taverns.js 0.2.0

package/dist/collection.js

@@ -0,0 +1,144 @@
+"use strict";
+/**
+ * taverns.js - Collection
+ *
+ * A utility class that extends Map with convenience methods,
+ * with convenience methods for working with cached data.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Collection = void 0;
+class Collection extends Map {
+    /**
+     * Find the first value that satisfies the predicate.
+     */
+    find(fn) {
+        for (const [key, value] of this) {
+            if (fn(value, key, this))
+                return value;
+        }
+        return undefined;
+    }
+    /**
+     * Filter the collection and return a new Collection with matching entries.
+     */
+    filter(fn) {
+        const result = new Collection();
+        for (const [key, value] of this) {
+            if (fn(value, key, this))
+                result.set(key, value);
+        }
+        return result;
+    }
+    /**
+     * Map each value in the collection to a new value.
+     */
+    map(fn) {
+        const result = [];
+        for (const [key, value] of this) {
+            result.push(fn(value, key, this));
+        }
+        return result;
+    }
+    /**
+     * Check if any value satisfies the predicate.
+     */
+    some(fn) {
+        for (const [key, value] of this) {
+            if (fn(value, key, this))
+                return true;
+        }
+        return false;
+    }
+    /**
+     * Check if every value satisfies the predicate.
+     */
+    every(fn) {
+        for (const [key, value] of this) {
+            if (!fn(value, key, this))
+                return false;
+        }
+        return true;
+    }
+    /**
+     * Reduce the collection to a single value.
+     */
+    reduce(fn, initialValue) {
+        let accumulator = initialValue;
+        for (const [key, value] of this) {
+            accumulator = fn(accumulator, value, key, this);
+        }
+        return accumulator;
+    }
+    first(count) {
+        if (count === undefined) {
+            const iter = this.values();
+            return iter.next().value;
+        }
+        if (count < 0)
+            return this.last(count * -1);
+        count = Math.min(this.size, count);
+        const result = [];
+        const iter = this.values();
+        for (let i = 0; i < count; i++) {
+            const next = iter.next();
+            if (next.done)
+                break;
+            result.push(next.value);
+        }
+        return result;
+    }
+    last(count) {
+        const arr = [...this.values()];
+        if (count === undefined)
+            return arr[arr.length - 1];
+        if (count < 0)
+            return this.first(count * -1);
+        if (!count)
+            return [];
+        return arr.slice(-count);
+    }
+    random(count) {
+        const arr = [...this.values()];
+        if (count === undefined) {
+            return arr[Math.floor(Math.random() * arr.length)];
+        }
+        return Array.from({ length: Math.min(count, arr.length) }, () => {
+            const index = Math.floor(Math.random() * arr.length);
+            return arr.splice(index, 1)[0];
+        });
+    }
+    /**
+     * Return an array of all values in the collection.
+     */
+    toArray() {
+        return [...this.values()];
+    }
+    /**
+     * Return an array of all keys in the collection.
+     */
+    keyArray() {
+        return [...this.keys()];
+    }
+    /**
+     * Sort the collection by a comparator and return a new Collection.
+     */
+    sort(compareFn = () => 0) {
+        const entries = [...this.entries()].sort((a, b) => compareFn(a[1], b[1], a[0], b[0]));
+        const sorted = new Collection();
+        for (const [key, value] of entries) {
+            sorted.set(key, value);
+        }
+        return sorted;
+    }
+    /**
+     * Create a Collection from an array using a key extractor.
+     */
+    static from(items, keyFn) {
+        const collection = new Collection();
+        for (const item of items) {
+            collection.set(keyFn(item), item);
+        }
+        return collection;
+    }
+}
+exports.Collection = Collection;

package/dist/constants.d.ts

