@notidotbot/noti-api-client 1.9.73 → 1.9.75

package/dist/classes/@me.d.ts

@@ -12,6 +12,18 @@ export declare class APIMe {
     getConnectPlatformUrl({ platform }: MeFunctionsInput['getConnectPlatformUrl']): Promise<import("../types").WebResponse<string>>;
     connectPlatform({ auth, platform, code, state }: MeFunctionsInput['connectPlatform']): Promise<import("../types").WebResponse<string>>;
     unlinkPlatform({ auth, platform }: MeFunctionsInput['unlinkPlatform']): Promise<import("../types").WebResponse<string>>;
+    /**
+     * Link a Minecraft account: the code `/noti link` printed in a connected Minecraft server. The link counts only
+     * in that server's Discord server. 400 for a wrong or expired code (it is spent either way), 409 when that
+     * Minecraft account is already linked to someone else there. Linking again in the same server replaces the old one.
+     */
+    connectMinecraft({ auth, code }: MeFunctionsInput['connectMinecraft']): Promise<import("../types").WebResponse<MinecraftLinkResult>>;
+    /** Every server this user has linked a Minecraft account in, newest first. */
+    getMinecraftLinks({ auth }: MeFunctionsInput['getMinecraftLinks']): Promise<import("../types").WebResponse<{
+        links: MinecraftLink[];
+    }>>;
+    /** Unlink in one server. 404 when nothing is linked there. */
+    unlinkMinecraft({ auth, guildId }: MeFunctionsInput['unlinkMinecraft']): Promise<import("../types").WebResponse<string>>;
     /**
      * The one server upgrade that comes with User Premium: where it currently sits, and whether it can
      * be moved yet. Everything the dashboard needs is inside `data` - a field beside it would exist at
@@ -62,6 +74,17 @@ export type MeFunctionsInput<T extends GuildDataType = never> = {
     'deleteServerPremium': {
         auth: string;
     };
+    'connectMinecraft': {
+        auth: string;
+        code: string;
+    };
+    'getMinecraftLinks': {
+        auth: string;
+    };
+    'unlinkMinecraft': {
+        auth: string;
+        guildId: string;
+    };
 };
 export type MeGetReturnTypes = {
     'getCurrentUserRaw': Awaited<ReturnType<APIMe['getCurrentUser']>>;
@@ -84,6 +107,28 @@ export type MeGetReturnTypes = {
     'setServerPremiumSuccess': CancelOutWebResponses<Awaited<ReturnType<APIMe['setServerPremium']>>>;
     'deleteServerPremiumRaw': Awaited<ReturnType<APIMe['deleteServerPremium']>>;
     'deleteServerPremiumSuccess': CancelOutWebResponses<Awaited<ReturnType<APIMe['deleteServerPremium']>>>;
+    'connectMinecraftRaw': Awaited<ReturnType<APIMe['connectMinecraft']>>;
+    'connectMinecraftSuccess': CancelOutWebResponses<Awaited<ReturnType<APIMe['connectMinecraft']>>>;
+    'getMinecraftLinksRaw': Awaited<ReturnType<APIMe['getMinecraftLinks']>>;
+    'getMinecraftLinksSuccess': CancelOutWebResponses<Awaited<ReturnType<APIMe['getMinecraftLinks']>>>;
+    'unlinkMinecraftRaw': Awaited<ReturnType<APIMe['unlinkMinecraft']>>;
+    'unlinkMinecraftSuccess': CancelOutWebResponses<Awaited<ReturnType<APIMe['unlinkMinecraft']>>>;
+};
+/** What `connectMinecraft` linked. `bedrock`: a Bedrock player through Geyser/Floodgate. */
+export type MinecraftLinkResult = {
+    guildId: string;
+    uuid: string;
+    name: string;
+    bedrock: boolean;
+};
+/** One Minecraft account linked in one Discord server. `guildName` is null when Noti is no longer in that server. */
+export type MinecraftLink = {
+    guildId: string;
+    guildName: string | null;
+    uuid: string;
+    name: string;
+    bedrock: boolean;
+    linkedAt: string;
 };
 export type DCUserData = {
     id: string;

package/dist/classes/@me.js

@@ -55,6 +55,31 @@ class APIMe {
             endpoint: this.web.qp('/@me/connect/' + platform),
         });
     }
