@notidotbot/noti-api-client 1.5.7 → 1.6.0

package/dist/classes/client.d.ts

@@ -40,15 +40,15 @@ export declare class APIClient {
         content: string;
         thumbnail: string | null;
         authorIcon: string;
+        createdAt: Date;
+        tags: string[];
         clientId: string;
         identifier: string;
         isPinned: boolean;
         views: number | null;
         reactions: string[];
         reactionsCount: number | null;
-        tags: string[];
         authorName: string;
-        createdAt: Date;
         lastEdited: Date;
         isPublic: boolean;
     }[]>>;

package/dist/classes/games.d.ts

@@ -3,7 +3,7 @@ import { CancelOutWebResponses, WebResponse } from '../types';
 export type GameStore = 'steam' | 'epic' | 'gog' | 'prime';
 export type GameKind = 'free_game' | 'free_dlc_or_loot' | 'discount' | 'upcoming_free';
 export type GameDiscountTier = '100' | '90_plus' | '75_plus' | '50_plus' | '33_plus' | 'under_33';
-export type GameDelivery = 'instant' | 'daily' | 'weekly';
+export type GameDelivery = 'instant' | 'window' | 'scheduled';
 export type GameFlag = 'freeWeekend' | 'allTimeLow' | 'featured' | 'aaa' | 'earlyAccess';
 export type GameSourceId = 'epic_free' | 'cheapshark' | 'steam_featured' | 'gamerpower' | 'watchlist' | 'steam_weekend';
 export interface DealPrice {
@@ -257,9 +257,15 @@ export interface GameConfig {
     enabled: boolean;
     notificationChannelId: string | null;
     pingRoleId: string | null;
+    /** Delivery schedule (non-instant is premium). All hours are evaluated in the guild's `timezone`. */
     deliveryMode: GameDelivery;
-    digestHourUTC: number | null;
-    digestWeekday: number | null;
+    /** `window` mode: send instantly inside [windowStartHour, windowEndHour); hold + batch outside until it opens. */
+    windowStartHour: number | null;
+    windowEndHour: number | null;
+    /** `scheduled` mode: hold every event and flush the batch at each of these hours (0–23). */
+    scheduledHours: number[];
+    /** `scheduled` mode: restrict flushes to these weekdays (0=Sun … 6=Sat). Empty = every day. */
+    scheduledWeekdays: number[];
     freeGamesEnabled: boolean;
     /** Master switch for free DLC/loot alerts. `freeDlcStores` narrows it (empty = all stores). */
     freeDlcEnabled: boolean;
@@ -308,6 +314,8 @@ export interface GameEntitlements {
 }
 export interface GameConfigResponse {
     config: GameConfig;
+    /** Guild-wide IANA timezone (default `UTC`) that digest/scheduled sends are evaluated against. */
+    timezone: string;
     entitlements: GameEntitlements;
 }
 export interface GameSourceHealth {
@@ -431,6 +439,7 @@ export type GamesFunctionsInput = {
     updateConfig: {
         auth: string;
         guildId: string;
+        timezone?: string;
     } & Partial<Omit<GameConfig, 'guildId' | 'categoryRoutes' | 'trackedGames' | 'changelogGames' | 'robloxGames'>>;
     updateTrackedGames: {
         auth: string;

package/dist/classes/guildDrops.d.ts

@@ -1,10 +1,11 @@
 import { WebDataManager } from '../core/manager';
 import { CancelOutWebResponses, WebResponse } from '../types';
+export type DeliveryMode = 'instant' | 'window' | 'scheduled';
 export declare class APIGuildDrops {
     private web;
     constructor(web: WebDataManager);
     getGuildDrops({ auth, guildId }: GuildDropsFunctionsInput['getGuildDrops']): Promise<WebResponse<GuildDropsData>>;
-    updateGuildDrops({ auth, guildId, kickEnabled, twitchEnabled, kickLiveNotifications, twitchLiveNotifications, kickChannelId, twitchChannelId, kickRoleId, twitchRoleId, kickLiveNotificationChannelId, kickLiveNotificationRoleId, twitchLiveNotificationChannelId, twitchLiveNotificationRoleId, webhook, games }: GuildDropsFunctionsInput['updateGuildDrops']): Promise<WebResponse<GuildDropsData>>;
+    updateGuildDrops({ auth, guildId, timezone, kickDeliveryMode, kickWindowStartHour, kickWindowEndHour, kickScheduledHours, kickScheduledWeekdays, twitchDeliveryMode, twitchWindowStartHour, twitchWindowEndHour, twitchScheduledHours, twitchScheduledWeekdays, kickEnabled, twitchEnabled, kickLiveNotifications, twitchLiveNotifications, kickChannelId, twitchChannelId, kickRoleId, twitchRoleId, kickLiveNotificationChannelId, kickLiveNotificationRoleId, twitchLiveNotificationChannelId, twitchLiveNotificationRoleId, webhook, games }: GuildDropsFunctionsInput['updateGuildDrops']): Promise<WebResponse<GuildDropsData>>;
 }
 export type GuildDropsFunctionsInput = {
     'getGuildDrops': {
@@ -14,6 +15,17 @@ export type GuildDropsFunctionsInput = {
     'updateGuildDrops': {
         auth: string;
         guildId: string;
+        timezone?: string;
+        kickDeliveryMode?: DeliveryMode;
+        kickWindowStartHour?: number | null;
+        kickWindowEndHour?: number | null;
+        kickScheduledHours?: number[];
+        kickScheduledWeekdays?: number[];
+        twitchDeliveryMode?: DeliveryMode;
+        twitchWindowStartHour?: number | null;
+        twitchWindowEndHour?: number | null;
+        twitchScheduledHours?: number[];
+        twitchScheduledWeekdays?: number[];
         kickEnabled?: boolean;
         twitchEnabled?: boolean;
         kickLiveNotifications?: boolean;
@@ -66,6 +78,17 @@ export type GameDropConfig = {
     webhook: WebhookConfig | null;
 };
 export type GuildDropsData = {
+    timezone: string;
+    kickDeliveryMode: DeliveryMode;
+    kickWindowStartHour: number | null;
+    kickWindowEndHour: number | null;
+    kickScheduledHours: number[];
+    kickScheduledWeekdays: number[];
+    twitchDeliveryMode: DeliveryMode;
+    twitchWindowStartHour: number | null;
+    twitchWindowEndHour: number | null;
+    twitchScheduledHours: number[];
+    twitchScheduledWeekdays: number[];
     kickEnabled: boolean;
     twitchEnabled: boolean;
     kickLiveNotifications: boolean;

package/dist/classes/guildDrops.js

@@ -14,11 +14,22 @@ class APIGuildDrops {
             endpoint: this.web.qp(`/data/guild/${guildId}/drops`),
         });
     }
-    async updateGuildDrops({ auth, guildId, kickEnabled, twitchEnabled, kickLiveNotifications, twitchLiveNotifications, kickChannelId, twitchChannelId, kickRoleId, twitchRoleId, kickLiveNotificationChannelId, kickLiveNotificationRoleId, twitchLiveNotificationChannelId, twitchLiveNotificationRoleId, webhook, games }) {
+    async updateGuildDrops({ auth, guildId, timezone, kickDeliveryMode, kickWindowStartHour, kickWindowEndHour, kickScheduledHours, kickScheduledWeekdays, twitchDeliveryMode, twitchWindowStartHour, twitchWindowEndHour, twitchScheduledHours, twitchScheduledWeekdays, kickEnabled, twitchEnabled, kickLiveNotifications, twitchLiveNotifications, kickChannelId, twitchChannelId, kickRoleId, twitchRoleId, kickLiveNotificationChannelId, kickLiveNotificationRoleId, twitchLiveNotificationChannelId, twitchLiveNotificationRoleId, webhook, games }) {
         return await this.web.request({
             method: 'PATCH', auth,
             endpoint: this.web.qp(`/data/guild/${guildId}/drops`),
             body: {
+                timezone,
+                kickDeliveryMode,
+                kickWindowStartHour,
+                kickWindowEndHour,
+                kickScheduledHours,
+                kickScheduledWeekdays,
+                twitchDeliveryMode,
+                twitchWindowStartHour,
+                twitchWindowEndHour,
+                twitchScheduledHours,
+                twitchScheduledWeekdays,
                 kickEnabled,
                 twitchEnabled,
                 kickLiveNotifications,

package/dist/classes/guildMessageScheduler.d.ts

@@ -0,0 +1,93 @@
+import { GuildScheduledMessage } from '../other/prisma';
+import { WebDataManager } from '../core/manager';
+import { CancelOutWebResponses, WebResponse } from '../types';
+export type ScheduledMessageTrigger = 'time' | 'stage' | 'guildEvent';
+export type ScheduledMessageRecurrence = 'once' | 'daily' | 'weekly' | 'days' | 'interval';
+export type ScheduledMessageTiming = 'on' | 'before';
+export declare class APIGuildMessageScheduler {
+    private web;
+    constructor(web: WebDataManager);
+    getScheduledMessages({ auth, guildId }: GuildMessageSchedulerFunctionsInput['getScheduledMessages']): Promise<WebResponse<ScheduledMessageData[]>>;
+    getScheduledMessage({ auth, guildId, messageId }: GuildMessageSchedulerFunctionsInput['getScheduledMessage']): Promise<WebResponse<ScheduledMessageData>>;
+    createScheduledMessage({ auth, guildId, body }: GuildMessageSchedulerFunctionsInput['createScheduledMessage']): Promise<WebResponse<CreateScheduledMessageResponse>>;
+    editScheduledMessage({ auth, guildId, messageId, body }: GuildMessageSchedulerFunctionsInput['editScheduledMessage']): Promise<WebResponse<string>>;
+    pauseScheduledMessage({ auth, guildId, messageId }: GuildMessageSchedulerFunctionsInput['pauseScheduledMessage']): Promise<WebResponse<string>>;
+    resumeScheduledMessage({ auth, guildId, messageId }: GuildMessageSchedulerFunctionsInput['resumeScheduledMessage']): Promise<WebResponse<string>>;
+    deleteScheduledMessage({ auth, guildId, messageId }: GuildMessageSchedulerFunctionsInput['deleteScheduledMessage']): Promise<WebResponse<string>>;
+}
+export type GuildMessageSchedulerFunctionsInput = {
+    'getScheduledMessages': {
+        auth: string;
+        guildId: string;
+    };
+    'getScheduledMessage': {
+        auth: string;
+        guildId: string;
+        messageId: string;
+    };
+    'createScheduledMessage': {
+        auth: string;
+        guildId: string;
+        body: ScheduledMessageCreateBody;
+    };
+    'editScheduledMessage': {
+        auth: string;
+        guildId: string;
+        messageId: string;
+        body: ScheduledMessageEditBody;
+    };
+    'pauseScheduledMessage': {
+        auth: string;
+        guildId: string;
+        messageId: string;
+    };
+    'resumeScheduledMessage': {
+        auth: string;
+        guildId: string;
+        messageId: string;
+    };
+    'deleteScheduledMessage': {
+        auth: string;
+        guildId: string;
+        messageId: string;
+    };
+};
+export type GuildMessageSchedulerReturnTypes = {
+    'getScheduledMessagesRaw': Awaited<ReturnType<APIGuildMessageScheduler['getScheduledMessages']>>;
+    'getScheduledMessagesSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuildMessageScheduler['getScheduledMessages']>>>;
+    'getScheduledMessageRaw': Awaited<ReturnType<APIGuildMessageScheduler['getScheduledMessage']>>;
+    'getScheduledMessageSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuildMessageScheduler['getScheduledMessage']>>>;
+    'createScheduledMessageRaw': Awaited<ReturnType<APIGuildMessageScheduler['createScheduledMessage']>>;
+    'createScheduledMessageSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuildMessageScheduler['createScheduledMessage']>>>;
+    'editScheduledMessageRaw': Awaited<ReturnType<APIGuildMessageScheduler['editScheduledMessage']>>;
+    'editScheduledMessageSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuildMessageScheduler['editScheduledMessage']>>>;
+    'pauseScheduledMessageRaw': Awaited<ReturnType<APIGuildMessageScheduler['pauseScheduledMessage']>>;
+    'pauseScheduledMessageSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuildMessageScheduler['pauseScheduledMessage']>>>;
+    'resumeScheduledMessageRaw': Awaited<ReturnType<APIGuildMessageScheduler['resumeScheduledMessage']>>;
+    'resumeScheduledMessageSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuildMessageScheduler['resumeScheduledMessage']>>>;
+    'deleteScheduledMessageRaw': Awaited<ReturnType<APIGuildMessageScheduler['deleteScheduledMessage']>>;
+    'deleteScheduledMessageSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuildMessageScheduler['deleteScheduledMessage']>>>;
+};
+export type ScheduledMessageData = GuildScheduledMessage & {
+    schedule: string;
+};
+export type CreateScheduledMessageResponse = {
+    messageId: string;
+    nextRunAt: Date | null;
+};
+export type ScheduledMessageCreateBody = {
+    channelId: string;
+    content: string;
+    trigger?: ScheduledMessageTrigger;
+    recurrence?: ScheduledMessageRecurrence;
+    daysOfWeek?: number[];
+    intervalMinutes?: number | null;
+    time?: string | null;
+    date?: string | null;
+    eventId?: string | null;
+    timing?: ScheduledMessageTiming | null;
+    offsetMinutes?: number | null;
+};
+export type ScheduledMessageEditBody = {
+    content: string;
+};

package/dist/classes/guildMessageScheduler.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APIGuildMessageScheduler = void 0;
+// Data.
+class APIGuildMessageScheduler {
+    web;
+    constructor(web) {
+        this.web = web;
+    }
+    // Methods.
+    async getScheduledMessages({ auth, guildId }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp(`/data/scheduledMessages/${guildId}`),
+        });
+    }
+    async getScheduledMessage({ auth, guildId, messageId }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp(`/data/scheduledMessages/${guildId}/${messageId}`),
+        });
+    }
+    async createScheduledMessage({ auth, guildId, body }) {
+        return await this.web.request({
+            method: 'POST', auth, body,
+            endpoint: this.web.qp(`/data/scheduledMessages/${guildId}`),
+        });
+    }
+    async editScheduledMessage({ auth, guildId, messageId, body }) {
+        return await this.web.request({
+            method: 'PATCH', auth, body,
+            endpoint: this.web.qp(`/data/scheduledMessages/${guildId}/${messageId}`),
+        });
+    }
+    async pauseScheduledMessage({ auth, guildId, messageId }) {
+        return await this.web.request({
+            method: 'POST', auth,
+            endpoint: this.web.qp(`/data/scheduledMessages/${guildId}/${messageId}/pause`),
+        });
+    }
+    async resumeScheduledMessage({ auth, guildId, messageId }) {
+        return await this.web.request({
+            method: 'POST', auth,
+            endpoint: this.web.qp(`/data/scheduledMessages/${guildId}/${messageId}/resume`),
+        });
+    }
+    async deleteScheduledMessage({ auth, guildId, messageId }) {
+        return await this.web.request({
+            method: 'DELETE', auth,
+            endpoint: this.web.qp(`/data/scheduledMessages/${guildId}/${messageId}`),
+        });
+    }
+}
+exports.APIGuildMessageScheduler = APIGuildMessageScheduler;

package/dist/classes/guildStarboard.d.ts

@@ -9,9 +9,9 @@ export declare class APIGuildStarboard {
             dbId: string;
             guildStarboardId: string;
             roles: string[];
-            channels: string[];
             roleMode: import("@prisma/client").$Enums.FilterEnum | null;
             channelMode: import("@prisma/client").$Enums.FilterEnum | null;
+            channels: string[];
         } | null;
     } & {
         dbId: string;

package/dist/core/manager.d.ts

@@ -1,3 +1,4 @@
+import { APIGuildMessageScheduler } from '../classes/guildMessageScheduler';
 import { APIPlatformAction } from '../classes/guildPlatformAction';
 import { APIGuildStarboard } from '../classes/guildStarboard';
 import { APIGuildFixURL } from '../classes/guildFixURL';
@@ -52,6 +53,7 @@ export declare class WebDataManager {
     readonly guildPlatformAction: APIPlatformAction;
     readonly guildFixURL: APIGuildFixURL;
     readonly guildClipper: APIGuildClipper;
+    readonly guildMessageScheduler: APIGuildMessageScheduler;
     readonly games: APIGames;
     constructor(url: string, options?: {
         log?: boolean;

package/dist/core/manager.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebDataManager = void 0;
+const guildMessageScheduler_1 = require("../classes/guildMessageScheduler");
 const guildPlatformAction_1 = require("../classes/guildPlatformAction");
 const guildStarboard_1 = require("../classes/guildStarboard");
 const guildFixURL_1 = require("../classes/guildFixURL");
@@ -56,6 +57,7 @@ class WebDataManager {
     guildPlatformAction = new guildPlatformAction_1.APIPlatformAction(this);
     guildFixURL = new guildFixURL_1.APIGuildFixURL(this);
     guildClipper = new guildClipper_1.APIGuildClipper(this);
+    guildMessageScheduler = new guildMessageScheduler_1.APIGuildMessageScheduler(this);
     games = new games_1.APIGames(this);
     constructor(url, options) {
         this.url = url;

package/dist/index.d.ts

@@ -23,6 +23,7 @@ export * from './classes/guildStarboard';
 export * from './classes/guildPlatformAction';
 export * from './classes/guildFixURL';
 export * from './classes/guildClipper';
+export * from './classes/guildMessageScheduler';
 export * from './classes/games';
 export { GuildMessageTypeEnum, StreamerMessageTypeEnum, PlatformEnum, $Enums } from './other/enums';
 export type { Prisma, TSPrisma } from '@prisma/client';

package/dist/index.js

@@ -40,6 +40,7 @@ __exportStar(require("./classes/guildStarboard"), exports);
 __exportStar(require("./classes/guildPlatformAction"), exports);
 __exportStar(require("./classes/guildFixURL"), exports);
 __exportStar(require("./classes/guildClipper"), exports);
+__exportStar(require("./classes/guildMessageScheduler"), exports);
 __exportStar(require("./classes/games"), exports);
 // Re-export Prisma generated enums (browser-safe)
 var enums_1 = require("./other/enums");

package/dist/other/enums.d.ts

@@ -128,6 +128,18 @@ export declare const UserNotificationSeverityEnum: {
     readonly warning: "warning";
     readonly emergency: "emergency";
 };
+export declare const ScheduledMessageRecurrenceEnum: {
+    readonly once: "once";
+    readonly daily: "daily";
+    readonly weekly: "weekly";
+    readonly days: "days";
+    readonly interval: "interval";
+};
+export declare const ScheduledMessageTriggerEnum: {
+    readonly time: "time";
+    readonly stage: "stage";
+    readonly guildEvent: "guildEvent";
+};
 export declare const $Enums: {
     readonly LeaderBoardTypesEnum: {
         readonly weekly: "weekly";
@@ -259,5 +271,17 @@ export declare const $Enums: {
         readonly warning: "warning";
         readonly emergency: "emergency";
     };
+    readonly ScheduledMessageRecurrenceEnum: {
+        readonly once: "once";
+        readonly daily: "daily";
+        readonly weekly: "weekly";
+        readonly days: "days";
+        readonly interval: "interval";
+    };
+    readonly ScheduledMessageTriggerEnum: {
+        readonly time: "time";
+        readonly stage: "stage";
+        readonly guildEvent: "guildEvent";
+    };
 };
 export type $EnumsType = typeof $Enums;

package/dist/other/enums.js

@@ -3,7 +3,7 @@
 // These mirror the Prisma enums and provide plain JS objects/arrays so the
 // docs/client code can safely import them during bundling.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.$Enums = exports.UserNotificationSeverityEnum = exports.RoleBonusEnum = exports.MediaShareCommandsEnum = exports.MediaShareTypesEnum = exports.FilterEnum = exports.QueryInEnum = exports.RumbleTypeEnum = exports.PlatformsWithVideosEnum = exports.UserMediaSharePermissionsEnum = exports.ClipperCategoryEnum = exports.PlatformEnum = exports.OverridesEnum = exports.GuildSingleMessageTypeEnum = exports.GuildMessageTypeEnum = exports.StreamerMessageTypeEnum = exports.SingleMessageTypeEnum = exports.LeaderBoardTypesEnum = void 0;
+exports.$Enums = exports.ScheduledMessageTriggerEnum = exports.ScheduledMessageRecurrenceEnum = exports.UserNotificationSeverityEnum = exports.RoleBonusEnum = exports.MediaShareCommandsEnum = exports.MediaShareTypesEnum = exports.FilterEnum = exports.QueryInEnum = exports.RumbleTypeEnum = exports.PlatformsWithVideosEnum = exports.UserMediaSharePermissionsEnum = exports.ClipperCategoryEnum = exports.PlatformEnum = exports.OverridesEnum = exports.GuildSingleMessageTypeEnum = exports.GuildMessageTypeEnum = exports.StreamerMessageTypeEnum = exports.SingleMessageTypeEnum = exports.LeaderBoardTypesEnum = void 0;
 exports.LeaderBoardTypesEnum = {
     weekly: 'weekly',
     monthly: 'monthly',
@@ -135,6 +135,18 @@ exports.UserNotificationSeverityEnum = {
     warning: 'warning',
     emergency: 'emergency',
 };
+exports.ScheduledMessageRecurrenceEnum = {
+    once: 'once',
+    daily: 'daily',
+    weekly: 'weekly',
+    days: 'days',
+    interval: 'interval',
+};
+exports.ScheduledMessageTriggerEnum = {
+    time: 'time',
+    stage: 'stage',
+    guildEvent: 'guildEvent',
+};
 exports.$Enums = {
     LeaderBoardTypesEnum: exports.LeaderBoardTypesEnum,
     SingleMessageTypeEnum: exports.SingleMessageTypeEnum,
@@ -153,4 +165,6 @@ exports.$Enums = {
     MediaShareCommandsEnum: exports.MediaShareCommandsEnum,
     RoleBonusEnum: exports.RoleBonusEnum,
     UserNotificationSeverityEnum: exports.UserNotificationSeverityEnum,
+    ScheduledMessageRecurrenceEnum: exports.ScheduledMessageRecurrenceEnum,
+    ScheduledMessageTriggerEnum: exports.ScheduledMessageTriggerEnum,
 };

package/dist/other/prisma.d.ts

@@ -13,6 +13,7 @@ import { MemberZod } from './zod/member.zod';
 import { ClientZod } from './zod/client.zod';
 import { GuildZod } from './zod/guild.zod';
 import { GameConfigZod } from './zod/gameConfig.zod';
+import { ScheduledMessageZod } from './zod/scheduledMessage.zod';
 import { DropsZod } from './zod/drops.zod';
 import { UserZod } from './zod/user.zod';
 import { TeamZod } from './zod/team.zod';
@@ -39,6 +40,7 @@ export type GuildDropsWebhook = TSPrisma.TSPrismaModelsFull['GuildDropsWebhook']
 export type GuildDropsGame = TSPrisma.TSPrismaModelsFull['GuildDropsGame'];
 export type GuildDropsGameWebhook = TSPrisma.TSPrismaModelsFull['GuildDropsGameWebhook'];
 export type SentDrop = TSPrisma.TSPrismaModelsFull['SentDrop'];
+export type GuildScheduledMessage = TSPrisma.TSPrismaModelsFull['GuildScheduledMessage'];
 export type TeamZod = z.infer<typeof TeamZod.TeamSchema>;
 export type UserZod = z.infer<typeof UserZod.UserSchema>;
 export type GuildZod = z.infer<typeof GuildZod.GuildSchema>;
@@ -64,6 +66,9 @@ export type GameConfigZod = z.infer<typeof GameConfigZod.GuildGameConfigSchema>;
 export type GuildGameCategoryRouteZod = z.infer<typeof GameConfigZod.GuildGameCategoryRouteSchema>;
 export type GuildTrackedGameZod = z.infer<typeof GameConfigZod.GuildTrackedGameSchema>;
 export type GuildGameChangelogZod = z.infer<typeof GameConfigZod.GuildGameChangelogSchema>;
+export type GuildScheduledMessageZod = z.infer<typeof ScheduledMessageZod.GuildScheduledMessageSchema>;
+export type ScheduledMessageCreateZod = z.infer<typeof ScheduledMessageZod.ScheduledMessageCreateSchema>;
+export type ScheduledMessageEditZod = z.infer<typeof ScheduledMessageZod.ScheduledMessageEditSchema>;
 export type AllPlatforms = (typeof PlatformEnum)[keyof typeof PlatformEnum];
 export type AllPlatformsWithVideos = Enums['PlatformsWithVideosEnum'];
 export type PlatformsToLinkType = typeof PlatformsToLink[number];

package/dist/other/zod/drops.zod.js

@@ -53,6 +53,17 @@ const GuildDropsSchema = zod_2.z.object({
     kickLiveNotificationRoleId: zod_2.z.string().nullable(),
     twitchLiveNotificationChannelId: zod_2.z.string().nullable(),
     twitchLiveNotificationRoleId: zod_2.z.string().nullable(),
+    // Independent per-platform delivery schedule (hours in the guild timezone).
+    kickDeliveryMode: schema_zod_1.NotificationDeliveryEnum,
+    kickWindowStartHour: zod_2.z.number().min(0).max(23).nullable(),
+    kickWindowEndHour: zod_2.z.number().min(0).max(23).nullable(),
+    kickScheduledHours: zod_2.z.array(zod_2.z.number().min(0).max(23)),
+    kickScheduledWeekdays: zod_2.z.array(zod_2.z.number().min(0).max(6)),
+    twitchDeliveryMode: schema_zod_1.NotificationDeliveryEnum,
+    twitchWindowStartHour: zod_2.z.number().min(0).max(23).nullable(),
+    twitchWindowEndHour: zod_2.z.number().min(0).max(23).nullable(),
+    twitchScheduledHours: zod_2.z.array(zod_2.z.number().min(0).max(23)),
+    twitchScheduledWeekdays: zod_2.z.array(zod_2.z.number().min(0).max(6)),
     games: zod_2.z.array(zod_2.z.lazy(() => GuildDropsGameSchema)),
     webhook: zod_2.z.lazy(() => GuildDropsWebhookSchema).nullable(),
     createdAt: zod_2.z.date(),

package/dist/other/zod/gameConfig.zod.d.ts

@@ -11,12 +11,14 @@ export declare const GameConfigZod: {
         notificationChannelId: z.ZodNullable<z.ZodString>;
         pingRoleId: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"everyone">, z.ZodLiteral<"here">]>>;
         deliveryMode: z.ZodEnum<{
-            weekly: "weekly";
             instant: "instant";
-            daily: "daily";
+            window: "window";
+            scheduled: "scheduled";
         }>;
-        digestHourUTC: z.ZodNullable<z.ZodNumber>;
-        digestWeekday: z.ZodNullable<z.ZodNumber>;
+        windowStartHour: z.ZodNullable<z.ZodNumber>;
+        windowEndHour: z.ZodNullable<z.ZodNumber>;
+        scheduledHours: z.ZodArray<z.ZodNumber>;
+        scheduledWeekdays: z.ZodArray<z.ZodNumber>;
         freeGamesEnabled: z.ZodBoolean;
         freeDlcEnabled: z.ZodBoolean;
         freeDlcStores: z.ZodArray<z.ZodEnum<{

package/dist/other/zod/gameConfig.zod.js

@@ -58,10 +58,12 @@ const GuildGameConfigSchema = zod_2.z.object({
     // Default routing — the free-tier "one channel + one mention role" target.
     notificationChannelId: zod_1.SnowFlake.nullable(),
     pingRoleId: zod_1.SnowFlakeOrEveryone.nullable(),
-    // Delivery tier. Window/day customization is premium; free guilds get the default window.
-    deliveryMode: schema_zod_1.GameDeliveryEnum,
-    digestHourUTC: zod_2.z.number().min(0).max(23).nullable(),
-    digestWeekday: zod_2.z.number().min(0).max(6).nullable(),
+    // Delivery schedule (non-instant is premium). Hours are evaluated in the guild timezone.
+    deliveryMode: schema_zod_1.NotificationDeliveryEnum,
+    windowStartHour: zod_2.z.number().min(0).max(23).nullable(),
+    windowEndHour: zod_2.z.number().min(0).max(23).nullable(),
+    scheduledHours: zod_2.z.array(zod_2.z.number().min(0).max(23)),
+    scheduledWeekdays: zod_2.z.array(zod_2.z.number().min(0).max(6)),
     // Free-to-keep games (always free-tier), upcoming freebies, and Steam play-free weekends.
     // Each `*Enabled` boolean is the master switch; the matching `*Stores` array narrows the
     // type to specific stores (empty = all, same as freeGameStores).

package/dist/other/zod/guild.zod.d.ts

@@ -8,6 +8,7 @@ export declare const GuildZod: {
     readonly GuildSchema: z.ZodObject<{
         guildId: z.ZodString;
         locale: z.ZodString;
+        timezone: z.ZodString;
         blacklisted: z.ZodBoolean;
         leftAt: z.ZodNullable<z.ZodDate>;
         premium: z.ZodNullable<z.ZodLazy<z.ZodObject<{

package/dist/other/zod/guild.zod.js

@@ -7,6 +7,7 @@ const zod_2 = require("zod");
 const GuildSchema = zod_2.z.object({
     guildId: zod_1.SnowFlake,
     locale: zod_2.z.string(),
+    timezone: zod_2.z.string(),
     blacklisted: zod_2.z.boolean(),
     leftAt: zod_2.z.date().nullable(),
     premium: zod_2.z.lazy(() => GuildPremiumSchema).nullable(),

package/dist/other/zod/rumbleStreamer.zod.d.ts

@@ -9,8 +9,8 @@ export declare const RumbleStreamerZod: {
         streamerUserName: z.ZodString;
         guildId: z.ZodString;
         type: z.ZodEnum<{
-            user: "user";
             channel: "channel";
+            user: "user";
         }>;
         deleteEmbeds: z.ZodNullable<z.ZodBoolean>;
         sendOfflineMessage: z.ZodNullable<z.ZodBoolean>;

package/dist/other/zod/scheduledMessage.zod.d.ts

@@ -0,0 +1,71 @@
+import { PartialZodObject } from './schema.zod';
+import { RemoveProperties } from '../prisma';
+import { TSPrisma } from '@prisma/client';
+import { z } from 'zod';
+export type RT<T extends TSPrisma.AllModelNames> = z.ZodType<RemoveProperties<TSPrisma.TSPrismaModelsFull[T], GuildScheduledMessageRelations>>;
+export type GuildScheduledMessageRelations = 'db';
+export declare const ScheduledMessageTimingEnum: z.ZodEnum<{
+    on: "on";
+    before: "before";
+}>;
+export declare const ScheduledMessageZod: {
+    readonly GuildScheduledMessageSchema: z.ZodObject<{
+        messageId: z.ZodString;
+        guildId: z.ZodString;
+        channelId: z.ZodString;
+        creatorId: z.ZodString;
+        content: z.ZodString;
+        trigger: z.ZodEnum<{
+            time: "time";
+            stage: "stage";
+            guildEvent: "guildEvent";
+        }>;
+        recurrence: z.ZodEnum<{
+            weekly: "weekly";
+            once: "once";
+            daily: "daily";
+            days: "days";
+            interval: "interval";
+        }>;
+        daysOfWeek: z.ZodArray<z.ZodNumber>;
+        intervalMinutes: z.ZodNullable<z.ZodNumber>;
+        timeOfDay: z.ZodNullable<z.ZodString>;
+        guildEventId: z.ZodNullable<z.ZodString>;
+        eventOffsetMinutes: z.ZodNullable<z.ZodNumber>;
+        timezone: z.ZodString;
+        nextRunAt: z.ZodNullable<z.ZodDate>;
+        lastRunAt: z.ZodNullable<z.ZodDate>;
+        paused: z.ZodBoolean;
+        createdAt: z.ZodDate;
+    }, z.core.$strip>;
+    readonly ScheduledMessageCreateSchema: z.ZodObject<{
+        channelId: z.ZodString;
+        content: z.ZodString;
+        trigger: z.ZodDefault<z.ZodEnum<{
+            time: "time";
+            stage: "stage";
+            guildEvent: "guildEvent";
+        }>>;
+        recurrence: z.ZodDefault<z.ZodEnum<{
+            weekly: "weekly";
+            once: "once";
+            daily: "daily";
+            days: "days";
+            interval: "interval";
+        }>>;
+        daysOfWeek: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+        intervalMinutes: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+        time: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        date: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        eventId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        timing: z.ZodDefault<z.ZodNullable<z.ZodEnum<{
+            on: "on";
+            before: "before";
+        }>>>;
+        offsetMinutes: z.ZodDefault<z.ZodNullable<z.ZodNumber>>;
+    }, z.core.$strip>;
+    readonly ScheduledMessageEditSchema: z.ZodObject<{
+        content: z.ZodString;
+    }, z.core.$strip>;
+};
+export declare const ScheduledMessageZodPartial: PartialZodObject<typeof ScheduledMessageZod>;