@@ -0,0 +1,117 @@
+/**
+ * taverns.js - Constants
+ *
+ * API versions, URLs, enums, and event names used throughout the SDK.
+ */
+export declare const API_VERSION = "v1";
+export declare const DEFAULT_API_URL = "https://api.tav.gg/api/v1";
+export declare const DEFAULT_WS_URL = "wss://ws.tav.gg";
+export declare const BOT_TOKEN_PREFIX = "tavbot_";
+export declare enum ChannelType {
+    TEXT = "TEXT",
+    ANNOUNCEMENT = "ANNOUNCEMENT",
+    THREAD = "THREAD",
+    VOICE = "VOICE",
+    MIRROR = "MIRROR",
+    FORUM = "FORUM"
+}
+export declare enum MessageStatus {
+    SENT = "SENT",
+    FILTERED = "FILTERED",
+    DELETED = "DELETED"
+}
+export declare enum BotStatus {
+    CREATED = "CREATED",
+    ACTIVE = "ACTIVE",
+    DISABLED = "DISABLED",
+    BANNED = "BANNED"
+}
+export declare enum MemberStatus {
+    ACTIVE = "ACTIVE",
+    PENDING = "PENDING",
+    BANNED = "BANNED"
+}
+export declare const GatewayIntents: {
+    readonly TAVERN_MESSAGES: bigint;
+    readonly MESSAGE_CONTENT: bigint;
+    readonly TAVERN_MEMBERS: bigint;
+    readonly TAVERN_MODERATION: bigint;
+    readonly TAVERN_CHANNELS: bigint;
+    readonly TAVERN_THREADS: bigint;
+    readonly TAVERN_FORUMS: bigint;
+    readonly TAVERN_ROLES: bigint;
+    readonly TAVERN_SETTINGS: bigint;
+    readonly TAVERN_EVENTS: bigint;
+    readonly TAVERN_VOICE: bigint;
+    readonly TAVERN_BROADCASTS: bigint;
+    readonly TAVERN_TYPING: bigint;
+    readonly TAVERN_REACTIONS: bigint;
+    readonly TAVERN_PINS: bigint;
+    readonly INTERACTIONS: bigint;
+    /** All non-privileged intents */
+    readonly DEFAULT: 32761n;
+    /** All intents including privileged */
+    readonly ALL: 65535n;
+};
+export declare enum CommandOptionType {
+    STRING = 1,
+    INTEGER = 2,
+    BOOLEAN = 3,
+    USER = 4,
+    CHANNEL = 5,
+    ROLE = 6,
+    NUMBER = 7
+}
+export declare enum GatewayEvent {
+    READY = "ready",
+    RECONNECTING = "reconnecting",
+    DISCONNECTED = "disconnected",
+    ERROR = "error",
+    DEBUG = "debug",
+    MESSAGE_CREATE = "tavern_message",
+    MESSAGE_EDIT = "tavern_message_edited",
+    MESSAGE_DELETE = "tavern_message_deleted",
+    MESSAGES_BULK_DELETE = "tavern_messages_bulk_deleted",
+    MESSAGE_PINNED = "tavern_message_pinned",
+    MESSAGE_UNPINNED = "tavern_message_unpinned",
+    MESSAGE_PUBLISHED = "tavern_message_published",
+    MESSAGE_MEDIA_PROCESSED = "tavern_message_media_processed",
+    MEMBER_JOINED = "tavern_member_joined",
+    MEMBER_LEFT = "tavern_member_left",
+    MEMBER_MUTED = "tavern_member_muted",
+    MEMBER_UNMUTED = "tavern_member_unmuted",
+    CHANNEL_CREATED = "tavern_channel_created",
+    CHANNEL_UPDATED = "tavern_channel_updated",
+    CHANNEL_DELETED = "tavern_channel_deleted",
+    THREAD_CREATED = "tavern_thread_created",
+    THREAD_UPDATED = "tavern_thread_updated",
+    THREAD_DELETED = "tavern_thread_deleted",
+    THREAD_ARCHIVED = "tavern_thread_archived",
+    THREAD_MESSAGE = "tavern_thread_message",
+    FORUM_POST_CREATED = "tavern_forum_post_created",
+    FORUM_SETTINGS_UPDATED = "tavern_forum_settings_updated",
+    FORUM_POST_TAGS_UPDATED = "tavern_forum_post_tags_updated",
+    ROLE_UPDATED = "tavern_role_updated",
+    ROLE_DELETED = "tavern_role_deleted",
+    TAVERN_UPDATED = "tavern_updated",
+    EVENT_CREATED = "tavern_event_created",
+    EVENT_UPDATED = "tavern_event_updated",
+    EVENT_DELETED = "tavern_event_deleted",
+    EVENT_STARTING = "tavern_event_starting",
+    EVENT_ENDED = "tavern_event_ended",
+    VOICE_STATE_UPDATE = "tavern_voice_state_update",
+    VOICE_SERVER_MUTE = "tavern_voice_server_mute",
+    VOICE_USER_DISCONNECTED = "tavern_voice_user_disconnected",
+    TYPING_START = "tavern_typing_start",
+    TYPING_STOP = "tavern_typing_stop",
+    BOT_INSTALLED = "bot_installed",
+    BOT_REMOVED = "bot_removed",
+    INTERACTION_CREATE = "interaction_create"
+}
+export declare enum GatewayAction {
+    HEARTBEAT = "heartbeat",
+    TYPING_START = "tavern_typing_start",
+    TYPING_STOP = "tavern_typing_stop",
+    MARK_READ = "tavern_mark_read"
+}
+export declare const FRIENDLY_EVENT_MAP: Record<string, string>;