+    /**
+     * Link a Minecraft account: the code `/noti link` printed in a connected Minecraft server. The link counts only
+     * in that server's Discord server. 400 for a wrong or expired code (it is spent either way), 409 when that
+     * Minecraft account is already linked to someone else there. Linking again in the same server replaces the old one.
+     */
+    async connectMinecraft({ auth, code }) {
+        return await this.web.request({
+            method: 'POST', auth, body: { code },
+            endpoint: this.web.qp('/@me/connect/minecraft'),
+        });
+    }
+    /** Every server this user has linked a Minecraft account in, newest first. */
+    async getMinecraftLinks({ auth }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp('/@me/connect/minecraft'),
+        });
+    }
+    /** Unlink in one server. 404 when nothing is linked there. */
+    async unlinkMinecraft({ auth, guildId }) {
+        return await this.web.request({
+            method: 'DELETE', auth,
+            endpoint: this.web.qp('/@me/connect/minecraft/' + guildId),
+        });
+    }
     /**
      * The one server upgrade that comes with User Premium: where it currently sits, and whether it can
      * be moved yet. Everything the dashboard needs is inside `data` - a field beside it would exist at

package/dist/classes/guildInGame.d.ts

@@ -0,0 +1,259 @@
+import { WebDataManager } from '../core/manager';
+import { CancelOutWebResponses, WebResponse } from '../types';
+import type { InGameAlertType, InGamePlatform } from '../other/inGameAlerts';
+/**
+ * Minecraft - game servers connected to a Discord server (Noti-v3 phases/in-game/).
+ *
+ * A server running the Noti plugin with no token prints a code (`K7P-2QX`) to its console. The owner enters it
+ * here (`createInGameServer`), which connects that server to this Discord server and returns its token ONCE; the
+ * plugin receives it automatically while it is waiting (`delivered: true`); otherwise the dashboard shows it once
+ * ("paste into plugins/Noti/token.txt").
+ *
+ * The plan sets how many servers stay ACTIVE (`limits.servers`: free 1, Premium 3, Premium Plus 10). A network that
+ * shares one token counts once. Over the limit (after a downgrade) the rest are kept but paused: pinned servers
+ * first, then the oldest, stay active - `active` on each server says which. An upgrade brings them back.
+ *
+ * Behind the `inGame` launch flag: every method answers 403 until it is beta/public for the caller.
+ */
+export declare class APIGuildInGame {
+    private web;
+    constructor(web: WebDataManager);
+    /** Every connected server, oldest first, which are active, and what the plan allows. */
+    getInGameServers({ auth, guildId }: InGameFunctionsInput['getInGameServers']): Promise<WebResponse<InGameServersData>>;
+    /**
+     * Redeem the code a server printed. Case, spaces and the dash do not matter. Returns the new server and its
+     * `token`, which is never shown again. 400 when the code is wrong, expired or already used ("Run /noti connect
+     * for a new one"); 403 with `{ message, limit, current }` inside `error` when the plan cannot connect another.
+     */
+    createInGameServer({ auth, guildId, code }: InGameFunctionsInput['createInGameServer']): Promise<WebResponse<InGameServerCreatedData>>;
+    /**
+     * Rename a server, or pin it so it stays active ahead of older ones when the server is over its plan limit.
+     * Send either or both. Returns the whole list again (pinning can change which others are active). 404 when it
+     * is not this Discord server's.
+     */
+    updateInGameServer({ auth, guildId, serverId, ...body }: InGameFunctionsInput['updateInGameServer']): Promise<WebResponse<InGameServersData>>;
+    /** Replace the server's token; the old one stops working at once. The new `token` is returned ONCE. */
+    rotateInGameServerToken({ auth, guildId, serverId }: InGameFunctionsInput['rotateInGameServerToken']): Promise<WebResponse<InGameTokenData>>;
+    /**
+     * "Send a test alert": a sample event through the real connection, shown to the server's admins in-game. 409 when
+     * the server is not connected right now; 403 with the vote-gate error when the caller must vote first; 429 with
+     * `retryAfterSeconds` inside `error` when tests are sent too quickly (count down from it).
+     */
+    sendInGameServerTest({ auth, guildId, serverId }: InGameFunctionsInput['sendInGameServerTest']): Promise<WebResponse<InGameTestData>>;
+    /**
+     * Every creator, for the "Choose what shows in Minecraft" picker: whether it has a Discord channel (a creator with
+     * none can never show in Minecraft - say so next to it), what shows today, and the types its platform has.
+     */
+    getInGameCreators({ auth, guildId }: InGameFunctionsInput['getInGameCreators']): Promise<WebResponse<InGameCreatorsData>>;
+    /**
+     * Save the picker in one call. Each entry changes only the fields it sends; unknown types and picks are dropped.
+     * Max 500 entries. The per-creator settings page can also send `inGame` / `inGameTypes` / `inGameServerIds` on the
+     * normal creator save. Returns the list again.
+     */
+    updateInGameCreators({ auth, guildId, creators }: InGameFunctionsInput['updateInGameCreators']): Promise<WebResponse<InGameCreatorsUpdatedData>>;
+    /**
+     * Minecraft giveaway prizes (in-game P7): one row per winner who linked a Minecraft account, and where it stands -
+     * `pending` (waiting for the winner to be online on the paying server), `claimed` (a node is running it), `done`,
+     * or `failed` (with the plugin's reason, e.g. an unknown preset). `giveawayId` narrows it to one giveaway.
+     * `paused`: the server lost InGameRewards, so stored presets are kept but nothing new is paid.
+     */
+    getInGameRewards({ auth, guildId, giveawayId }: InGameFunctionsInput['getInGameRewards']): Promise<WebResponse<InGameRewardsData>>;
+    /** Disconnect a server. To move it to another Discord server, disconnect it and run /noti connect again. */
+    deleteInGameServer({ auth, guildId, serverId }: InGameFunctionsInput['deleteInGameServer']): Promise<WebResponse<InGameServersData>>;
+}
+/** Games a server can connect from. Only Minecraft today; Roblox is planned. */
+export type InGameGame = 'minecraft' | 'roblox';
+export type InGameServer = {
+    id: string;
+    game: InGameGame;
+    /** The server's MOTD at connect time (colour codes stripped), or the name it was renamed to. */
+    name: string;
+    /** The start of the server's token, so an owner can tell which token a server holds. */
+    tokenPrefix: string;
+    /** Discord user id of whoever connected it. */
+    connectedBy: string;
+    /** Kept active ahead of older servers when over the plan limit. */
+    pinned: boolean;
+    /** False when the Discord server is over its plan limit and this one is paused. */
+    active: boolean;
+    /** ISO time the server was last connected, or null if it never has been. */
+    lastSeenAt: string | null;
+    createdAt: string;
+    /** Connected right now (at least one node). Live, not stored. */
+    connected: boolean;
+    /** Every node connected right now: a single server, or each backend and proxy of a network sharing the token. */
+    nodes: InGameNode[];
+    /** The reward presets its rewards.yml offers, as last reported - the giveaway form's dropdown (P7). */
+    rewardPresets: string[];
+};
+export type InGameNode = {
+    /** Stable per installation; a network's backends each have their own. */
+    instanceId: string;
+    /** "Paper", "Spigot", "Velocity", "BungeeCord", ... */
+    software: string | null;
+    /** Null on a proxy. */
+    mcVersion: string | null;
+    pluginVersion: string | null;
+    players: number | null;
+    /** False means offline mode: account linking will be unavailable (P6). Null when unknown. */
+    onlineMode: boolean | null;
+    /** A BungeeCord / Velocity proxy. */
+    proxy: boolean;
+    connectedAt: string;
+    /**
+     * Players can link accounts through this node: online mode, or behind a proxy that forwards checked identities.
+     * Use this, not `onlineMode`, for "account linking unavailable": an offline-mode backend behind such a proxy is
+     * normal and links fine.
+     */
+    accountLinking: boolean;
+};
+export type InGameServersLimits = {
+    /** Servers the plan keeps active. */
+    servers: number;
+    /** Servers connected now, active or paused. */
+    current: number;
+    /** Whether giveaway reward commands are available (`InGameRewards`, Premium). */
+    rewards: boolean;
+};
+export type InGameServersData = {
+    servers: InGameServer[];
+    limits: InGameServersLimits;
+};
+export type InGameServerCreatedData = {
+    server: InGameServer;
+    /** Shown once. The plugin stores it in plugins/Noti/token.txt. */
+    token: string;
+    /**
+     * True when the waiting server received the token itself - nothing to show. False when it stopped waiting (it
+     * restarted, or the code was typed after it shut down): show `token` once, with "paste into plugins/Noti/token.txt".
+     */
+    delivered: boolean;
+};
+export type InGameTestData = {
+    sent: true;
+    nodes: number;
+};
+export type InGameCreator = {
+    platform: InGamePlatform;
+    username: string;
+    /** False: no Discord channel set, so it cannot show in Minecraft (Minecraft mirrors Discord). */
+    hasChannel: boolean;
+    inGame: boolean;
+    /** Empty = every type in `availableTypes`. */
+    inGameTypes: InGameAlertType[];
+    /** Empty = every active server. */
+    inGameServerIds: string[];
+    /** The types this creator's platform has. */
+    availableTypes: InGameAlertType[];
+};
+export type InGameCreatorsData = {
+    creators: InGameCreator[];
+};
+/**
+ * `updated`: rows changed. `hiddenByMember`: creators NOT turned on because their member hid them from Minecraft in
+ * the Influencer Panel - show "Hidden by the member" next to them; only they can change it.
+ */
+export type InGameCreatorsUpdatedData = InGameCreatorsData & {
+    updated: number;
+    hiddenByMember: {
+        platform: string;
+        username: string;
+    }[];
+};
+export type InGameCreatorUpdate = {
+    platform: InGamePlatform;
+    username: string;
+    inGame?: boolean;
+    inGameTypes?: InGameAlertType[];
+    inGameServerIds?: string[];
+};
+export type InGameTokenData = {
+    token: string;
+    tokenPrefix: string;
+};
+export type InGameFunctionsInput = {
+    'getInGameServers': {
+        auth: string;
+        guildId: string;
+    };
+    'createInGameServer': {
+        auth: string;
+        guildId: string;
+        code: string;
+    };
+    'updateInGameServer': {
+        auth: string;
+        guildId: string;
+        serverId: string;
+        name?: string;
+        pinned?: boolean;
+    };
+    'rotateInGameServerToken': {
+        auth: string;
+        guildId: string;
+        serverId: string;
+    };
+    'sendInGameServerTest': {
+        auth: string;
+        guildId: string;
+        serverId: string;
+    };
+    'getInGameCreators': {
+        auth: string;
+        guildId: string;
+    };
+    'updateInGameCreators': {
+        auth: string;
+        guildId: string;
+        creators: InGameCreatorUpdate[];
+    };
+    'deleteInGameServer': {
+        auth: string;
+        guildId: string;
+        serverId: string;
+    };
+    'getInGameRewards': {
+        auth: string;
+        guildId: string;
+        giveawayId?: string;
+    };
+};
+export type InGameGetReturnTypes = {
+    'getInGameServersRaw': Awaited<ReturnType<APIGuildInGame['getInGameServers']>>;
+    'getInGameServersSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuildInGame['getInGameServers']>>>;
+    'createInGameServerRaw': Awaited<ReturnType<APIGuildInGame['createInGameServer']>>;
+    'createInGameServerSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuildInGame['createInGameServer']>>>;
+    'updateInGameServerRaw': Awaited<ReturnType<APIGuildInGame['updateInGameServer']>>;
+    'updateInGameServerSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuildInGame['updateInGameServer']>>>;
+    'rotateInGameServerTokenRaw': Awaited<ReturnType<APIGuildInGame['rotateInGameServerToken']>>;
+    'rotateInGameServerTokenSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuildInGame['rotateInGameServerToken']>>>;
+    'getInGameCreatorsRaw': Awaited<ReturnType<APIGuildInGame['getInGameCreators']>>;
+    'getInGameCreatorsSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuildInGame['getInGameCreators']>>>;
+    'updateInGameCreatorsRaw': Awaited<ReturnType<APIGuildInGame['updateInGameCreators']>>;
+    'updateInGameCreatorsSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuildInGame['updateInGameCreators']>>>;
+    'sendInGameServerTestRaw': Awaited<ReturnType<APIGuildInGame['sendInGameServerTest']>>;
+    'sendInGameServerTestSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuildInGame['sendInGameServerTest']>>>;
+    'deleteInGameServerRaw': Awaited<ReturnType<APIGuildInGame['deleteInGameServer']>>;
+    'deleteInGameServerSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuildInGame['deleteInGameServer']>>>;
+    'getInGameRewardsRaw': Awaited<ReturnType<APIGuildInGame['getInGameRewards']>>;
+    'getInGameRewardsSuccess': CancelOutWebResponses<Awaited<ReturnType<APIGuildInGame['getInGameRewards']>>>;
+};
+export type InGameRewardStatus = 'pending' | 'claimed' | 'done' | 'failed';
+/** One giveaway prize paid in Minecraft. `uuid` is the winner's linked Minecraft account; `preset` its rewards.yml name. */
+export type InGameReward = {
+    rewardId: string;
+    giveawayId: string;
+    userId: string;
+    uuid: string;
+    preset: string;
+    serverId: string;
+    status: InGameRewardStatus;
+    /** Why it failed, from the plugin; null otherwise. */
+    error: string | null;
+    createdAt: string;
+    doneAt: string | null;
+};
+export type InGameRewardsData = {
+    rewards: InGameReward[];
+    paused: boolean;
+};

