gambling-bot-shared 0.1.54 → 1.0.1

package/dist/guild/index.js

@@ -0,0 +1,26 @@
+"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.GuildConfigurationSchema = void 0;
+__exportStar(require("./constants/defaultGlobalSettings"), exports);
+__exportStar(require("./constants/commonTimezones"), exports);
+__exportStar(require("./types/guildConfiguration"), exports);
+__exportStar(require("./utils/globalSettings"), exports);
+__exportStar(require("./utils/normalizeGlobalSettings"), exports);
+__exportStar(require("./utils/guildTimezone"), exports);
+__exportStar(require("./schemas/guild.forms"), exports);
+var guildConfiguration_mongoose_1 = require("./guildConfiguration.mongoose");
+Object.defineProperty(exports, "GuildConfigurationSchema", { enumerable: true, get: function () { return guildConfiguration_mongoose_1.GuildConfigurationSchema; } });

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

@@ -0,0 +1,68 @@
+import z from 'zod';
+export declare const channelsFormSchema: z.ZodObject<{
+    atm: z.ZodObject<{
+        actions: z.ZodString;
+        logs: z.ZodString;
+    }, z.core.$strip>;
+    casino: z.ZodObject<{
+        casinoChannelIds: z.ZodArray<z.ZodString>;
+        winAnnouncementsChannelId: z.ZodString;
+    }, z.core.$strip>;
+    prediction: z.ZodObject<{
+        actions: z.ZodString;
+        logs: z.ZodString;
+    }, z.core.$strip>;
+    raffle: z.ZodObject<{
+        actions: z.ZodString;
+        logs: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const managerRoleFormSchema: z.ZodObject<{
+    managerRoleId: z.ZodString;
+}, z.core.$strip>;
+export declare const globalSettingsFormSchema: z.ZodObject<{
+    disableRegistrations: z.ZodBoolean;
+    disableDeposits: z.ZodBoolean;
+    disableWithdrawals: z.ZodBoolean;
+    disableCasinoGames: z.ZodBoolean;
+    disableCasinoGamesForMods: z.ZodBoolean;
+    disablePredictions: z.ZodBoolean;
+    disablePredictionManagement: z.ZodBoolean;
+    disableRaffles: z.ZodBoolean;
+    disableRaffleManagement: z.ZodBoolean;
+    disableDailyBonus: z.ZodBoolean;
+    disableVip: z.ZodBoolean;
+    maintenanceMode: z.ZodBoolean;
+    timezone: z.ZodEnum<{
+        UTC: "UTC";
+        "Europe/London": "Europe/London";
+        "Europe/Paris": "Europe/Paris";
+        "Europe/Berlin": "Europe/Berlin";
+        "Europe/Prague": "Europe/Prague";
+        "Europe/Warsaw": "Europe/Warsaw";
+        "Europe/Athens": "Europe/Athens";
+        "Europe/Moscow": "Europe/Moscow";
+        "America/New_York": "America/New_York";
+        "America/Chicago": "America/Chicago";
+        "America/Denver": "America/Denver";
+        "America/Los_Angeles": "America/Los_Angeles";
+        "America/Toronto": "America/Toronto";
+        "America/Sao_Paulo": "America/Sao_Paulo";
+        "America/Mexico_City": "America/Mexico_City";
+        "Asia/Dubai": "Asia/Dubai";
+        "Asia/Kolkata": "Asia/Kolkata";
+        "Asia/Bangkok": "Asia/Bangkok";
+        "Asia/Singapore": "Asia/Singapore";
+        "Asia/Hong_Kong": "Asia/Hong_Kong";
+        "Asia/Tokyo": "Asia/Tokyo";
+        "Asia/Seoul": "Asia/Seoul";
+        "Australia/Sydney": "Australia/Sydney";
+        "Australia/Melbourne": "Australia/Melbourne";
+        "Pacific/Auckland": "Pacific/Auckland";
+    }>;
+    currencySymbol: z.ZodString;
+    currencyPlacement: z.ZodEnum<{
+        prefix: "prefix";
+        suffix: "suffix";
+    }>;
+}, z.core.$strip>;

package/dist/guild/schemas/guild.forms.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.globalSettingsFormSchema = exports.managerRoleFormSchema = exports.channelsFormSchema = void 0;
+const zod_1 = __importDefault(require("zod"));
+const atm_forms_1 = require("../../atm/schemas/atm.forms");
+const casino_forms_1 = require("../../casino/schemas/casino.forms");
+const prediction_forms_1 = require("../../predictions/schemas/prediction.forms");
+const raffle_forms_1 = require("../../raffle/schemas/raffle.forms");
+const commonTimezones_1 = require("../constants/commonTimezones");
+exports.channelsFormSchema = zod_1.default.object({
+    atm: atm_forms_1.atmChannelsFormSchema,
+    casino: casino_forms_1.casinoChannelsFormSchema,
+    prediction: prediction_forms_1.predictionChannelsFormSchema,
+    raffle: raffle_forms_1.raffleChannelsFormSchema
+});
+exports.managerRoleFormSchema = zod_1.default.object({
+    managerRoleId: zod_1.default.string()
+});
+exports.globalSettingsFormSchema = zod_1.default.object({
+    disableRegistrations: zod_1.default.boolean(),
+    disableDeposits: zod_1.default.boolean(),
+    disableWithdrawals: zod_1.default.boolean(),
+    disableCasinoGames: zod_1.default.boolean(),
+    disableCasinoGamesForMods: zod_1.default.boolean(),
+    disablePredictions: zod_1.default.boolean(),
+    disablePredictionManagement: zod_1.default.boolean(),
+    disableRaffles: zod_1.default.boolean(),
+    disableRaffleManagement: zod_1.default.boolean(),
+    disableDailyBonus: zod_1.default.boolean(),
+    disableVip: zod_1.default.boolean(),
+    maintenanceMode: zod_1.default.boolean(),
+    timezone: zod_1.default.enum(commonTimezones_1.COMMON_TIMEZONES),
+    currencySymbol: zod_1.default
+        .string()
+        .max(8)
+        .refine((value) => value.trim().length > 0, {
+        message: 'Currency symbol is required'
+    }),
+    currencyPlacement: zod_1.default.enum(['prefix', 'suffix'])
+});

package/dist/{types → guild/types}/guildConfiguration.d.ts

@@ -1,6 +1,6 @@
-import { defaultCasinoSettings } from '../constants';
+import type { BonusSettings } from '../../bonus/types/bonus';
+import { defaultCasinoSettings } from '../../casino/constants/defaultConfig';
 import type { GlobalSettings } from '../constants/defaultGlobalSettings';
-import { BonusSettings } from './bonus';
 export type RewardMode = 'linear' | 'exponential';
 export type TGuildConfiguration = {
     guildId: string;

package/dist/{utils → guild/utils}/normalizeGlobalSettings.d.ts

@@ -1,2 +1,2 @@
-import { type GlobalSettings } from '../constants';
+import { type GlobalSettings } from '../constants/defaultGlobalSettings';
 export declare const normalizeGlobalSettings: (settings: Partial<GlobalSettings> | null | undefined) => GlobalSettings;

package/dist/guild/utils/normalizeGlobalSettings.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeGlobalSettings = void 0;
+const commonTimezones_1 = require("../constants/commonTimezones");
+const defaultGlobalSettings_1 = require("../constants/defaultGlobalSettings");
+const coerceBool = (value, fallback) => {
+    if (typeof value === 'boolean')
+        return value;
+    if (value === 'true')
+        return true;
+    if (value === 'false')
+        return false;
+    return fallback;
+};
+const normalizeCurrencySymbol = (value) => {
+    if (typeof value !== 'string' || value.trim().length === 0) {
+        return defaultGlobalSettings_1.defaultGlobalSettings.currencySymbol;
+    }
+    return value.slice(0, 8);
+};
+const normalizeCurrencyPlacement = (value) => value === 'suffix' ? 'suffix' : 'prefix';
+const normalizeTimezone = (value) => {
+    const raw = typeof value === 'string' ? value.trim() : '';
+    if (raw.length > 0 && commonTimezones_1.COMMON_TIMEZONES.includes(raw)) {
+        return raw;
+    }
+    return defaultGlobalSettings_1.defaultGlobalSettings.timezone;
+};
+const normalizeGlobalSettings = (settings) => ({
+    disableRegistrations: coerceBool(settings?.disableRegistrations, defaultGlobalSettings_1.defaultGlobalSettings.disableRegistrations),
+    disableDeposits: coerceBool(settings?.disableDeposits, defaultGlobalSettings_1.defaultGlobalSettings.disableDeposits),
+    disableWithdrawals: coerceBool(settings?.disableWithdrawals, defaultGlobalSettings_1.defaultGlobalSettings.disableWithdrawals),
+    disableCasinoGames: coerceBool(settings?.disableCasinoGames, defaultGlobalSettings_1.defaultGlobalSettings.disableCasinoGames),
+    disableCasinoGamesForMods: coerceBool(settings?.disableCasinoGamesForMods, defaultGlobalSettings_1.defaultGlobalSettings.disableCasinoGamesForMods),
+    disablePredictions: coerceBool(settings?.disablePredictions, defaultGlobalSettings_1.defaultGlobalSettings.disablePredictions),
+    disablePredictionManagement: coerceBool(settings?.disablePredictionManagement, defaultGlobalSettings_1.defaultGlobalSettings.disablePredictionManagement),
+    disableRaffles: coerceBool(settings?.disableRaffles, defaultGlobalSettings_1.defaultGlobalSettings.disableRaffles),
+    disableRaffleManagement: coerceBool(settings?.disableRaffleManagement, defaultGlobalSettings_1.defaultGlobalSettings.disableRaffleManagement),
+    disableDailyBonus: coerceBool(settings?.disableDailyBonus, defaultGlobalSettings_1.defaultGlobalSettings.disableDailyBonus),
+    disableVip: coerceBool(settings?.disableVip, defaultGlobalSettings_1.defaultGlobalSettings.disableVip),
+    maintenanceMode: coerceBool(settings?.maintenanceMode, defaultGlobalSettings_1.defaultGlobalSettings.maintenanceMode),
+    timezone: normalizeTimezone(settings?.timezone),
+    currencySymbol: normalizeCurrencySymbol(settings?.currencySymbol),
+    currencyPlacement: normalizeCurrencyPlacement(settings?.currencyPlacement)
+});
+exports.normalizeGlobalSettings = normalizeGlobalSettings;

package/dist/mongoose/index.d.ts

@@ -1,8 +1,8 @@
-export * from './user.schema';
-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';
+export { UserSchema } from '../user/user.mongoose';
+export { VipRoomSchema } from '../vip/vipRoom.mongoose';
+export { PredictionSchema } from '../predictions/prediction.mongoose';
+export { TransactionSchema } from '../transactions/transaction.mongoose';
+export { GuildConfigurationSchema } from '../guild/guildConfiguration.mongoose';
+export { AtmRequestSchema } from '../atm/atmRequest.mongoose';
+export { RaffleSchema } from '../raffle/raffle.mongoose';
+export { BlackjackGameSchema } from '../casino/blackjackGame.mongoose';

package/dist/mongoose/index.js

@@ -1,24 +1,19 @@
 "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 });
-__exportStar(require("./user.schema"), exports);
-__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);
+exports.BlackjackGameSchema = exports.RaffleSchema = exports.AtmRequestSchema = exports.GuildConfigurationSchema = exports.TransactionSchema = exports.PredictionSchema = exports.VipRoomSchema = exports.UserSchema = void 0;
+var user_mongoose_1 = require("../user/user.mongoose");
+Object.defineProperty(exports, "UserSchema", { enumerable: true, get: function () { return user_mongoose_1.UserSchema; } });
+var vipRoom_mongoose_1 = require("../vip/vipRoom.mongoose");
+Object.defineProperty(exports, "VipRoomSchema", { enumerable: true, get: function () { return vipRoom_mongoose_1.VipRoomSchema; } });
+var prediction_mongoose_1 = require("../predictions/prediction.mongoose");
+Object.defineProperty(exports, "PredictionSchema", { enumerable: true, get: function () { return prediction_mongoose_1.PredictionSchema; } });
+var transaction_mongoose_1 = require("../transactions/transaction.mongoose");
+Object.defineProperty(exports, "TransactionSchema", { enumerable: true, get: function () { return transaction_mongoose_1.TransactionSchema; } });
+var guildConfiguration_mongoose_1 = require("../guild/guildConfiguration.mongoose");
+Object.defineProperty(exports, "GuildConfigurationSchema", { enumerable: true, get: function () { return guildConfiguration_mongoose_1.GuildConfigurationSchema; } });
+var atmRequest_mongoose_1 = require("../atm/atmRequest.mongoose");
+Object.defineProperty(exports, "AtmRequestSchema", { enumerable: true, get: function () { return atmRequest_mongoose_1.AtmRequestSchema; } });
+var raffle_mongoose_1 = require("../raffle/raffle.mongoose");
+Object.defineProperty(exports, "RaffleSchema", { enumerable: true, get: function () { return raffle_mongoose_1.RaffleSchema; } });
+var blackjackGame_mongoose_1 = require("../casino/blackjackGame.mongoose");
+Object.defineProperty(exports, "BlackjackGameSchema", { enumerable: true, get: function () { return blackjackGame_mongoose_1.BlackjackGameSchema; } });

package/dist/predictions/index.d.ts

@@ -0,0 +1,11 @@
+export * from './types/prediction';
+export * from './utils/validatePredictionBet';
+export * from './services/types';
+export * from './services/parsePredictionChoices';
+export * from './services/parsePredictionAutolock';
+export * from './services/normalizePredictionInput';
+export * from './services/predictionSummary';
+export * from './services/prediction.db';
+export * from './services/predictionLifecycle.service';
+export * from './schemas/prediction.forms';
+export { PredictionSchema } from './prediction.mongoose';

package/dist/predictions/index.js

@@ -0,0 +1,29 @@
+"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.PredictionSchema = void 0;
+__exportStar(require("./types/prediction"), exports);
+__exportStar(require("./utils/validatePredictionBet"), exports);
+__exportStar(require("./services/types"), exports);
+__exportStar(require("./services/parsePredictionChoices"), exports);
+__exportStar(require("./services/parsePredictionAutolock"), exports);
+__exportStar(require("./services/normalizePredictionInput"), exports);
+__exportStar(require("./services/predictionSummary"), exports);
+__exportStar(require("./services/prediction.db"), exports);
+__exportStar(require("./services/predictionLifecycle.service"), exports);
+__exportStar(require("./schemas/prediction.forms"), exports);
+var prediction_mongoose_1 = require("./prediction.mongoose");
+Object.defineProperty(exports, "PredictionSchema", { enumerable: true, get: function () { return prediction_mongoose_1.PredictionSchema; } });

package/dist/{mongoose/prediction.schema.d.ts → predictions/prediction.mongoose.d.ts}

@@ -1,18 +1,8 @@
 import { Schema } from 'mongoose';
-import { TPrediction } from '../types';
-export declare const PredictionSchema: Schema<TPrediction, import("mongoose").Model<TPrediction, any, any, any, (import("mongoose").Document<unknown, any, TPrediction, any, import("mongoose").DefaultSchemaOptions> & TPrediction & {
-    _id: import("mongoose").Types.ObjectId;
-} & {
-    __v: number;
-} & {
-    id: string;
-}) | (import("mongoose").Document<unknown, any, TPrediction, any, import("mongoose").DefaultSchemaOptions> & TPrediction & {
-    _id: import("mongoose").Types.ObjectId;
-} & {
-    __v: number;
-}), any, TPrediction>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, TPrediction, import("mongoose").Document<unknown, {}, TPrediction, {
+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").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TPrediction & {
+}, import("mongoose").DefaultSchemaOptions> & Omit<TPrediction & {
     _id: import("mongoose").Types.ObjectId;
 } & {
     __v: number;
@@ -21,7 +11,7 @@ export declare const PredictionSchema: Schema<TPrediction, import("mongoose").Mo
 }, {
     predictionId?: import("mongoose").SchemaDefinitionProperty<string, TPrediction, import("mongoose").Document<unknown, {}, TPrediction, {
         id: string;
-    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TPrediction & {
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TPrediction & {
         _id: import("mongoose").Types.ObjectId;
     } & {
         __v: number;
@@ -30,7 +20,7 @@ export declare const PredictionSchema: Schema<TPrediction, import("mongoose").Mo
     }> | undefined;
     guildId?: import("mongoose").SchemaDefinitionProperty<string, TPrediction, import("mongoose").Document<unknown, {}, TPrediction, {
         id: string;
-    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TPrediction & {
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TPrediction & {
         _id: import("mongoose").Types.ObjectId;
     } & {
         __v: number;
@@ -39,7 +29,7 @@ export declare const PredictionSchema: Schema<TPrediction, import("mongoose").Mo
     }> | undefined;
     channelId?: import("mongoose").SchemaDefinitionProperty<string, TPrediction, import("mongoose").Document<unknown, {}, TPrediction, {
         id: string;
-    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TPrediction & {
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TPrediction & {
         _id: import("mongoose").Types.ObjectId;
     } & {
         __v: number;
@@ -48,7 +38,7 @@ export declare const PredictionSchema: Schema<TPrediction, import("mongoose").Mo
     }> | undefined;
     creatorId?: import("mongoose").SchemaDefinitionProperty<string, TPrediction, import("mongoose").Document<unknown, {}, TPrediction, {
         id: string;
-    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TPrediction & {
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TPrediction & {
         _id: import("mongoose").Types.ObjectId;
     } & {
         __v: number;
@@ -57,16 +47,16 @@ export declare const PredictionSchema: Schema<TPrediction, import("mongoose").Mo
     }> | undefined;
     title?: import("mongoose").SchemaDefinitionProperty<string, TPrediction, import("mongoose").Document<unknown, {}, TPrediction, {
         id: string;
-    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TPrediction & {
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TPrediction & {
         _id: import("mongoose").Types.ObjectId;
     } & {
         __v: number;
     }, "id"> & {
         id: string;
     }> | undefined;
-    choices?: import("mongoose").SchemaDefinitionProperty<import("../types").TPredictionOption[], TPrediction, import("mongoose").Document<unknown, {}, TPrediction, {
+    choices?: import("mongoose").SchemaDefinitionProperty<import("./types/prediction").TPredictionOption[], TPrediction, import("mongoose").Document<unknown, {}, TPrediction, {
         id: string;
-    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TPrediction & {
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TPrediction & {
         _id: import("mongoose").Types.ObjectId;
     } & {
         __v: number;
@@ -75,7 +65,7 @@ export declare const PredictionSchema: Schema<TPrediction, import("mongoose").Mo
     }> | undefined;
     status?: import("mongoose").SchemaDefinitionProperty<"active" | "ended" | "paying" | "paid" | "canceled", TPrediction, import("mongoose").Document<unknown, {}, TPrediction, {
         id: string;
-    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TPrediction & {
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TPrediction & {
         _id: import("mongoose").Types.ObjectId;
     } & {
         __v: number;
@@ -84,7 +74,7 @@ export declare const PredictionSchema: Schema<TPrediction, import("mongoose").Mo
     }> | undefined;
     autolock?: import("mongoose").SchemaDefinitionProperty<Date | null | undefined, TPrediction, import("mongoose").Document<unknown, {}, TPrediction, {
         id: string;
-    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TPrediction & {
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TPrediction & {
         _id: import("mongoose").Types.ObjectId;
     } & {
         __v: number;
@@ -93,7 +83,7 @@ export declare const PredictionSchema: Schema<TPrediction, import("mongoose").Mo
     }> | undefined;
     createdAt?: import("mongoose").SchemaDefinitionProperty<Date, TPrediction, import("mongoose").Document<unknown, {}, TPrediction, {
         id: string;
-    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TPrediction & {
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TPrediction & {
         _id: import("mongoose").Types.ObjectId;
     } & {
         __v: number;
@@ -102,7 +92,7 @@ export declare const PredictionSchema: Schema<TPrediction, import("mongoose").Mo
     }> | undefined;
     updatedAt?: import("mongoose").SchemaDefinitionProperty<Date, TPrediction, import("mongoose").Document<unknown, {}, TPrediction, {
         id: string;
-    }, import("mongoose").ResolveSchemaOptions<import("mongoose").DefaultSchemaOptions>> & Omit<TPrediction & {
+    }, import("mongoose").DefaultSchemaOptions> & Omit<TPrediction & {
         _id: import("mongoose").Types.ObjectId;
     } & {
         __v: number;

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/schemas/prediction.forms.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.payoutPredictionFormSchema = exports.createPredictionFormSchema = exports.predictionChoiceSchema = exports.predictionChannelsFormSchema = void 0;
+const zod_1 = __importDefault(require("zod"));
+const zod_2 = require("../../common/zod");
+exports.predictionChannelsFormSchema = zod_1.default.object({
+    actions: zod_1.default.string(),
+    logs: zod_1.default.string()
+});
+exports.predictionChoiceSchema = zod_1.default.object({
+    choiceName: zod_1.default.string().min(1),
+    odds: zod_2.num.pipe(zod_1.default.number().positive())
+});
+exports.createPredictionFormSchema = zod_1.default.object({
+    title: zod_1.default.string().min(1).max(256),
+    choices: zod_1.default.array(exports.predictionChoiceSchema).min(2).max(3),
+    autolock: zod_1.default.string().optional()
+});
+exports.payoutPredictionFormSchema = zod_1.default.object({
+    winnerChoice: zod_1.default.string().min(1)
+});

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/normalizePredictionInput.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizePredictionChoices = normalizePredictionChoices;
+exports.normalizePredictionAutolock = normalizePredictionAutolock;
+const luxon_1 = require("luxon");
+const parsePredictionAutolock_1 = require("./parsePredictionAutolock");
+const parsePredictionChoices_1 = require("./parsePredictionChoices");
+function normalizePredictionChoices(input) {
+    if (typeof input === 'string') {
+        return (0, parsePredictionChoices_1.parsePredictionChoices)(input);
+    }
+    if (input.length < 2 || input.length > 3) {
+        return { ok: false, error: 'INVALID_COUNT' };
+    }
+    for (const choice of input) {
+        if (!choice.choiceName?.trim() ||
+            typeof choice.odds !== 'number' ||
+            Number.isNaN(choice.odds) ||
+            choice.odds <= 0) {
+            return {
+                ok: false,
+                error: 'INVALID_FORMAT',
+                detail: choice.choiceName
+            };
+        }
+    }
+    return {
+        ok: true,
+        choices: input.map((choice) => ({
+            choiceName: choice.choiceName.trim(),
+            odds: choice.odds,
+            bets: []
+        }))
+    };
+}
+function normalizePredictionAutolock(input, format) {
+    if (format === 'discord') {
+        return (0, parsePredictionAutolock_1.parsePredictionAutolock)(input);
+    }
+    const trimmed = input.trim();
+    if (!trimmed) {
+        return { ok: false, error: 'INVALID_FORMAT' };
+    }
+    const parsed = luxon_1.DateTime.fromISO(trimmed, { zone: 'utc' });
+    if (!parsed.isValid) {
+        return { ok: false, error: 'INVALID_DATE' };
+    }
+    const autolock = parsed.toJSDate();
+    if (autolock.getTime() <= Date.now()) {
+        return { ok: false, error: 'PAST_DATE' };
+    }
+    return { ok: true, autolock };
+}

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/parsePredictionAutolock.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePredictionAutolock = parsePredictionAutolock;
+const luxon_1 = require("luxon");
+const AUTOLOCK_REGEX = /^(\d{1,2})\.(\d{1,2})\.(\d{4}) (\d{2}):(\d{2})$/;
+function parsePredictionAutolock(input, timezone = 'Europe/Prague') {
+    const match = input.match(AUTOLOCK_REGEX);
+    if (!match) {
+        return { ok: false, error: 'INVALID_FORMAT' };
+    }
+    const [, day, month, year, hour, minute] = match.map(Number);
+    const dt = luxon_1.DateTime.fromObject({ year, month, day, hour, minute }, { zone: timezone });
+    if (!dt.isValid) {
+        return { ok: false, error: 'INVALID_DATE' };
+    }
+    if (dt.toMillis() <= Date.now()) {
+        return { ok: false, error: 'PAST_DATE' };
+    }
+    return { ok: true, autolock: dt.toJSDate() };
+}

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/parsePredictionChoices.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePredictionChoices = parsePredictionChoices;
+function parsePredictionChoices(input) {
+    const rawChoices = input.split(',').map((c) => c.trim());
+    if (rawChoices.length < 2 || rawChoices.length > 3) {
+        return { ok: false, error: 'INVALID_COUNT' };
+    }
+    const choicesArray = [];
+    for (const item of rawChoices) {
+        const [name, odds] = item.split(':').map((x) => x.trim());
+        if (!name || !odds || Number.isNaN(Number(odds))) {
+            return {
+                ok: false,
+                error: 'INVALID_FORMAT',
+                detail: item
+            };
+        }
+        choicesArray.push({
+            choiceName: name,
+            odds: Number(odds),
+            bets: []
+        });
+    }
+    return { ok: true, choices: choicesArray };
+}