package/dist/constants.js

@@ -0,0 +1,190 @@
+"use strict";
+/**
+ * taverns.js - Constants
+ *
+ * API versions, URLs, enums, and event names used throughout the SDK.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FRIENDLY_EVENT_MAP = exports.GatewayAction = exports.GatewayEvent = exports.CommandOptionType = exports.GatewayIntents = exports.MemberStatus = exports.BotStatus = exports.MessageStatus = exports.ChannelType = exports.BOT_TOKEN_PREFIX = exports.DEFAULT_WS_URL = exports.DEFAULT_API_URL = exports.API_VERSION = void 0;
+// ─── API Configuration ──────────────────────────────────────
+exports.API_VERSION = 'v1';
+exports.DEFAULT_API_URL = 'https://api.tav.gg/api/v1';
+exports.DEFAULT_WS_URL = 'wss://ws.tav.gg';
+// ─── Bot Token Prefix ────────────────────────────────────────
+exports.BOT_TOKEN_PREFIX = 'tavbot_';
+// ─── Channel Types ───────────────────────────────────────────
+var ChannelType;
+(function (ChannelType) {
+    ChannelType["TEXT"] = "TEXT";
+    ChannelType["ANNOUNCEMENT"] = "ANNOUNCEMENT";
+    ChannelType["THREAD"] = "THREAD";
+    ChannelType["VOICE"] = "VOICE";
+    ChannelType["MIRROR"] = "MIRROR";
+    ChannelType["FORUM"] = "FORUM";
+})(ChannelType || (exports.ChannelType = ChannelType = {}));
+// ─── Message Status ──────────────────────────────────────────
+var MessageStatus;
+(function (MessageStatus) {
+    MessageStatus["SENT"] = "SENT";
+    MessageStatus["FILTERED"] = "FILTERED";
+    MessageStatus["DELETED"] = "DELETED";
+})(MessageStatus || (exports.MessageStatus = MessageStatus = {}));
+// ─── Bot Application Status ─────────────────────────────────
+var BotStatus;
+(function (BotStatus) {
+    BotStatus["CREATED"] = "CREATED";
+    BotStatus["ACTIVE"] = "ACTIVE";
+    BotStatus["DISABLED"] = "DISABLED";
+    BotStatus["BANNED"] = "BANNED";
+})(BotStatus || (exports.BotStatus = BotStatus = {}));
+// ─── Member Status ──────────────────────────────────────────
+var MemberStatus;
+(function (MemberStatus) {
+    MemberStatus["ACTIVE"] = "ACTIVE";
+    MemberStatus["PENDING"] = "PENDING";
+    MemberStatus["BANNED"] = "BANNED";
+})(MemberStatus || (exports.MemberStatus = MemberStatus = {}));
+// ─── Gateway Intents ────────────────────────────────────────
+// Bitfield values controlling which events the bot receives.
+// Pass a combination of these to the Client constructor to filter events.
+exports.GatewayIntents = {
+    TAVERN_MESSAGES: 1n << 0n,
+    MESSAGE_CONTENT: 1n << 1n, // Privileged
+    TAVERN_MEMBERS: 1n << 2n, // Privileged
+    TAVERN_MODERATION: 1n << 3n,
+    TAVERN_CHANNELS: 1n << 4n,
+    TAVERN_THREADS: 1n << 5n,
+    TAVERN_FORUMS: 1n << 6n,
+    TAVERN_ROLES: 1n << 7n,
+    TAVERN_SETTINGS: 1n << 8n,
+    TAVERN_EVENTS: 1n << 9n,
+    TAVERN_VOICE: 1n << 10n,
+    TAVERN_BROADCASTS: 1n << 11n,
+    TAVERN_TYPING: 1n << 12n,
+    TAVERN_REACTIONS: 1n << 13n,
+    TAVERN_PINS: 1n << 14n,
+    INTERACTIONS: 1n << 15n,
+    /** All non-privileged intents */
+    DEFAULT: 0x7ff9n,
+    /** All intents including privileged */
+    ALL: 0xffffn,
+};
+// ─── Command Option Types ───────────────────────────────────
+// Types for slash command options.
+var CommandOptionType;
+(function (CommandOptionType) {
+    CommandOptionType[CommandOptionType["STRING"] = 1] = "STRING";
+    CommandOptionType[CommandOptionType["INTEGER"] = 2] = "INTEGER";
+    CommandOptionType[CommandOptionType["BOOLEAN"] = 3] = "BOOLEAN";
+    CommandOptionType[CommandOptionType["USER"] = 4] = "USER";
+    CommandOptionType[CommandOptionType["CHANNEL"] = 5] = "CHANNEL";
+    CommandOptionType[CommandOptionType["ROLE"] = 6] = "ROLE";
+    CommandOptionType[CommandOptionType["NUMBER"] = 7] = "NUMBER";
+})(CommandOptionType || (exports.CommandOptionType = CommandOptionType = {}));
+// ─── Gateway Events ─────────────────────────────────────────
+// Events emitted by the WebSocket gateway that bots can listen to.
+var GatewayEvent;
+(function (GatewayEvent) {
+    // Connection lifecycle
+    GatewayEvent["READY"] = "ready";
+    GatewayEvent["RECONNECTING"] = "reconnecting";
+    GatewayEvent["DISCONNECTED"] = "disconnected";
+    GatewayEvent["ERROR"] = "error";
+    GatewayEvent["DEBUG"] = "debug";
+    // Messages
+    GatewayEvent["MESSAGE_CREATE"] = "tavern_message";
+    GatewayEvent["MESSAGE_EDIT"] = "tavern_message_edited";
+    GatewayEvent["MESSAGE_DELETE"] = "tavern_message_deleted";
+    GatewayEvent["MESSAGES_BULK_DELETE"] = "tavern_messages_bulk_deleted";
+    GatewayEvent["MESSAGE_PINNED"] = "tavern_message_pinned";
+    GatewayEvent["MESSAGE_UNPINNED"] = "tavern_message_unpinned";
+    GatewayEvent["MESSAGE_PUBLISHED"] = "tavern_message_published";
+    GatewayEvent["MESSAGE_MEDIA_PROCESSED"] = "tavern_message_media_processed";
+    // Members
+    GatewayEvent["MEMBER_JOINED"] = "tavern_member_joined";
+    GatewayEvent["MEMBER_LEFT"] = "tavern_member_left";
+    GatewayEvent["MEMBER_MUTED"] = "tavern_member_muted";
+    GatewayEvent["MEMBER_UNMUTED"] = "tavern_member_unmuted";
+    // Channels
+    GatewayEvent["CHANNEL_CREATED"] = "tavern_channel_created";
+    GatewayEvent["CHANNEL_UPDATED"] = "tavern_channel_updated";
+    GatewayEvent["CHANNEL_DELETED"] = "tavern_channel_deleted";
+    // Threads
+    GatewayEvent["THREAD_CREATED"] = "tavern_thread_created";
+    GatewayEvent["THREAD_UPDATED"] = "tavern_thread_updated";
+    GatewayEvent["THREAD_DELETED"] = "tavern_thread_deleted";
+    GatewayEvent["THREAD_ARCHIVED"] = "tavern_thread_archived";
+    GatewayEvent["THREAD_MESSAGE"] = "tavern_thread_message";
+    // Forum
+    GatewayEvent["FORUM_POST_CREATED"] = "tavern_forum_post_created";
+    GatewayEvent["FORUM_SETTINGS_UPDATED"] = "tavern_forum_settings_updated";
+    GatewayEvent["FORUM_POST_TAGS_UPDATED"] = "tavern_forum_post_tags_updated";
+    // Roles
+    GatewayEvent["ROLE_UPDATED"] = "tavern_role_updated";
+    GatewayEvent["ROLE_DELETED"] = "tavern_role_deleted";
+    // Tavern
+    GatewayEvent["TAVERN_UPDATED"] = "tavern_updated";
+    // Events
+    GatewayEvent["EVENT_CREATED"] = "tavern_event_created";
+    GatewayEvent["EVENT_UPDATED"] = "tavern_event_updated";
+    GatewayEvent["EVENT_DELETED"] = "tavern_event_deleted";
+    GatewayEvent["EVENT_STARTING"] = "tavern_event_starting";
+    GatewayEvent["EVENT_ENDED"] = "tavern_event_ended";
+    // Voice
+    GatewayEvent["VOICE_STATE_UPDATE"] = "tavern_voice_state_update";
+    GatewayEvent["VOICE_SERVER_MUTE"] = "tavern_voice_server_mute";
+    GatewayEvent["VOICE_USER_DISCONNECTED"] = "tavern_voice_user_disconnected";
+    // Typing
+    GatewayEvent["TYPING_START"] = "tavern_typing_start";
+    GatewayEvent["TYPING_STOP"] = "tavern_typing_stop";
+    // Bot lifecycle
+    GatewayEvent["BOT_INSTALLED"] = "bot_installed";
+    GatewayEvent["BOT_REMOVED"] = "bot_removed";
+    // Interactions (slash commands)
+    GatewayEvent["INTERACTION_CREATE"] = "interaction_create";
+})(GatewayEvent || (exports.GatewayEvent = GatewayEvent = {}));
+// ─── WebSocket Actions ──────────────────────────────────────
+// Actions the bot can send to the gateway.
+var GatewayAction;
+(function (GatewayAction) {
+    GatewayAction["HEARTBEAT"] = "heartbeat";
+    GatewayAction["TYPING_START"] = "tavern_typing_start";
+    GatewayAction["TYPING_STOP"] = "tavern_typing_stop";
+    GatewayAction["MARK_READ"] = "tavern_mark_read";
+})(GatewayAction || (exports.GatewayAction = GatewayAction = {}));
+// ─── Friendly Event Name Map ────────────────────────────────
+// Maps gateway wire events to friendly SDK event names.
+exports.FRIENDLY_EVENT_MAP = {
+    [GatewayEvent.MESSAGE_CREATE]: 'messageCreate',
+    [GatewayEvent.MESSAGE_EDIT]: 'messageUpdate',
+    [GatewayEvent.MESSAGE_DELETE]: 'messageDelete',
+    [GatewayEvent.MESSAGES_BULK_DELETE]: 'messageDeleteBulk',
+    [GatewayEvent.MESSAGE_PINNED]: 'messagePinned',
+    [GatewayEvent.MESSAGE_UNPINNED]: 'messageUnpinned',
+    [GatewayEvent.MESSAGE_PUBLISHED]: 'messagePublished',
+    [GatewayEvent.MEMBER_JOINED]: 'memberJoin',
+    [GatewayEvent.MEMBER_LEFT]: 'memberLeave',
+    [GatewayEvent.MEMBER_MUTED]: 'memberMuted',
+    [GatewayEvent.MEMBER_UNMUTED]: 'memberUnmuted',
+    [GatewayEvent.CHANNEL_CREATED]: 'channelCreate',
+    [GatewayEvent.CHANNEL_UPDATED]: 'channelUpdate',
+    [GatewayEvent.CHANNEL_DELETED]: 'channelDelete',
+    [GatewayEvent.THREAD_CREATED]: 'threadCreate',
+    [GatewayEvent.THREAD_UPDATED]: 'threadUpdate',
+    [GatewayEvent.THREAD_DELETED]: 'threadDelete',
+    [GatewayEvent.THREAD_ARCHIVED]: 'threadArchived',
+    [GatewayEvent.ROLE_UPDATED]: 'roleUpdate',
+    [GatewayEvent.ROLE_DELETED]: 'roleDelete',
+    [GatewayEvent.TAVERN_UPDATED]: 'tavernUpdate',
+    [GatewayEvent.EVENT_CREATED]: 'eventCreate',
+    [GatewayEvent.EVENT_UPDATED]: 'eventUpdate',
+    [GatewayEvent.EVENT_DELETED]: 'eventDelete',
+    [GatewayEvent.EVENT_STARTING]: 'eventStarting',
+    [GatewayEvent.EVENT_ENDED]: 'eventEnded',
+    [GatewayEvent.VOICE_STATE_UPDATE]: 'voiceStateUpdate',
+    [GatewayEvent.TYPING_START]: 'typingStart',
+    [GatewayEvent.TYPING_STOP]: 'typingStop',
+    [GatewayEvent.BOT_INSTALLED]: 'botInstalled',
+    [GatewayEvent.BOT_REMOVED]: 'botRemoved',
+    [GatewayEvent.INTERACTION_CREATE]: 'interactionCreate',
+};