package/dist/classes/guildInGame.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APIGuildInGame = void 0;
+/**
+ * Minecraft - game servers connected to a Discord server (Noti-v3 phases/in-game/).
+ *
+ * A server running the Noti plugin with no token prints a code (`K7P-2QX`) to its console. The owner enters it
+ * here (`createInGameServer`), which connects that server to this Discord server and returns its token ONCE; the
+ * plugin receives it automatically while it is waiting (`delivered: true`); otherwise the dashboard shows it once
+ * ("paste into plugins/Noti/token.txt").
+ *
+ * The plan sets how many servers stay ACTIVE (`limits.servers`: free 1, Premium 3, Premium Plus 10). A network that
+ * shares one token counts once. Over the limit (after a downgrade) the rest are kept but paused: pinned servers
+ * first, then the oldest, stay active - `active` on each server says which. An upgrade brings them back.
+ *
+ * Behind the `inGame` launch flag: every method answers 403 until it is beta/public for the caller.
+ */
+class APIGuildInGame {
+    web;
+    constructor(web) {
+        this.web = web;
+    }
+    /** Every connected server, oldest first, which are active, and what the plan allows. */
+    async getInGameServers({ auth, guildId }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp(`/data/guild/${guildId}/in-game/servers`),
+        });
+    }
+    /**
+     * Redeem the code a server printed. Case, spaces and the dash do not matter. Returns the new server and its
+     * `token`, which is never shown again. 400 when the code is wrong, expired or already used ("Run /noti connect
+     * for a new one"); 403 with `{ message, limit, current }` inside `error` when the plan cannot connect another.
+     */
+    async createInGameServer({ auth, guildId, code }) {
+        return await this.web.request({
+            method: 'POST', auth,
+            endpoint: this.web.qp(`/data/guild/${guildId}/in-game/servers`),
+            body: { code },
+        });
+    }
+    /**
+     * Rename a server, or pin it so it stays active ahead of older ones when the server is over its plan limit.
+     * Send either or both. Returns the whole list again (pinning can change which others are active). 404 when it
+     * is not this Discord server's.
+     */
+    async updateInGameServer({ auth, guildId, serverId, ...body }) {
+        return await this.web.request({
+            method: 'PATCH', auth,
+            endpoint: this.web.qp(`/data/guild/${guildId}/in-game/servers/${serverId}`),
+            body,
+        });
+    }
+    /** Replace the server's token; the old one stops working at once. The new `token` is returned ONCE. */
+    async rotateInGameServerToken({ auth, guildId, serverId }) {
+        return await this.web.request({
+            method: 'POST', auth,
+            endpoint: this.web.qp(`/data/guild/${guildId}/in-game/servers/${serverId}/token`),
+        });
+    }
+    /**
+     * "Send a test alert": a sample event through the real connection, shown to the server's admins in-game. 409 when
+     * the server is not connected right now; 403 with the vote-gate error when the caller must vote first; 429 with
+     * `retryAfterSeconds` inside `error` when tests are sent too quickly (count down from it).
+     */
+    async sendInGameServerTest({ auth, guildId, serverId }) {
+        return await this.web.request({
+            method: 'POST', auth,
+            endpoint: this.web.qp(`/data/guild/${guildId}/in-game/servers/${serverId}/test`),
+        });
+    }
+    /**
+     * Every creator, for the "Choose what shows in Minecraft" picker: whether it has a Discord channel (a creator with
+     * none can never show in Minecraft - say so next to it), what shows today, and the types its platform has.
+     */
+    async getInGameCreators({ auth, guildId }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp(`/data/guild/${guildId}/in-game/creators`),
+        });
+    }
+    /**
+     * Save the picker in one call. Each entry changes only the fields it sends; unknown types and picks are dropped.
+     * Max 500 entries. The per-creator settings page can also send `inGame` / `inGameTypes` / `inGameServerIds` on the
+     * normal creator save. Returns the list again.
+     */
+    async updateInGameCreators({ auth, guildId, creators }) {
+        return await this.web.request({
+            method: 'PATCH', auth,
+            endpoint: this.web.qp(`/data/guild/${guildId}/in-game/creators`),
+            body: { creators },
+        });
+    }
+    /**
+     * Minecraft giveaway prizes (in-game P7): one row per winner who linked a Minecraft account, and where it stands -
+     * `pending` (waiting for the winner to be online on the paying server), `claimed` (a node is running it), `done`,
+     * or `failed` (with the plugin's reason, e.g. an unknown preset). `giveawayId` narrows it to one giveaway.
+     * `paused`: the server lost InGameRewards, so stored presets are kept but nothing new is paid.
+     */
+    async getInGameRewards({ auth, guildId, giveawayId }) {
+        return await this.web.request({
+            method: 'GET', auth,
+            endpoint: this.web.qp(`/data/guild/${guildId}/in-game/rewards`, { giveawayId }),
+        });
+    }
+    /** Disconnect a server. To move it to another Discord server, disconnect it and run /noti connect again. */
+    async deleteInGameServer({ auth, guildId, serverId }) {
+        return await this.web.request({
+            method: 'DELETE', auth,
+            endpoint: this.web.qp(`/data/guild/${guildId}/in-game/servers/${serverId}`),
+        });
+    }
+}
+exports.APIGuildInGame = APIGuildInGame;

