gambling-bot-shared 0.1.51 → 0.1.53

package/README.MD

@@ -34,4 +34,14 @@ in the case study linked above.
 
 ## Local development
 
-See [LOCAL_DEVELOPMENT.md](./LOCAL_DEVELOPMENT.md) for the local linking workflow, debugging commands, and release process.
+Bootstrap all three repos in one step:
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/krouskystepan/gambling-bot-shared/main/scripts/setup-workspace.sh | bash
+```
+
+See [docs/LOCAL_DEVELOPMENT.md](./docs/LOCAL_DEVELOPMENT.md) for the local linking workflow, debugging commands, and CI release process.
+
+## GitHub / CI
+
+See [docs/GITHUB_SETUP.md](./docs/GITHUB_SETUP.md) for CI workflows and branch protection on `main`.

package/dist/constants/blackjack.d.ts

@@ -0,0 +1,41 @@
+export declare const SUITES: readonly ["♠️", "♣️", "♥️", "♦️"];
+export declare const VALUES: readonly [{
+    readonly label: "A";
+    readonly value: 11;
+}, {
+    readonly label: "2";
+    readonly value: 2;
+}, {
+    readonly label: "3";
+    readonly value: 3;
+}, {
+    readonly label: "4";
+    readonly value: 4;
+}, {
+    readonly label: "5";
+    readonly value: 5;
+}, {
+    readonly label: "6";
+    readonly value: 6;
+}, {
+    readonly label: "7";
+    readonly value: 7;
+}, {
+    readonly label: "8";
+    readonly value: 8;
+}, {
+    readonly label: "9";
+    readonly value: 9;
+}, {
+    readonly label: "10";
+    readonly value: 10;
+}, {
+    readonly label: "J";
+    readonly value: 10;
+}, {
+    readonly label: "Q";
+    readonly value: 10;
+}, {
+    readonly label: "K";
+    readonly value: 10;
+}];

package/dist/constants/blackjack.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VALUES = exports.SUITES = void 0;
+exports.SUITES = ['♠️', '♣️', '♥️', '♦️'];
+exports.VALUES = [
+    { label: 'A', value: 11 },
+    { label: '2', value: 2 },
+    { label: '3', value: 3 },
+    { label: '4', value: 4 },
+    { label: '5', value: 5 },
+    { label: '6', value: 6 },
+    { label: '7', value: 7 },
+    { label: '8', value: 8 },
+    { label: '9', value: 9 },
+    { label: '10', value: 10 },
+    { label: 'J', value: 10 },
+    { label: 'Q', value: 10 },
+    { label: 'K', value: 10 }
+];

package/dist/constants/defaultConfig.d.ts

@@ -95,4 +95,14 @@ export declare const defaultCasinoSettings: {
         maxBet: number;
         minBet: number;
     };
+    winAnnouncements: {
+        plinkoMinMultiplier: number;
+        goldenJackpotMinMultiplier: number;
+        slotsMinMultiplier: number;
+        lotteryMinMultiplier: number;
+        rouletteMinMultiplier: number;
+        blackjackMinMultiplier: number;
+        diceMinMultiplier: number;
+        coinflipMinMultiplier: number;
+    };
 };

package/dist/constants/defaultConfig.js

@@ -8,7 +8,18 @@ exports.readableGameValueNames = [
     { name: 'Win Multipliers (x)', value: 'winMultipliers' },
     { name: 'Casino House Cut (%)', value: 'casinoCut' },
     { name: 'One-In Chance (e.g. 1 in 10,000)', value: 'oneInChance' },
-    { name: 'Symbol Weights', value: 'symbolWeights' }
+    { name: 'Symbol Weights', value: 'symbolWeights' },
+    { name: 'Plinko Minimum Multiplier', value: 'plinkoMinMultiplier' },
+    {
+        name: 'Golden Jackpot Minimum Multiplier',
+        value: 'goldenJackpotMinMultiplier'
+    },
+    { name: 'Slots Minimum Multiplier', value: 'slotsMinMultiplier' },
+    { name: 'Dice Minimum Multiplier', value: 'diceMinMultiplier' },
+    { name: 'Coin Flip Minimum Multiplier', value: 'coinflipMinMultiplier' },
+    { name: 'Lottery Minimum Multiplier', value: 'lotteryMinMultiplier' },
+    { name: 'Roulette Minimum Multiplier', value: 'rouletteMinMultiplier' },
+    { name: 'Blackjack Minimum Multiplier', value: 'blackjackMinMultiplier' }
 ];
 exports.readableGameNames = [
     { name: 'Dice', value: 'dice' },
@@ -21,7 +32,8 @@ exports.readableGameNames = [
     { name: 'Blackjack', value: 'blackjack' },
     { name: 'Prediction', value: 'prediction' },
     { name: 'Raffle', value: 'raffle' },
-    { name: 'Plinko', value: 'plinko' }
+    { name: 'Plinko', value: 'plinko' },
+    { name: 'Win Announcements', value: 'winAnnouncements' }
 ];
 exports.defaultCasinoSettings = {
     dice: {
@@ -111,5 +123,15 @@ exports.defaultCasinoSettings = {
         },
         maxBet: 0,
         minBet: 0
+    },
+    winAnnouncements: {
+        plinkoMinMultiplier: 6,
+        goldenJackpotMinMultiplier: 1,
+        slotsMinMultiplier: 100,
+        lotteryMinMultiplier: 40,
+        rouletteMinMultiplier: 18,
+        blackjackMinMultiplier: 2.5,
+        diceMinMultiplier: 0,
+        coinflipMinMultiplier: 0
     }
 };

package/dist/constants/index.d.ts

@@ -8,3 +8,4 @@ export * from './rouletteConfig';
 export * from './gameRecordFields';
 export * from './plinkoConfig';
 export * from './transaction';
+export * from './blackjack';

package/dist/constants/index.js

@@ -24,3 +24,4 @@ __exportStar(require("./rouletteConfig"), exports);
 __exportStar(require("./gameRecordFields"), exports);
 __exportStar(require("./plinkoConfig"), exports);
 __exportStar(require("./transaction"), exports);
+__exportStar(require("./blackjack"), exports);

package/dist/constants/plinkoConfig.js

@@ -69,6 +69,9 @@ const getPlinkoMultiplierAtPathIndex = (binMultipliers, pathIndex) => {
 exports.getPlinkoMultiplierAtPathIndex = getPlinkoMultiplierAtPathIndex;
 const formatPlinkoBinMultipliersForDisplay = (binMultipliers) => {
     const normalized = (0, exports.normalizePlinkoBinMultipliers)(binMultipliers);
-    return Object.fromEntries(exports.PLINKO_EDITABLE_BINS.map((bin) => [String(bin), plinkoBinAt(normalized, bin)]));
+    return Object.fromEntries(exports.PLINKO_EDITABLE_BINS.map((bin) => [
+        String(bin),
+        plinkoBinAt(normalized, bin)
+    ]));
 };
 exports.formatPlinkoBinMultipliersForDisplay = formatPlinkoBinMultipliersForDisplay;

package/dist/constants/rouletteConfig.js

@@ -20,5 +20,5 @@ exports.MINI_NUMBERS = {
     '11': 'black',
     '13': 'black',
     '15': 'black',
-    '17': 'black',
+    '17': 'black'
 };

package/dist/mongoose/atmRequest.schema.d.ts

@@ -0,0 +1,139 @@
+import { Schema } from 'mongoose';
+import { TAtmRequest } from '../types';
+export declare const AtmRequestSchema: Schema<TAtmRequest, import("mongoose").Model<TAtmRequest, any, any, any, (import("mongoose").Document<unknown, any, TAtmRequest, any, import("mongoose").DefaultSchemaOptions> & TAtmRequest & {
+    _id: import("mongoose").Types.ObjectId;
+} & {
+    __v: number;
+} & {
+    id: string;
+}) | (import("mongoose").Document<unknown, any, TAtmRequest, any, import("mongoose").DefaultSchemaOptions> & TAtmRequest & {
+    _id: import("mongoose").Types.ObjectId;
+} & {
+    __v: number;
+}), any, TAtmRequest>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, TAtmRequest, import("mongoose").Document<unknown, {}, TAtmRequest, {
+    id: string;
+}, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TAtmRequest & {
+    _id: import("mongoose").Types.ObjectId;
+} & {
+    __v: number;
+}, "id"> & {
+    id: string;
+}, {
+    requestId?: import("mongoose").SchemaDefinitionProperty<string, TAtmRequest, import("mongoose").Document<unknown, {}, TAtmRequest, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TAtmRequest & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    guildId?: import("mongoose").SchemaDefinitionProperty<string, TAtmRequest, import("mongoose").Document<unknown, {}, TAtmRequest, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TAtmRequest & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    userId?: import("mongoose").SchemaDefinitionProperty<string, TAtmRequest, import("mongoose").Document<unknown, {}, TAtmRequest, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TAtmRequest & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    type?: import("mongoose").SchemaDefinitionProperty<"deposit" | "withdraw", TAtmRequest, import("mongoose").Document<unknown, {}, TAtmRequest, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TAtmRequest & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    amount?: import("mongoose").SchemaDefinitionProperty<number, TAtmRequest, import("mongoose").Document<unknown, {}, TAtmRequest, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TAtmRequest & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    account?: import("mongoose").SchemaDefinitionProperty<string, TAtmRequest, import("mongoose").Document<unknown, {}, TAtmRequest, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TAtmRequest & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    status?: import("mongoose").SchemaDefinitionProperty<"pending" | "approved" | "rejected", TAtmRequest, import("mongoose").Document<unknown, {}, TAtmRequest, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TAtmRequest & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    handledBy?: import("mongoose").SchemaDefinitionProperty<string | undefined, TAtmRequest, import("mongoose").Document<unknown, {}, TAtmRequest, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TAtmRequest & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    handledAt?: import("mongoose").SchemaDefinitionProperty<Date | undefined, TAtmRequest, import("mongoose").Document<unknown, {}, TAtmRequest, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TAtmRequest & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    logChannelId?: import("mongoose").SchemaDefinitionProperty<string, TAtmRequest, import("mongoose").Document<unknown, {}, TAtmRequest, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TAtmRequest & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    logMessageId?: import("mongoose").SchemaDefinitionProperty<string, TAtmRequest, import("mongoose").Document<unknown, {}, TAtmRequest, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TAtmRequest & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    createdAt?: import("mongoose").SchemaDefinitionProperty<Date, TAtmRequest, import("mongoose").Document<unknown, {}, TAtmRequest, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TAtmRequest & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    updatedAt?: import("mongoose").SchemaDefinitionProperty<Date, TAtmRequest, import("mongoose").Document<unknown, {}, TAtmRequest, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TAtmRequest & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+}, TAtmRequest>;

package/dist/mongoose/atmRequest.schema.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AtmRequestSchema = void 0;
+const mongoose_1 = require("mongoose");
+exports.AtmRequestSchema = new mongoose_1.Schema({
+    requestId: { type: String, required: true, unique: true },
+    guildId: { type: String, required: true, index: true },
+    userId: { type: String, required: true, index: true },
+    type: { type: String, enum: ['deposit', 'withdraw'], required: true },
+    amount: { type: Number, required: true, min: 1 },
+    account: { type: String, required: true },
+    status: {
+        type: String,
+        enum: ['pending', 'approved', 'rejected'],
+        required: true,
+        default: 'pending',
+        index: true
+    },
+    handledBy: { type: String },
+    handledAt: { type: Date },
+    logChannelId: { type: String },
+    logMessageId: { type: String }
+}, { timestamps: true });

package/dist/mongoose/blackjackGame.schema.d.ts

@@ -0,0 +1,139 @@
+import { Schema } from 'mongoose';
+import { TBlackjackGame, TBlackjackHand } from '../types';
+export declare const BlackjackGameSchema: Schema<TBlackjackGame, import("mongoose").Model<TBlackjackGame, any, any, any, (import("mongoose").Document<unknown, any, TBlackjackGame, any, import("mongoose").DefaultSchemaOptions> & TBlackjackGame & {
+    _id: import("mongoose").Types.ObjectId;
+} & {
+    __v: number;
+} & {
+    id: string;
+}) | (import("mongoose").Document<unknown, any, TBlackjackGame, any, import("mongoose").DefaultSchemaOptions> & TBlackjackGame & {
+    _id: import("mongoose").Types.ObjectId;
+} & {
+    __v: number;
+}), any, TBlackjackGame>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, TBlackjackGame, import("mongoose").Document<unknown, {}, TBlackjackGame, {
+    id: string;
+}, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TBlackjackGame & {
+    _id: import("mongoose").Types.ObjectId;
+} & {
+    __v: number;
+}, "id"> & {
+    id: string;
+}, {
+    userId?: import("mongoose").SchemaDefinitionProperty<string, TBlackjackGame, import("mongoose").Document<unknown, {}, TBlackjackGame, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TBlackjackGame & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    guildId?: import("mongoose").SchemaDefinitionProperty<string, TBlackjackGame, import("mongoose").Document<unknown, {}, TBlackjackGame, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TBlackjackGame & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    channelId?: import("mongoose").SchemaDefinitionProperty<string, TBlackjackGame, import("mongoose").Document<unknown, {}, TBlackjackGame, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TBlackjackGame & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    messageId?: import("mongoose").SchemaDefinitionProperty<string, TBlackjackGame, import("mongoose").Document<unknown, {}, TBlackjackGame, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TBlackjackGame & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    betId?: import("mongoose").SchemaDefinitionProperty<string, TBlackjackGame, import("mongoose").Document<unknown, {}, TBlackjackGame, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TBlackjackGame & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    deck?: import("mongoose").SchemaDefinitionProperty<import("../types").Card[], TBlackjackGame, import("mongoose").Document<unknown, {}, TBlackjackGame, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TBlackjackGame & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    deckIndex?: import("mongoose").SchemaDefinitionProperty<number, TBlackjackGame, import("mongoose").Document<unknown, {}, TBlackjackGame, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TBlackjackGame & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    hands?: import("mongoose").SchemaDefinitionProperty<TBlackjackHand[], TBlackjackGame, import("mongoose").Document<unknown, {}, TBlackjackGame, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TBlackjackGame & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    activeHandIndex?: import("mongoose").SchemaDefinitionProperty<number, TBlackjackGame, import("mongoose").Document<unknown, {}, TBlackjackGame, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TBlackjackGame & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    phase?: import("mongoose").SchemaDefinitionProperty<import("../types").GamePhase, TBlackjackGame, import("mongoose").Document<unknown, {}, TBlackjackGame, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TBlackjackGame & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    dealerCards?: import("mongoose").SchemaDefinitionProperty<import("../types").Card[], TBlackjackGame, import("mongoose").Document<unknown, {}, TBlackjackGame, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TBlackjackGame & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    createdAt?: import("mongoose").SchemaDefinitionProperty<Date, TBlackjackGame, import("mongoose").Document<unknown, {}, TBlackjackGame, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TBlackjackGame & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+    updatedAt?: import("mongoose").SchemaDefinitionProperty<Date, TBlackjackGame, import("mongoose").Document<unknown, {}, TBlackjackGame, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TBlackjackGame & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+}, TBlackjackGame>;

package/dist/mongoose/blackjackGame.schema.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlackjackGameSchema = void 0;
+const mongoose_1 = require("mongoose");
+const cardSchema = {
+    suite: { type: String, required: true },
+    label: { type: String, required: true },
+    value: { type: Number, required: true }
+};
+const handSchema = new mongoose_1.Schema({
+    cards: [cardSchema],
+    betAmount: { type: Number, required: true },
+    finished: { type: Boolean, required: true, default: false },
+    isSplitHand: { type: Boolean, required: true, default: false }
+}, { _id: false });
+exports.BlackjackGameSchema = new mongoose_1.Schema({
+    userId: { type: String, required: true, index: true },
+    guildId: { type: String, required: true, index: true },
+    channelId: { type: String, required: true },
+    messageId: { type: String, required: true },
+    betId: { type: String, required: true, index: true },
+    deck: [cardSchema],
+    deckIndex: { type: Number, required: true, default: 0 },
+    hands: { type: [handSchema], required: true, default: [] },
+    phase: {
+        type: String,
+        enum: ['PLAYER', 'DEALER', 'FINISHED'],
+        required: true,
+        default: 'PLAYER'
+    },
+    activeHandIndex: { type: Number, required: true, default: 0 },
+    dealerCards: [cardSchema]
+}, { timestamps: true });
+exports.BlackjackGameSchema.index({ userId: 1, guildId: 1 }, { unique: true });

package/dist/mongoose/guildConfiguration.schema.d.ts

@@ -49,6 +49,15 @@ export declare const GuildConfigurationSchema: Schema<TGuildConfiguration, impor
     }, "id"> & {
         id: string;
     }> | undefined;
+    winAnnouncementsChannelId?: import("mongoose").SchemaDefinitionProperty<string, TGuildConfiguration, import("mongoose").Document<unknown, {}, TGuildConfiguration, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TGuildConfiguration & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
     predictionChannelIds?: import("mongoose").SchemaDefinitionProperty<{
         actions: string;
         logs: string;
@@ -171,6 +180,16 @@ export declare const GuildConfigurationSchema: Schema<TGuildConfiguration, impor
             maxBet: number;
             minBet: number;
         };
+        winAnnouncements: {
+            plinkoMinMultiplier: number;
+            goldenJackpotMinMultiplier: number;
+            slotsMinMultiplier: number;
+            lotteryMinMultiplier: number;
+            rouletteMinMultiplier: number;
+            blackjackMinMultiplier: number;
+            diceMinMultiplier: number;
+            coinflipMinMultiplier: number;
+        };
     }, TGuildConfiguration, import("mongoose").Document<unknown, {}, TGuildConfiguration, {
         id: string;
     }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TGuildConfiguration & {

package/dist/mongoose/guildConfiguration.schema.js

@@ -24,6 +24,10 @@ exports.GuildConfigurationSchema = new mongoose_1.Schema({
         type: [String],
         default: []
     },
+    winAnnouncementsChannelId: {
+        type: String,
+        default: ''
+    },
     predictionChannelIds: {
         actions: {
             type: String,

package/dist/mongoose/index.d.ts

@@ -3,3 +3,6 @@ export * from './vipRoom.schema';
 export * from './prediction.schema';
 export * from './transaction.schema';
 export * from './guildConfiguration.schema';
+export * from './atmRequest.schema';
+export * from './raffle.schema';
+export * from './blackjackGame.schema';

package/dist/mongoose/index.js

@@ -19,3 +19,6 @@ __exportStar(require("./vipRoom.schema"), exports);
 __exportStar(require("./prediction.schema"), exports);
 __exportStar(require("./transaction.schema"), exports);
 __exportStar(require("./guildConfiguration.schema"), exports);
+__exportStar(require("./atmRequest.schema"), exports);
+__exportStar(require("./raffle.schema"), exports);
+__exportStar(require("./blackjackGame.schema"), exports);

package/dist/mongoose/prediction.schema.js

@@ -5,23 +5,23 @@ const mongoose_1 = require("mongoose");
 exports.PredictionSchema = new mongoose_1.Schema({
     predictionId: {
         type: String,
-        required: true,
+        required: true
     },
     guildId: {
         type: String,
-        required: true,
+        required: true
     },
     channelId: {
         type: String,
-        required: true,
+        required: true
     },
     creatorId: {
         type: String,
-        required: true,
+        required: true
     },
     title: {
         type: String,
-        required: true,
+        required: true
     },
     choices: [
         {
@@ -30,20 +30,20 @@ exports.PredictionSchema = new mongoose_1.Schema({
             bets: [
                 {
                     userId: { type: String, required: true },
-                    amount: { type: Number, required: true },
-                },
-            ],
-        },
+                    amount: { type: Number, required: true }
+                }
+            ]
+        }
     ],
     status: {
         type: String,
         enum: ['active', 'ended', 'paid', 'canceled'],
-        default: 'active',
+        default: 'active'
     },
     autolock: {
         type: Date,
         required: false,
-        default: null,
-    },
+        default: null
+    }
 }, { timestamps: true });
 exports.PredictionSchema.index({ predictionId: 1, guildId: 1 }, { unique: true });

package/dist/mongoose/raffle.schema.d.ts

@@ -0,0 +1,151 @@
+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, {
+    id: string;
+}, import("mongoose").ResolveSchemaOptions<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").ResolveSchemaOptions<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").ResolveSchemaOptions<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").ResolveSchemaOptions<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").ResolveSchemaOptions<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").ResolveSchemaOptions<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").ResolveSchemaOptions<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").ResolveSchemaOptions<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").ResolveSchemaOptions<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").ResolveSchemaOptions<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").ResolveSchemaOptions<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, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<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, {
+        id: string;
+    }, import("mongoose").ResolveSchemaOptions<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").ResolveSchemaOptions<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").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TRaffle & {
+        _id: import("mongoose").Types.ObjectId;
+    } & {
+        __v: number;
+    }, "id"> & {
+        id: string;
+    }> | undefined;
+}, TRaffle>;

package/dist/mongoose/raffle.schema.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RaffleSchema = void 0;
+const mongoose_1 = require("mongoose");
+exports.RaffleSchema = new mongoose_1.Schema({
+    drawId: { type: String, required: true },
+    raffleId: { type: String, required: true },
+    guildId: { type: String, required: true, index: true },
+    channelId: { type: String, required: true },
+    creatorId: { type: String, required: true },
+    ticketPrice: { type: Number, required: true, min: 1 },
+    maxTicketsPerUser: { type: Number, required: true, min: 1 },
+    nextDrawAt: { type: Date, required: true },
+    lastDrawAt: { type: Date },
+    drawIntervalMs: { type: Number, required: true, min: 1 },
+    status: {
+        type: String,
+        enum: ['active', 'canceled'],
+        default: 'active',
+        index: true
+    },
+    participants: [
+        {
+            userId: { type: String, required: true },
+            tickets: { type: Number, required: true, min: 1 }
+        }
+    ]
+}, { timestamps: true });
+exports.RaffleSchema.index({ raffleId: 1 }, { unique: true });

package/dist/mongoose/transaction.schema.d.ts

@@ -64,7 +64,7 @@ export declare const TransactionSchema: Schema<TTransaction, import("mongoose").
     }, "id"> & {
         id: string;
     }> | undefined;
-    meta?: import("mongoose").SchemaDefinitionProperty<Record<string, any> | undefined, TTransaction, import("mongoose").Document<unknown, {}, TTransaction, {
+    meta?: import("mongoose").SchemaDefinitionProperty<Record<string, unknown> | undefined, TTransaction, import("mongoose").Document<unknown, {}, TTransaction, {
         id: string;
     }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TTransaction & {
         _id: import("mongoose").Types.ObjectId;

package/dist/mongoose/vipRoom.schema.js

@@ -8,9 +8,9 @@ exports.VipRoomSchema = new mongoose_1.Schema({
     channelId: { type: String, required: true },
     memberIds: {
         type: [String],
-        default: [],
+        default: []
     },
-    expiresAt: { type: Date, required: true },
+    expiresAt: { type: Date, required: true }
 }, { timestamps: true });
 exports.VipRoomSchema.index({ expiresAt: 1 });
 exports.VipRoomSchema.index({ ownerId: 1, guildId: 1 }, { unique: true });

package/dist/schemas/forms.d.ts

@@ -5,6 +5,7 @@ export declare const atmChannelsFormSchema: z.ZodObject<{
 }, z.core.$strip>;
 export declare const casinoChannelsFormSchema: z.ZodObject<{
     casinoChannelIds: z.ZodArray<z.ZodString>;
+    winAnnouncementsChannelId: z.ZodString;
 }, z.core.$strip>;
 export declare const predictionChannelsFormSchema: z.ZodObject<{
     actions: z.ZodString;
@@ -21,6 +22,7 @@ export declare const channelsFormSchema: z.ZodObject<{
     }, z.core.$strip>;
     casino: z.ZodObject<{
         casinoChannelIds: z.ZodArray<z.ZodString>;
+        winAnnouncementsChannelId: z.ZodString;
     }, z.core.$strip>;
     prediction: z.ZodObject<{
         actions: z.ZodString;
@@ -95,6 +97,16 @@ export declare const casinoSettingsSchema: z.ZodObject<{
         minBet: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>, z.ZodNumber>;
         maxBet: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>, z.ZodNumber>;
     }, z.core.$strip>;
+    winAnnouncements: z.ZodObject<{
+        plinkoMinMultiplier: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>, z.ZodNumber>;
+        goldenJackpotMinMultiplier: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>, z.ZodNumber>;
+        slotsMinMultiplier: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>, z.ZodNumber>;
+        lotteryMinMultiplier: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>, z.ZodNumber>;
+        rouletteMinMultiplier: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>, z.ZodNumber>;
+        blackjackMinMultiplier: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>, z.ZodNumber>;
+        diceMinMultiplier: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>, z.ZodNumber>;
+        coinflipMinMultiplier: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>, z.ZodNumber>;
+    }, z.core.$strip>;
 }, z.core.$strip>;
 export declare const vipSettingsFormSchema: z.ZodObject<{
     roleOwnerId: z.ZodString;

package/dist/schemas/forms.js

@@ -5,26 +5,24 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.bonusFormSchema = exports.globalSettingsFormSchema = exports.managerRoleFormSchema = exports.vipSettingsFormSchema = exports.casinoSettingsSchema = exports.channelsFormSchema = exports.raffleChannelsFormSchema = exports.predictionChannelsFormSchema = exports.casinoChannelsFormSchema = exports.atmChannelsFormSchema = void 0;
 const zod_1 = __importDefault(require("zod"));
-const commonTimezones_1 = require("../constants/commonTimezones");
 const bonusLimits_1 = require("../constants/bonusLimits");
+const commonTimezones_1 = require("../constants/commonTimezones");
 const plinkoConfig_1 = require("../constants/plinkoConfig");
-const NO_CHANNEL = 'At least one channel must be selected.';
 exports.atmChannelsFormSchema = zod_1.default.object({
-    actions: zod_1.default.string().min(1, { message: NO_CHANNEL }),
-    logs: zod_1.default.string().min(1, { message: NO_CHANNEL })
+    actions: zod_1.default.string(),
+    logs: zod_1.default.string()
 });
 exports.casinoChannelsFormSchema = zod_1.default.object({
-    casinoChannelIds: zod_1.default
-        .array(zod_1.default.string().min(1, { message: NO_CHANNEL }))
-        .min(1, { message: NO_CHANNEL })
+    casinoChannelIds: zod_1.default.array(zod_1.default.string()),
+    winAnnouncementsChannelId: zod_1.default.string()
 });
 exports.predictionChannelsFormSchema = zod_1.default.object({
-    actions: zod_1.default.string().min(1, { message: NO_CHANNEL }),
-    logs: zod_1.default.string().min(1, { message: NO_CHANNEL })
+    actions: zod_1.default.string(),
+    logs: zod_1.default.string()
 });
 exports.raffleChannelsFormSchema = zod_1.default.object({
-    actions: zod_1.default.string().min(1, { message: NO_CHANNEL }),
-    logs: zod_1.default.string().min(1, { message: NO_CHANNEL })
+    actions: zod_1.default.string(),
+    logs: zod_1.default.string()
 });
 exports.channelsFormSchema = zod_1.default.object({
     atm: exports.atmChannelsFormSchema,
@@ -96,19 +94,29 @@ exports.casinoSettingsSchema = zod_1.default.object({
             .transform(plinkoConfig_1.normalizePlinkoBinMultipliers),
         minBet: num,
         maxBet: num
+    }),
+    winAnnouncements: zod_1.default.object({
+        plinkoMinMultiplier: num,
+        goldenJackpotMinMultiplier: num,
+        slotsMinMultiplier: num,
+        lotteryMinMultiplier: num,
+        rouletteMinMultiplier: num,
+        blackjackMinMultiplier: num,
+        diceMinMultiplier: num,
+        coinflipMinMultiplier: num
     })
 });
 exports.vipSettingsFormSchema = zod_1.default.object({
-    roleOwnerId: zod_1.default.string().min(1, 'Select a Owner VIP role'),
-    roleMemberId: zod_1.default.string().min(1, 'Select a Member VIP role'),
+    roleOwnerId: zod_1.default.string(),
+    roleMemberId: zod_1.default.string(),
     pricePerDay: zod_1.default.number().min(0, 'Must be ≥ 0'),
     pricePerCreate: zod_1.default.number().min(0, 'Must be ≥ 0'),
     pricePerAdditionalMember: zod_1.default.number().min(0, 'Must be ≥ 0'),
     maxMembers: zod_1.default.number().min(0, 'Must be ≥ 0'),
-    categoryId: zod_1.default.string().min(1, 'Select a category')
+    categoryId: zod_1.default.string()
 });
 exports.managerRoleFormSchema = zod_1.default.object({
-    managerRoleId: zod_1.default.string().min(1, 'Select a manager role')
+    managerRoleId: zod_1.default.string()
 });
 const bonusAmountSchema = zod_1.default
     .number()

package/dist/types/atmRequest.d.ts

@@ -0,0 +1,15 @@
+export type TAtmRequest = {
+    requestId: string;
+    guildId: string;
+    userId: string;
+    type: 'deposit' | 'withdraw';
+    amount: number;
+    account: string;
+    status: 'pending' | 'approved' | 'rejected';
+    handledBy?: string;
+    handledAt?: Date;
+    logChannelId: string;
+    logMessageId: string;
+    createdAt: Date;
+    updatedAt: Date;
+};

package/dist/types/atmRequest.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/blackjackGame.d.ts

@@ -0,0 +1,30 @@
+import { SUITES, VALUES } from '../constants/blackjack';
+export type Suite = (typeof SUITES)[number];
+export type CardLabel = (typeof VALUES)[number]['label'];
+export type Card = {
+    suite: Suite;
+    label: CardLabel;
+    value: number;
+};
+export type GamePhase = 'PLAYER' | 'DEALER' | 'FINISHED';
+export type TBlackjackHand = {
+    cards: Card[];
+    betAmount: number;
+    finished: boolean;
+    isSplitHand: boolean;
+};
+export type TBlackjackGame = {
+    userId: string;
+    guildId: string;
+    channelId: string;
+    messageId: string;
+    betId: string;
+    deck: Card[];
+    deckIndex: number;
+    hands: TBlackjackHand[];
+    activeHandIndex: number;
+    phase: GamePhase;
+    dealerCards: Card[];
+    createdAt: Date;
+    updatedAt: Date;
+};

package/dist/types/blackjackGame.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/guildConfiguration.d.ts

@@ -9,6 +9,7 @@ export type TGuildConfiguration = {
         logs: string;
     };
     casinoChannelIds: string[];
+    winAnnouncementsChannelId: string;
     predictionChannelIds: {
         actions: string;
         logs: string;

package/dist/types/index.d.ts

@@ -5,4 +5,7 @@ export * from './vipRoom';
 export * from './prediction';
 export * from './transaction';
 export * from './guildConfiguration';
+export * from './atmRequest';
+export * from './raffle';
+export * from './blackjackGame';
 export * from './bonus';

package/dist/types/index.js

@@ -19,5 +19,8 @@ __exportStar(require("./vipRoom"), exports);
 __exportStar(require("./prediction"), exports);
 __exportStar(require("./transaction"), exports);
 __exportStar(require("./guildConfiguration"), exports);
+__exportStar(require("./atmRequest"), exports);
+__exportStar(require("./raffle"), exports);
+__exportStar(require("./blackjackGame"), exports);
 // No db
 __exportStar(require("./bonus"), exports);

package/dist/types/raffle.d.ts

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

package/dist/types/raffle.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/transaction.d.ts

@@ -4,7 +4,7 @@ export type TTransaction = {
     amount: number;
     type: 'deposit' | 'withdraw' | 'bet' | 'win' | 'refund' | 'bonus' | 'vip';
     source: 'command' | 'manual' | 'web' | 'system' | 'casino';
-    meta?: Record<string, any>;
+    meta?: Record<string, unknown>;
     betId?: string;
     handledBy?: string;
     createdAt: Date;

package/dist/utils/calculateBonusReward.js

@@ -8,8 +8,7 @@ const getCycleLength = (rewardMode, baseReward, maxReward, streakIncrement, stre
             : 1;
     }
     return streakMultiplier > 1
-        ? Math.floor(Math.log(maxReward / baseReward) / Math.log(streakMultiplier)) +
-            1
+        ? Math.floor(Math.log(maxReward / baseReward) / Math.log(streakMultiplier)) + 1
         : 1;
 };
 const calculateBonusReward = ({ streak, settings }) => {

package/dist/utils/index.d.ts

@@ -5,9 +5,11 @@ export * from './generateBonusPreview';
 export * from './formatters';
 export * from './globalSettings';
 export * from './normalizeGlobalSettings';
+export * from './normalizeCasinoSettings';
 export * from './guildTimezone';
 export * from './generateId';
 export * from './parseTimeToSeconds';
 export * from './validateBetAmount';
 export * from './bonusStreak';
 export * from './validatePredictionBet';
+export * from './winAnnouncements';

package/dist/utils/index.js

@@ -21,9 +21,11 @@ __exportStar(require("./generateBonusPreview"), exports);
 __exportStar(require("./formatters"), exports);
 __exportStar(require("./globalSettings"), exports);
 __exportStar(require("./normalizeGlobalSettings"), exports);
+__exportStar(require("./normalizeCasinoSettings"), exports);
 __exportStar(require("./guildTimezone"), exports);
 __exportStar(require("./generateId"), exports);
 __exportStar(require("./parseTimeToSeconds"), exports);
 __exportStar(require("./validateBetAmount"), exports);
 __exportStar(require("./bonusStreak"), exports);
 __exportStar(require("./validatePredictionBet"), exports);
+__exportStar(require("./winAnnouncements"), exports);

package/dist/utils/normalizeCasinoSettings.d.ts

@@ -0,0 +1,2 @@
+import type { TCasinoSettings } from '../types';
+export declare const normalizeCasinoSettings: (settings: Partial<TCasinoSettings> | null | undefined) => TCasinoSettings;

package/dist/utils/normalizeCasinoSettings.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeCasinoSettings = void 0;
+const constants_1 = require("../constants");
+const plinkoConfig_1 = require("../constants/plinkoConfig");
+const isPlainObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const deepMerge = (base, patch) => {
+    if (!patch)
+        return { ...base };
+    const result = { ...base };
+    for (const [key, patchValue] of Object.entries(patch)) {
+        const baseValue = base[key];
+        if (isPlainObject(baseValue) && isPlainObject(patchValue)) {
+            result[key] = deepMerge(baseValue, patchValue);
+            continue;
+        }
+        if (patchValue !== undefined) {
+            result[key] = patchValue;
+        }
+    }
+    return result;
+};
+const normalizeCasinoSettings = (settings) => {
+    const merged = deepMerge(constants_1.defaultCasinoSettings, settings);
+    return {
+        ...merged,
+        plinko: {
+            ...merged.plinko,
+            binMultipliers: (0, plinkoConfig_1.normalizePlinkoBinMultipliers)(merged.plinko.binMultipliers)
+        }
+    };
+};
+exports.normalizeCasinoSettings = normalizeCasinoSettings;

package/dist/utils/normalizeGlobalSettings.js

@@ -20,8 +20,7 @@ const normalizeCurrencySymbol = (value) => {
 const normalizeCurrencyPlacement = (value) => value === 'suffix' ? 'suffix' : 'prefix';
 const normalizeTimezone = (value) => {
     const raw = typeof value === 'string' ? value.trim() : '';
-    if (raw.length > 0 &&
-        constants_1.COMMON_TIMEZONES.includes(raw)) {
+    if (raw.length > 0 && constants_1.COMMON_TIMEZONES.includes(raw)) {
         return raw;
     }
     return constants_1.defaultGlobalSettings.timezone;

package/dist/utils/winAnnouncements.d.ts

@@ -0,0 +1,4 @@
+/** minMultiplier <= 0 disables announcements for that game */
+export declare const shouldAnnounceByMultiplier: (multiplier: number, minMultiplier: number) => boolean;
+export declare const shouldAnnouncePlinkoBall: (multiplier: number, plinkoMinMultiplier: number) => boolean;
+export declare const shouldAnnounceGoldenJackpotHit: (winMultiplier: number, goldenJackpotMinMultiplier: number) => boolean;

package/dist/utils/winAnnouncements.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldAnnounceGoldenJackpotHit = exports.shouldAnnouncePlinkoBall = exports.shouldAnnounceByMultiplier = void 0;
+/** minMultiplier <= 0 disables announcements for that game */
+const shouldAnnounceByMultiplier = (multiplier, minMultiplier) => minMultiplier > 0 && multiplier >= minMultiplier;
+exports.shouldAnnounceByMultiplier = shouldAnnounceByMultiplier;
+const shouldAnnouncePlinkoBall = (multiplier, plinkoMinMultiplier) => (0, exports.shouldAnnounceByMultiplier)(multiplier, plinkoMinMultiplier);
+exports.shouldAnnouncePlinkoBall = shouldAnnouncePlinkoBall;
+const shouldAnnounceGoldenJackpotHit = (winMultiplier, goldenJackpotMinMultiplier) => (0, exports.shouldAnnounceByMultiplier)(winMultiplier, goldenJackpotMinMultiplier);
+exports.shouldAnnounceGoldenJackpotHit = shouldAnnounceGoldenJackpotHit;

package/package.json

@@ -1,10 +1,14 @@
 {
   "name": "gambling-bot-shared",
-  "version": "0.1.51",
+  "version": "0.1.53",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "license": "MIT",
   "type": "commonjs",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/krouskystepan/gambling-bot-shared.git"
+  },
   "files": [
     "dist"
   ],
@@ -25,25 +29,36 @@
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "dev": "tsc -p tsconfig.json --watch",
+    "format:check": "prettier --check \"src/**/*.ts\"",
+    "format:fix": "prettier --write \"src/**/*.ts\"",
+    "lint:check": "eslint src --max-warnings 0",
+    "lint:fix": "eslint src --fix --max-warnings 0",
+    "type:check": "tsc --noEmit",
+    "check": "pnpm format:check && pnpm lint:check && pnpm type:check",
     "prepublishOnly": "pnpm build",
     "prepare": "bash scripts/setup-git-hooks.sh",
     "link-local": "bash scripts/link-local.sh",
     "unlink-local": "bash scripts/unlink-local.sh",
     "link-status": "bash scripts/shared-link-status.sh",
-    "release": "bash scripts/release.sh",
-    "publish-and-bump-projects": "bash scripts/release.sh --no-bump",
-    "publish-to-npm": "bash scripts/publish-to-npm.sh"
+    "setup-workspace": "bash scripts/setup-workspace.sh",
+    "bump": "bash scripts/bump.sh"
   },
   "peerDependencies": {
     "mongoose": "^9.0.0"
   },
   "devDependencies": {
+    "@trivago/prettier-plugin-sort-imports": "^6.0.2",
     "@types/luxon": "^3.7.1",
+    "@typescript-eslint/eslint-plugin": "^8.59.4",
+    "@typescript-eslint/parser": "^8.59.4",
+    "eslint": "^10.4.0",
     "mongoose": "^9.1.4",
+    "prettier": "^3.8.3",
     "typescript": "^5.9.3"
   },
   "dependencies": {
     "luxon": "^3.7.2",
     "zod": "^4.3.6"
-  }
+  },
+  "packageManager": "pnpm@10.28.0"
 }