package/dist/embed.d.ts

@@ -0,0 +1,40 @@
+/**
+ * taverns.js - Embed Types & Builder
+ *
+ * Types and a fluent builder for creating rich embed content
+ * in messages and interaction replies.
+ */
+export interface EmbedImage {
+    url: string;
+    width?: number;
+    height?: number;
+}
+export interface EmbedFooter {
+    text: string;
+    iconUrl?: string;
+}
+export interface EmbedField {
+    name: string;
+    value: string;
+    inline?: boolean;
+}
+export interface Embed {
+    title?: string;
+    description?: string;
+    color?: string;
+    fields?: EmbedField[];
+    footer?: EmbedFooter;
+    thumbnail?: EmbedImage;
+    image?: EmbedImage;
+}
+export declare class EmbedBuilder {
+    private readonly data;
+    setTitle(title: string): this;
+    setDescription(description: string): this;
+    setColor(hex: string): this;
+    addField(name: string, value: string, inline?: boolean): this;
+    setFooter(text: string, iconUrl?: string): this;
+    setThumbnail(url: string): this;
+    setImage(url: string): this;
+    toJSON(): Embed;
+}

package/dist/embed.js

@@ -0,0 +1,30 @@
+"use strict";
+/**
+ * taverns.js - Embed Types & Builder
+ *
+ * Types and a fluent builder for creating rich embed content
+ * in messages and interaction replies.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmbedBuilder = void 0;
+class EmbedBuilder {
+    constructor() {
+        this.data = {};
+    }
+    setTitle(title) { this.data.title = title; return this; }
+    setDescription(description) { this.data.description = description; return this; }
+    setColor(hex) { this.data.color = hex; return this; }
+    addField(name, value, inline = false) {
+        var _a;
+        ((_a = this.data).fields ?? (_a.fields = [])).push({ name, value, inline });
+        return this;
+    }
+    setFooter(text, iconUrl) {
+        this.data.footer = { text, iconUrl };
+        return this;
+    }
+    setThumbnail(url) { this.data.thumbnail = { url }; return this; }
+    setImage(url) { this.data.image = { url }; return this; }
+    toJSON() { return { ...this.data }; }
+}
+exports.EmbedBuilder = EmbedBuilder;

package/dist/gateway.d.ts

@@ -0,0 +1,65 @@
+/**
+ * taverns.js - Gateway (WebSocket Client)
+ *
+ * Manages the WebSocket connection to the Tavern gateway.
+ * Handles authentication, heartbeats, auto-reconnection with exponential
+ * backoff, and event dispatching.
+ */
+import { EventEmitter } from 'events';
+export interface GatewayOptions {
+    /** Bot token (tavbot_...) */
+    token: string;
+    /** WebSocket URL (default: wss://ws.tav.gg) */
+    url?: string;
+    /** Heartbeat interval in milliseconds (default: 30000) */
+    heartbeatInterval?: number;
+    /** Whether to auto-reconnect on disconnect (default: true) */
+    autoReconnect?: boolean;
+    /** Maximum reconnect attempts before giving up (default: Infinity) */
+    maxReconnectAttempts?: number;
+    /** Gateway intents bitfield (session-level filtering, not persisted) */
+    intents?: bigint;
+}
+export declare class Gateway extends EventEmitter {
+    private ws;
+    private heartbeatTimer;
+    private reconnectTimer;
+    private state;
+    private reconnectAttempts;
+    private destroyed;
+    private token;
+    private readonly url;
+    private readonly heartbeatInterval;
+    private autoReconnect;
+    private readonly maxReconnectAttempts;
+    private readonly intents?;
+    constructor(options: GatewayOptions);
+    /** Whether the gateway is currently connected. */
+    get connected(): boolean;
+    /** Update the bot token (used when login() provides a new token). */
+    setToken(token: string): void;
+    /**
+     * Connect to the gateway.
+     * Resolves once the WebSocket connection is open.
+     */
+    connect(): Promise<void>;
+    /**
+     * Send a JSON message to the gateway.
+     */
+    send(action: string, data?: unknown): void;
+    /**
+     * Gracefully disconnect and clean up. The gateway cannot be reused after this.
+     */
+    destroy(): void;
+    /**
+     * Disconnect without destroying (allows reconnection).
+     */
+    disconnect(): void;
+    private onMessage;
+    private onClose;
+    private onError;
+    private startHeartbeat;
+    private stopHeartbeat;
+    private scheduleReconnect;
+    private cleanup;
+}