package/dist/classes/guildInfluencerPanel.d.ts

@@ -87,6 +87,14 @@ export type GuildInfluencerPlatformSettings = {
     secondaryChannelId: string | null;
     /** The ping role for videos (YouTube, TikTok, Rumble) or posts (X). Null pings no one on those. */
     secondaryPingRoleId: string | null;
+    /**
+     * Minecraft (1.9.75): members' creators on this platform show on the server's connected Minecraft servers. Needs
+     * the `inGame` launch flag to turn on (403). Leave it out of a save to keep it as it is. Members can still hide
+     * their own from the panel's "My socials" in Discord.
+     */
+    inGame?: boolean;
+    /** Which kinds show (`IN_GAME_TYPES[platform]`); empty = every kind the platform has. */
+    inGameTypes?: string[];
 };
 /**
  * The panel message's look. `title` and `description` on every plan; the rest is Premium Plus.
@@ -287,6 +295,11 @@ export type GuildInfluencerEntry = {
     decidedByUsername?: string | null;
     /** Rumble only: 'channel' or 'user'. */
     rumbleType: string | null;
+    /**
+     * The member hid this creator from Minecraft (1.9.75). Only they can show it again: turning Minecraft on for it
+     * from the creator settings answers 409, and the bulk picker skips it (`hiddenByMember`).
+     */
+    inGameOptOut?: boolean;
     createdAt: string;
     updatedAt: string;
 };

package/dist/classes/guildMessageScheduler.d.ts

@@ -99,8 +99,18 @@ export type ScheduledButtonInput = {
     emojiUnicodeOrId?: string | null;
 };
 export type ScheduledMessageCreateBody = {
-    channelId: string;
+    /** Required while `sendToDiscord` is on (the default). Omit or null for a Minecraft-only message. */
+    channelId?: string | null;
     content: string;
+    /** Default true. At least one of `sendToDiscord` / `sendToInGame` must be on. */
+    sendToDiscord?: boolean;
+    /** Default false. Needs the `inGame` launch flag (403 otherwise); goes to every connected Minecraft server. */
+    sendToInGame?: boolean;
+    /**
+     * Restricted MiniMessage for Minecraft (`forbiddenMiniMessageTag` says what is refused). Blank or null = the
+     * Discord content converted. Placeholders as in `content`; a Minecraft-only message has no {channelName}.
+     */
+    minecraftContent?: string | null;
     embed?: ScheduledEmbedInput | null;
     buttons?: ScheduledButtonInput[];
     trigger?: ScheduledMessageTrigger;
@@ -118,6 +128,10 @@ export type ScheduledMessageCreateBody = {
 };
 export type ScheduledMessageEditBody = {
     content?: string;
+    /** Turning it off is refused (400) when the message does not also go to Discord. Needs the `inGame` flag. */
+    sendToInGame?: boolean;
+    /** null clears it: the Discord content is converted again. */
+    minecraftContent?: string | null;
     embed?: ScheduledEmbedInput | null;
     buttons?: ScheduledButtonInput[];
     webhookEnabled?: boolean;

package/dist/classes/publicGiveaways.d.ts

@@ -75,7 +75,7 @@ export type PublicGiveawaysGetReturnTypes = {
  * Every reason an entry can be refused. Mirrors `PUBLIC_ENTRY_REFUSALS` in Noti-v3's
  * `src/modules/publicGiveaways.ts`; the eligibility ones match the card's `requirements` / `entryFilter`.
  */
-export declare const PUBLIC_ENTRY_REFUSALS: readonly ["not_listed", "ended", "full", "not_member", "already_entered", "rate_limited", "role_whitelist", "role_blacklist", "joined_server_before", "account_created_before", "min_account_age", "boosting_server", "roles", "message_count"];
+export declare const PUBLIC_ENTRY_REFUSALS: readonly ["not_listed", "ended", "full", "not_member", "already_entered", "rate_limited", "role_whitelist", "role_blacklist", "joined_server_before", "account_created_before", "min_account_age", "boosting_server", "roles", "message_count", "minecraft_not_linked"];
 export type PublicEntryRefusal = typeof PUBLIC_ENTRY_REFUSALS[number];
 export type PublicGiveawayRole = {
     id: string;

package/dist/classes/publicGiveaways.js

@@ -76,5 +76,5 @@ exports.APIPublicGiveaways = APIPublicGiveaways;
 exports.PUBLIC_ENTRY_REFUSALS = [
     'not_listed', 'ended', 'full', 'not_member', 'already_entered', 'rate_limited',
     'role_whitelist', 'role_blacklist', 'joined_server_before', 'account_created_before', 'min_account_age',
-    'boosting_server', 'roles', 'message_count',
+    'boosting_server', 'roles', 'message_count', 'minecraft_not_linked',
 ];

package/dist/core/manager.d.ts

@@ -10,6 +10,7 @@ import { APIGuildStatChannels } from '../classes/guildStatChannels';
 import { APIGuildClipForward } from '../classes/guildClipForward';
 import { APIGuildDrops } from '../classes/guildDrops';
 import { APIGuildBadges } from '../classes/guildBadges';
+import { APIGuildInGame } from '../classes/guildInGame';
 import { APIGuildBounties } from '../classes/guildBounties';
 import { APIGuildAssistant } from '../classes/guildAssistant';
 import { APIGuildAutoRoles } from '../classes/guildAutoRoles';
@@ -75,6 +76,7 @@ export declare class WebDataManager {
     readonly telemetry: APITelemetry;
     readonly guildDrops: APIGuildDrops;
     readonly guildBadges: APIGuildBadges;
+    readonly guildInGame: APIGuildInGame;
     readonly guildBounties: APIGuildBounties;
     readonly guildAssistant: APIGuildAssistant;
     readonly guildAutoRoles: APIGuildAutoRoles;

package/dist/core/manager.js

@@ -16,6 +16,7 @@ const guildStatChannels_1 = require("../classes/guildStatChannels");
 const guildClipForward_1 = require("../classes/guildClipForward");
 const guildDrops_1 = require("../classes/guildDrops");
 const guildBadges_1 = require("../classes/guildBadges");
+const guildInGame_1 = require("../classes/guildInGame");
 const guildBounties_1 = require("../classes/guildBounties");
 const guildAssistant_1 = require("../classes/guildAssistant");
 const guildAutoRoles_1 = require("../classes/guildAutoRoles");
@@ -79,6 +80,7 @@ class WebDataManager {
     telemetry = new telemetry_1.APITelemetry(this);
     guildDrops = new guildDrops_1.APIGuildDrops(this);
     guildBadges = new guildBadges_1.APIGuildBadges(this);
+    guildInGame = new guildInGame_1.APIGuildInGame(this);
     guildBounties = new guildBounties_1.APIGuildBounties(this);
     guildAssistant = new guildAssistant_1.APIGuildAssistant(this);
     guildAutoRoles = new guildAutoRoles_1.APIGuildAutoRoles(this);

package/dist/index.d.ts

@@ -27,6 +27,7 @@ export * from './classes/telemetry';
 export * from './classes/vods';
 export * from './classes/guildDrops';
 export * from './classes/guildBadges';
+export * from './classes/guildInGame';
 export * from './classes/guildBounties';
 export * from './classes/guildAssistant';
 export * from './classes/guildAutoRoles';
@@ -47,6 +48,11 @@ export { GuildMessageTypeEnum, StreamerMessageTypeEnum, PlatformEnum, $Enums } f
 export { FEATURE_NAMES, } from './other/features';
 export { OFFLINE_GRACE_CHOICES, OFFLINE_GRACE_DEFAULT, OFFLINE_GRACE_PLATFORMS, } from './other/offlineGrace';
 export type { OfflineGraceMinutes, OfflineGracePlatform } from './other/offlineGrace';
+export { DESTINATION_TYPES, MAX_EXTRA_DESTINATIONS, normalizeExtraDestinations, extrasFor, readExtraPosts, hasLivePost, } from './other/multiDestination';
+export type { DestinationPlatform, DestinationType, ExtraDestination, ExtraPost } from './other/multiDestination';
+export { IN_GAME_TYPES, MAX_IN_GAME_SERVER_PICKS, normalizeInGameTypes, normalizeInGameServerIds, } from './other/inGameAlerts';
+export type { InGamePlatform, InGameAlertType, InGameAlert } from './other/inGameAlerts';
+export { forbiddenMiniMessageTag, escapeMiniMessage, safeMiniMessageUrl, NAMED_COLOURS } from './other/inGameMiniMessage';
 export { GIVEAWAY_CLAIM_WINDOWS, GIVEAWAY_CLAIM_WINDOW_LABELS, GIVEAWAY_MAX_CLAIM_ROUNDS, GIVEAWAY_WINNER_ROLE_MAX_DAYS, GIVEAWAY_MIN_ACCOUNT_AGE_MAX_DAYS, GIVEAWAY_WINNER_ROLE_FORBIDDEN_PERMISSIONS, } from './other/giveawayClaims';
 export type { GiveawayClaimWindow, GiveawayWinnerStatus } from './other/giveawayClaims';
 export type { FeatureName, FeatureStatus, ResolvedFeature, } from './other/features';

package/dist/index.js

@@ -14,7 +14,7 @@ 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.GIVEAWAY_WINNER_ROLE_FORBIDDEN_PERMISSIONS = exports.GIVEAWAY_MIN_ACCOUNT_AGE_MAX_DAYS = exports.GIVEAWAY_WINNER_ROLE_MAX_DAYS = exports.GIVEAWAY_MAX_CLAIM_ROUNDS = exports.GIVEAWAY_CLAIM_WINDOW_LABELS = exports.GIVEAWAY_CLAIM_WINDOWS = exports.OFFLINE_GRACE_PLATFORMS = exports.OFFLINE_GRACE_DEFAULT = exports.OFFLINE_GRACE_CHOICES = exports.FEATURE_NAMES = exports.$Enums = exports.PlatformEnum = exports.StreamerMessageTypeEnum = exports.GuildMessageTypeEnum = void 0;
+exports.GIVEAWAY_WINNER_ROLE_FORBIDDEN_PERMISSIONS = exports.GIVEAWAY_MIN_ACCOUNT_AGE_MAX_DAYS = exports.GIVEAWAY_WINNER_ROLE_MAX_DAYS = exports.GIVEAWAY_MAX_CLAIM_ROUNDS = exports.GIVEAWAY_CLAIM_WINDOW_LABELS = exports.GIVEAWAY_CLAIM_WINDOWS = exports.NAMED_COLOURS = exports.safeMiniMessageUrl = exports.escapeMiniMessage = exports.forbiddenMiniMessageTag = exports.normalizeInGameServerIds = exports.normalizeInGameTypes = exports.MAX_IN_GAME_SERVER_PICKS = exports.IN_GAME_TYPES = exports.hasLivePost = exports.readExtraPosts = exports.extrasFor = exports.normalizeExtraDestinations = exports.MAX_EXTRA_DESTINATIONS = exports.DESTINATION_TYPES = exports.OFFLINE_GRACE_PLATFORMS = exports.OFFLINE_GRACE_DEFAULT = exports.OFFLINE_GRACE_CHOICES = exports.FEATURE_NAMES = exports.$Enums = exports.PlatformEnum = exports.StreamerMessageTypeEnum = exports.GuildMessageTypeEnum = void 0;
 __exportStar(require("./core/manager"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./classes/@me"), exports);
@@ -44,6 +44,7 @@ __exportStar(require("./classes/telemetry"), exports);
 __exportStar(require("./classes/vods"), exports);
 __exportStar(require("./classes/guildDrops"), exports);
 __exportStar(require("./classes/guildBadges"), exports);
+__exportStar(require("./classes/guildInGame"), exports);
 __exportStar(require("./classes/guildBounties"), exports);
 __exportStar(require("./classes/guildAssistant"), exports);
 __exportStar(require("./classes/guildAutoRoles"), exports);
@@ -73,6 +74,23 @@ var offlineGrace_1 = require("./other/offlineGrace");
 Object.defineProperty(exports, "OFFLINE_GRACE_CHOICES", { enumerable: true, get: function () { return offlineGrace_1.OFFLINE_GRACE_CHOICES; } });
 Object.defineProperty(exports, "OFFLINE_GRACE_DEFAULT", { enumerable: true, get: function () { return offlineGrace_1.OFFLINE_GRACE_DEFAULT; } });
 Object.defineProperty(exports, "OFFLINE_GRACE_PLATFORMS", { enumerable: true, get: function () { return offlineGrace_1.OFFLINE_GRACE_PLATFORMS; } });
+var multiDestination_1 = require("./other/multiDestination");
+Object.defineProperty(exports, "DESTINATION_TYPES", { enumerable: true, get: function () { return multiDestination_1.DESTINATION_TYPES; } });
+Object.defineProperty(exports, "MAX_EXTRA_DESTINATIONS", { enumerable: true, get: function () { return multiDestination_1.MAX_EXTRA_DESTINATIONS; } });
+Object.defineProperty(exports, "normalizeExtraDestinations", { enumerable: true, get: function () { return multiDestination_1.normalizeExtraDestinations; } });
+Object.defineProperty(exports, "extrasFor", { enumerable: true, get: function () { return multiDestination_1.extrasFor; } });
+Object.defineProperty(exports, "readExtraPosts", { enumerable: true, get: function () { return multiDestination_1.readExtraPosts; } });
+Object.defineProperty(exports, "hasLivePost", { enumerable: true, get: function () { return multiDestination_1.hasLivePost; } });
+var inGameAlerts_1 = require("./other/inGameAlerts");
+Object.defineProperty(exports, "IN_GAME_TYPES", { enumerable: true, get: function () { return inGameAlerts_1.IN_GAME_TYPES; } });
+Object.defineProperty(exports, "MAX_IN_GAME_SERVER_PICKS", { enumerable: true, get: function () { return inGameAlerts_1.MAX_IN_GAME_SERVER_PICKS; } });
+Object.defineProperty(exports, "normalizeInGameTypes", { enumerable: true, get: function () { return inGameAlerts_1.normalizeInGameTypes; } });
+Object.defineProperty(exports, "normalizeInGameServerIds", { enumerable: true, get: function () { return inGameAlerts_1.normalizeInGameServerIds; } });
+var inGameMiniMessage_1 = require("./other/inGameMiniMessage");
+Object.defineProperty(exports, "forbiddenMiniMessageTag", { enumerable: true, get: function () { return inGameMiniMessage_1.forbiddenMiniMessageTag; } });
+Object.defineProperty(exports, "escapeMiniMessage", { enumerable: true, get: function () { return inGameMiniMessage_1.escapeMiniMessage; } });
+Object.defineProperty(exports, "safeMiniMessageUrl", { enumerable: true, get: function () { return inGameMiniMessage_1.safeMiniMessageUrl; } });
+Object.defineProperty(exports, "NAMED_COLOURS", { enumerable: true, get: function () { return inGameMiniMessage_1.NAMED_COLOURS; } });
 var giveawayClaims_1 = require("./other/giveawayClaims");
 Object.defineProperty(exports, "GIVEAWAY_CLAIM_WINDOWS", { enumerable: true, get: function () { return giveawayClaims_1.GIVEAWAY_CLAIM_WINDOWS; } });
 Object.defineProperty(exports, "GIVEAWAY_CLAIM_WINDOW_LABELS", { enumerable: true, get: function () { return giveawayClaims_1.GIVEAWAY_CLAIM_WINDOW_LABELS; } });