multichat-ts 0.0.94 → 0.0.96

package/dist/kick.d.ts

@@ -1,6 +1,6 @@
 import Pusher from 'pusher-js';
 import { type BadgeURLsByNameOrCount, type EmoteURLsByName, type Message } from './index.js';
-type ConnectionState = 'initialized' | 'connecting' | 'connected' | 'unavailable' | 'failed';
+type ConnectionState = 'initialized' | 'connecting' | 'connected' | 'unavailable' | 'failed' | 'disconnected';
 type ConnectionStateEvent = {
     previous: ConnectionState;
     current: ConnectionState;
@@ -18,15 +18,17 @@ export declare class KickPusher {
     channel_name?: string;
     private assets;
     private public_listeners;
-    socket?: Pusher;
+    socket?: Pusher | undefined;
     isConnected: boolean;
     setBadges(badges: BadgeURLsByNameOrCount): void;
     setExternalEmotes(external_emotes: EmoteURLsByName): void;
     getStoredBadges(): BadgeURLsByNameOrCount;
     getStoredExternalEmotes(): EmoteURLsByName;
+    private connectionVersion;
+    private closeSocket;
     connect(channel?: {
         channelName?: string;
-    }, get_channel?: (channelName: string) => Promise<GetChannelResponse | undefined>): Promise<void>;
+    }, getChannel?: (channelName: string) => Promise<GetChannelResponse | undefined>): Promise<void>;
     disconnect(): void;
     on<EventName extends EventNames>(event_name: EventName, callback_fn: EventCallbackFunctions[EventName]): void;
     private onSubscriptionSuccess;

package/dist/kick.js

@@ -1,4 +1,5 @@
 import Pusher from 'pusher-js';
+import { buildMessageBody, isFiniteNumber, isRecord, runSafely } from './safety.js';
 const DEFAULT_KICK_PUSHER_KEY = '32cbd69e4b950bf97679';
 export class KickPusher {
     kick_pusher_key = DEFAULT_KICK_PUSHER_KEY;
@@ -37,74 +38,104 @@ export class KickPusher {
     getStoredExternalEmotes() {
         return this.assets.external_emotes;
     }
-    async connect(channel, get_channel = async (channelName) => {
-        const res = await fetch(`https://kick.com/api/v2/channels/${channelName}`, {
-            headers: {
-                accept: 'aplication/json',
-                'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36',
-            },
-        });
-        const json = await res.json();
-        return json;
-    }) {
-        if (channel?.channelName)
+    connectionVersion = 0;
+    closeSocket() {
+        const socket = this.socket;
+        this.socket = undefined;
+        this.isConnected = false;
+        if (!socket)
+            return;
+        runSafely('kick.cleanup.connection', () => socket.connection.unbind_all());
+        runSafely('kick.cleanup.listeners', () => socket.unbind_all());
+        runSafely('kick.cleanup.disconnect', () => socket.disconnect());
+    }
+    async connect(channel, getChannel = defaultGetChannel) {
+        if (channel?.channelName) {
             this.channel_name = channel.channelName;
-        if (!this.channel_name)
-            return console.error('channel_name not specified');
-        console.log(`connecting to ${this.channel_name}...`);
-        const channel_response = await get_channel(this.channel_name);
-        if (!channel_response)
-            return console.error('Failed to connect to Kick.com chat');
-        channel_response.subscriber_badges.forEach((subscriber_badge) => {
-            this.assets.badges['subscriber'] = {
-                ...(this.assets.badges['subscriber'] ?? {}),
-                [subscriber_badge.months]: subscriber_badge.badge_image.src,
-            };
-        });
-        this.disconnect();
-        this.socket = new Pusher(this.kick_pusher_key, {
-            cluster: 'us2',
-        });
-        this.socket.subscribe(`chatroom_${channel_response.chatroom.id}`);
-        this.socket.subscribe(`chatrooms.${channel_response.chatroom.id}.v2`);
-        this.socket
-            .bind('pusher:subscription_succeeded', () => this.onSubscriptionSuccess('pusher:subscription_succeeded'))
-            .bind('App\\Events\\ChatMessageEvent', (data) => this.onChatMessage(data))
-            .bind('App\\Events\\SubscriptionEvent', (data) => this.onChatSubscription(data))
-            .bind('GiftedSubscriptionsEvent', (data) => this.onChatGifted(data));
-        this.socket.connection.bind('state_change', (state) => {
-            switch (state.current) {
-                case 'connected': {
-                    this.isConnected = true;
-                    console.log(`Connected to Kick Pusher (${this.channel_name})!`);
-                    break;
-                }
-                case 'connecting': {
-                    this.isConnected = false;
-                    console.log(`Connecting to Kick Pusher (${this.channel_name})...`);
-                    break;
-                }
-                case 'failed': {
-                    this.isConnected = false;
-                    console.log(`Failed to connect to Kick Pusher (${this.channel_name})`);
-                    break;
-                }
-                case 'unavailable': {
-                    this.isConnected = false;
-                    console.log(`Disconnected from Kick Pusher (${this.channel_name})`);
-                    break;
-                }
-                default: {
-                    this.isConnected = false;
-                    break;
+        }
+        const channelName = this.channel_name;
+        if (!channelName) {
+            throw new Error('Kick channel_name not specified');
+        }
+        const version = ++this.connectionVersion;
+        this.closeSocket();
+        const response = await getChannel(channelName);
+        if (version !== this.connectionVersion)
+            return;
+        if (!response || !isFiniteNumber(response.chatroom?.id) || response.chatroom.id <= 0) {
+            throw new Error(`Invalid Kick channel response: ${channelName}`);
+        }
+        const subscriberBadges = {};
+        if (Array.isArray(response.subscriber_badges)) {
+            for (const badge of response.subscriber_badges) {
+                if (badge && isFiniteNumber(badge.months) && typeof badge.badge_image?.src === 'string') {
+                    subscriberBadges[badge.months] = badge.badge_image.src;
                 }
             }
-            this.public_listeners.connection_state_changed?.(state);
-        });
+        }
+        this.assets.badges['subscriber'] = subscriberBadges;
+        try {
+            const socket = new Pusher(this.kick_pusher_key, {
+                cluster: 'us2',
+            });
+            this.socket = socket;
+            const bind = (event, handler) => {
+                socket.bind(event, (data) => {
+                    if (this.socket !== socket)
+                        return;
+                    runSafely(`kick.${event}`, () => handler(data));
+                });
+            };
+            bind('App\\Events\\ChatMessageEvent', (data) => this.onChatMessage(data));
+            bind('App\\Events\\SubscriptionEvent', (data) => this.onChatSubscription(data));
+            bind('GiftedSubscriptionsEvent', (data) => this.onChatGifted(data));
+            socket.connection.bind('state_change', (state) => {
+                if (this.socket !== socket)
+                    return;
+                runSafely('kick.state_change', () => {
+                    if (!state || typeof state.current !== 'string') {
+                        throw new Error('Invalid Pusher state-change payload');
+                    }
+                    this.isConnected = state.current === 'connected';
+                    runSafely('kick.connection_state_changed', () => this.public_listeners.connection_state_changed?.(state));
+                });
+            });
+            socket.connection.bind('error', (error) => {
+                if (this.socket !== socket)
+                    return;
+                console.error('Kick Pusher connection error', {
+                    channelName,
+                    error,
+                });
+            });
+            const names = [`chatroom_${response.chatroom.id}`, `chatrooms.${response.chatroom.id}.v2`];
+            for (const name of names) {
+                const subscription = socket.subscribe(name);
+                subscription.bind('pusher:subscription_succeeded', () => {
+                    if (this.socket !== socket)
+                        return;
+                    runSafely('kick.subscription_succeeded', () => this.onSubscriptionSuccess(name));
+                });
+                subscription.bind('pusher:subscription_error', (error) => {
+                    if (this.socket !== socket)
+                        return;
+                    console.error('Kick Pusher subscription error', {
+                        channelName,
+                        subscription: name,
+                        error,
+                    });
+                });
+            }
+            this.isConnected = socket.connection.state === 'connected';
+        }
+        catch (error) {
+            this.closeSocket();
+            throw error;
+        }
     }
     disconnect() {
-        this.socket?.disconnect();
-        this.socket?.unbind_all();
+        ++this.connectionVersion;
+        this.closeSocket();
     }
     on(event_name, callback_fn) {
         this.public_listeners[event_name] = callback_fn;
@@ -113,63 +144,46 @@ export class KickPusher {
         console.log(`Subscribed to Channel on Kick Pusher (${channel})`);
     }
     onChatSubscription(data) {
-        this.public_listeners.subscription?.(data);
+        if (!isSubscription(data)) {
+            console.warn('Ignoring invalid Kick subscription payload', JSON.stringify(data));
+            return;
+        }
+        runSafely('kick.subscription', () => {
+            this.public_listeners.subscription?.(data);
+        });
     }
     onChatGifted(data) {
-        this.public_listeners.gifted?.(data);
+        if (!isGifted(data)) {
+            console.warn('Ignoring invalid Kick gifted payload', JSON.stringify(data));
+            return;
+        }
+        runSafely('kick.gifted', () => {
+            this.public_listeners.gifted?.(data);
+        });
     }
     onChatMessage(data) {
-        this.public_listeners.raw_message?.(data);
+        if (!isChatMessage(data)) {
+            console.warn('Ignoring invalid Kick chat payload: ', JSON.stringify(data));
+            return;
+        }
+        runSafely('kick.raw_message', () => {
+            this.public_listeners.raw_message?.(data);
+        });
         const text = data.content;
-        const emote_matches = [...data.content.matchAll(/\[emote:\d+:.+\]/g)];
-        const body = [];
-        emote_matches.forEach((match) => {
-            const emote_string = match[0];
-            const emote_parts = emote_string.slice(1, emote_string.length - 1).split(':');
-            const emote_id = emote_parts[1];
-            if (!emote_id)
-                return;
-            body.push({
+        const emotes = [];
+        for (const match of text.matchAll(/\[emote:(\d+):[^\]]+\]/g)) {
+            const id = match[1];
+            const start = match.index;
+            if (!id || start === undefined)
+                continue;
+            emotes.push({
                 type: 'emote',
-                start_inclusive: match.index,
-                end_exclusive: match.index + emote_string.length,
-                url: `https://files.kick.com/emotes/${emote_id}/fullsize`,
-            });
-        });
-        body.sort((a, b) => a.start_inclusive - b.start_inclusive);
-        const old_body_length = body.length;
-        if (old_body_length > 0) {
-            body.forEach((segment, index) => {
-                const previous_segment = body[index - 1];
-                const text_start_inclusive = previous_segment?.end_exclusive !== undefined ? previous_segment.end_exclusive + 1 : 0;
-                const text_end_exclusive = Math.max(0, segment.start_inclusive);
-                if (text_end_exclusive - text_start_inclusive > 0) {
-                    body.push({
-                        type: 'text',
-                        text: text.slice(text_start_inclusive, text_end_exclusive),
-                        start_inclusive: text_start_inclusive,
-                        end_exclusive: text_end_exclusive,
-                    });
-                }
-                if (index === old_body_length - 1 && segment.end_exclusive < text.length - 1) {
-                    body.push({
-                        type: 'text',
-                        text: text.slice(segment.end_exclusive),
-                        start_inclusive: segment.end_exclusive,
-                        end_exclusive: text.length,
-                    });
-                }
-            });
-        }
-        else {
-            body.push({
-                type: 'text',
-                text,
-                start_inclusive: 0,
-                end_exclusive: text.length,
+                start_inclusive: start,
+                end_exclusive: start + match[0].length,
+                url: `https://files.kick.com/emotes/${id}/fullsize`,
             });
         }
-        body.sort((a, b) => a.start_inclusive - b.start_inclusive);
+        const body = buildMessageBody(text, emotes);
         const message = {
             id: data.id,
             user: {
@@ -184,12 +198,14 @@ export class KickPusher {
                     const badge_count = badge.count;
                     if (typeof badge_url_or_counts === 'string')
                         badge_url = badge_url_or_counts;
-                    else if (typeof badge_url_or_counts === 'object' && badge_count !== undefined) {
-                        const badge_entry_by_count = Object.entries(badge_url_or_counts)
-                            .sort(([a_min_count], [b_min_count]) => Number(a_min_count) - Number(b_min_count))
-                            .find(([min_count]) => badge_count >= Number(min_count));
-                        if (badge_entry_by_count)
-                            badge_url = badge_entry_by_count[1];
+                    else if (badge_url_or_counts !== null &&
+                        typeof badge_url_or_counts === 'object' &&
+                        isFiniteNumber(badge_count)) {
+                        const entry = Object.entries(badge_url_or_counts)
+                            .filter(([minimum, url]) => Number.isFinite(Number(minimum)) && typeof url === 'string')
+                            .sort(([a], [b]) => Number(b) - Number(a))
+                            .find(([minimum]) => badge_count >= Number(minimum));
+                        badge_url = entry?.[1];
                     }
                     if (!badge_url)
                         return [];
@@ -208,13 +224,76 @@ export class KickPusher {
             raw_text: data.content,
             timestamp_sent: Date.parse(data.created_at),
         };
-        if (data.type === 'celebration' && data.metadata?.celebration) {
+        const metadata = data.metadata;
+        const celebration = isRecord(metadata) ? metadata['celebration'] : undefined;
+        if (data.type === 'celebration' &&
+            isRecord(celebration) &&
+            typeof celebration['id'] === 'string' &&
+            isFiniteNumber(celebration['total_months']) &&
+            celebration['total_months'] > 0 &&
+            typeof celebration['created_at'] === 'string' &&
+            Number.isFinite(Date.parse(celebration['created_at']))) {
             message.resubscription = {
-                id: data.metadata.celebration.id,
-                months: data.metadata.celebration.total_months,
-                subscribed_since_timestamp: data.metadata.celebration.created_at,
+                id: celebration['id'],
+                months: celebration['total_months'],
+                subscribed_since_timestamp: celebration['created_at'],
             };
         }
-        this.public_listeners.message?.(message);
+        runSafely('kick.message', () => {
+            this.public_listeners.message?.(message);
+        });
     }
 }
+async function defaultGetChannel(channelName) {
+    const url = 'https://kick.com/api/v2/channels/' + encodeURIComponent(channelName);
+    const response = await fetch(url, {
+        headers: {
+            accept: 'application/json',
+        },
+        signal: AbortSignal.timeout(15_000),
+    });
+    if (!response.ok) {
+        throw new Error(`Kick channel lookup HTTP ${response.status}`);
+    }
+    return (await response.json());
+}
+function isChatMessage(value) {
+    if (!isRecord(value))
+        return false;
+    const sender = value['sender'];
+    if (typeof value['id'] !== 'string' ||
+        !isFiniteNumber(value['chatroom_id']) ||
+        typeof value['content'] !== 'string' ||
+        typeof value['created_at'] !== 'string' ||
+        !Number.isFinite(Date.parse(value['created_at'])) ||
+        !['message', 'celebration', 'reply'].includes(String(value['type'])) ||
+        !isRecord(sender) ||
+        !isFiniteNumber(sender['id']) ||
+        typeof sender['username'] !== 'string' ||
+        (sender['slug'] !== undefined && typeof sender['slug'] !== 'string')) {
+        return false;
+    }
+    const identity = sender['identity'];
+    return (isRecord(identity) &&
+        typeof identity['color'] === 'string' &&
+        Array.isArray(identity['badges']) &&
+        identity['badges'].every((badge) => isRecord(badge) &&
+            typeof badge['type'] === 'string' &&
+            typeof badge['text'] === 'string' &&
+            (badge['count'] === undefined || isFiniteNumber(badge['count']))));
+}
+function isSubscription(value) {
+    return (isRecord(value) &&
+        isFiniteNumber(value['chatroom_id']) &&
+        typeof value['username'] === 'string' &&
+        isFiniteNumber(value['months']) &&
+        value['months'] > 0);
+}
+function isGifted(value) {
+    return (isRecord(value) &&
+        isFiniteNumber(value['chatroom_id']) &&
+        typeof value['gifter_username'] === 'string' &&
+        isFiniteNumber(value['gifter_total']) &&
+        Array.isArray(value['gifted_usernames']) &&
+        value['gifted_usernames'].every((name) => typeof name === 'string'));
+}

package/dist/safety.d.ts

@@ -0,0 +1,5 @@
+import { BodyComponent } from '.';
+export declare function runSafely(context: string, callback: () => unknown): void;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function isFiniteNumber(value: unknown): value is number;
+export declare function buildMessageBody(text: string, emotes: BodyComponent[]): BodyComponent[];

package/dist/safety.js

@@ -0,0 +1,56 @@
+export function runSafely(context, callback) {
+    try {
+        const result = callback();
+        if (result !== null &&
+            result !== undefined &&
+            typeof result.then === 'function') {
+            void Promise.resolve(result).catch((error) => {
+                console.error(`[${context}] Async failure`, error);
+            });
+        }
+    }
+    catch (error) {
+        console.error(`[${context}] Failure`, error);
+    }
+}
+export function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+export function isFiniteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value);
+}
+export function buildMessageBody(text, emotes) {
+    const sorted = [...emotes].sort((a, b) => a.start_inclusive - b.start_inclusive);
+    const body = [];
+    let cursor = 0;
+    for (const emote of sorted) {
+        const start = emote.start_inclusive;
+        const end = emote.end_exclusive;
+        if (!Number.isInteger(start) ||
+            !Number.isInteger(end) ||
+            start < cursor ||
+            end <= start ||
+            end > text.length) {
+            continue;
+        }
+        if (start > cursor) {
+            body.push({
+                type: 'text',
+                text: text.slice(cursor, start),
+                start_inclusive: cursor,
+                end_exclusive: start,
+            });
+        }
+        body.push(emote);
+        cursor = end;
+    }
+    if (cursor < text.length || body.length === 0) {
+        body.push({
+            type: 'text',
+            text: text.slice(cursor),
+            start_inclusive: cursor,
+            end_exclusive: text.length,
+        });
+    }
+    return body;
+}

package/dist/test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test.js

@@ -0,0 +1,24 @@
+import { format } from 'util';
+import { KickPusher } from './kick.js';
+const originalError = console.error.bind(console);
+const originalWarn = console.warn.bind(console);
+console.warn = (...args) => {
+    originalWarn(`\x1b[33m${format(...args)}\x1b[0m`);
+};
+console.error = (...args) => {
+    originalError(`\x1b[31m${format(...args)}\x1b[0m`);
+};
+const client = new KickPusher();
+client.on('subscription', (data) => {
+    console.log(JSON.stringify(data));
+});
+client.on('connection_state_changed', (data) => {
+    console.log(JSON.stringify(data));
+});
+client.on('gifted', (data) => {
+    console.log(JSON.stringify(data));
+});
+client.on('message', (data) => {
+    console.log(JSON.stringify(data));
+});
+client.connect({ channelName: 'drb7h' });

package/dist/twitch.d.ts

@@ -6,25 +6,44 @@ type EventCallbackFunctions = {
     delete_message: (data: DeleteMessage) => unknown;
     event: (event: Event) => unknown;
     raw_message: (message: IRC_Message) => unknown;
+    connected: () => unknown;
+    auth_error: () => unknown;
 };
 type EventNames = keyof EventCallbackFunctions;
+type SocketOptions = NonNullable<ConstructorParameters<typeof WebSocket>[2]>;
 export declare class TwitchIRC {
     channel_name?: string;
+    auth?: {
+        username: string;
+        token: string;
+    } | undefined;
+    bot_name?: string;
+    bot_token?: string;
     private assets;
     latency: number;
     private ping;
     private public_listeners;
-    socket?: WebSocket;
-    ws?: WebSocket | undefined;
-    constructor(ws?: WebSocket);
+    socket?: WebSocket | undefined;
+    wsCustom?: SocketOptions['WebSocket'];
+    constructor(options?: {
+        ws?: SocketOptions['WebSocket'];
+        auth?: {
+            username: string;
+            token: string;
+        };
+    });
     setBadges(badges: BadgeURLsBySetIDOrSetIDAndVersion): void;
-    setExternalEmotes(external_emotes: EmoteURLsByName): void;
+    setExternalEmotes(externalEmotes: EmoteURLsByName): void;
     getStoredBadges(): BadgeURLsBySetIDOrSetIDAndVersion;
     getStoredExternalEmotes(): EmoteURLsByName;
+    authenticate(username: string, token: string): void;
+    private clearPing;
     connect(channel?: {
         channelName?: string;
     }): void;
+    send(message: string, replyParentMessageId?: string): void;
     disconnect(): void;
+    private restartConnection;
     on<EventName extends EventNames>(event_name: EventName, callback_fn: EventCallbackFunctions[EventName]): void;
     isConnected(): this is {
         socket: {
@@ -32,42 +51,22 @@ export declare class TwitchIRC {
         } & WebSocket;
     };
     private onOpen;
-    private onClose;
     private sendPing;
-    private send;
+    private sendIRC;
     private onMessage;
+    private handleIRCMessage;
 }
-type IRC_Message = {
-    [C in CommandType]: {
-        channel: string;
-        command: C;
-        params: string[];
-        source: RawSource | undefined;
-        tags: SpecificRawTags<C> | undefined;
-    };
-}[CommandType];
-type RAW_TAGS = typeof RAW_TAGS;
-type CommandType = keyof RAW_TAGS;
-type SpecificRawTags<Command extends CommandType> = Record<RAW_TAGS[Command][number], string | undefined>;
+export declare function parseIRCLine(line: string): IRC_Message | undefined;
+export type IRC_Message = {
+    channel: string;
+    command: string;
+    params: string[];
+    source: RawSource | undefined;
+    tags: Record<string, string | undefined> | undefined;
+};
 type RawSource = {
     host: string;
     nick?: string | undefined;
     user?: string | undefined;
 };
-declare const RAW_TAGS: {
-    readonly CLEARCHAT: readonly ["ban-duration", "room-id", "target-user-id", "tmi-sent-ts"];
-    readonly CLEARMSG: readonly ["login", "room-id", "target-msg-id", "tmi-sent-ts"];
-    readonly GLOBALUSERSTATE: readonly ["badge-info", "badges", "color", "display-name", "emote-sets", "turbo", "user-id", "user-type"];
-    readonly HOSTTARGET: readonly [];
-    readonly NOTICE: readonly ["msg-id", "target-user-id"];
-    readonly PART: readonly [];
-    readonly PING: readonly [];
-    readonly PONG: readonly [];
-    readonly PRIVMSG: readonly ["badge-info", "badges", "bits", "color", "display-name", "emotes", "emote-only", "id", "mod", "custom-reward-id", "reply-thread-parent-display-name", "reply-thread-parent-user-id", "pinned-chat-paid-amount", "pinned-chat-paid-currency", "pinned-chat-paid-exponent", "pinned-chat-paid-level", "pinned-chat-paid-is-system-message", "reply-parent-msg-id", "reply-parent-user-id", "reply-parent-user-login", "reply-parent-display-name", "reply-parent-msg-body", "reply-thread-parent-msg-id", "reply-thread-parent-user-login", "room-id", "subscriber", "tmi-sent-ts", "turbo", "user-id", "user-type", "vip", "client-nonce", "first-msg", "flags", "returning-chatter"];
-    readonly RECONNECT: readonly [];
-    readonly ROOMSTATE: readonly ["emote-only", "followers-only", "r9k", "room-id", "slow", "subs-only"];
-    readonly USERNOTICE: readonly ["badge-info", "badges", "color", "display-name", "emotes", "id", "login", "mod", "msg-id", "room-id", "subscriber", "system-msg", "tmi-sent-ts", "turbo", "user-id", "user-type", "vip", "flags", "msg-param-cumulative-months", "msg-param-displayName", "msg-param-login", "msg-param-multimonth-duration", "msg-param-multimonth-tenure", "msg-param-was-gifted=false", "msg-param-months", "msg-param-promo-gift-total", "msg-param-promo-name", "msg-param-recipient-display-name", "msg-param-recipient-id", "msg-param-recipient-user-name", "msg-param-sender-login", "msg-param-sender-name", "msg-param-should-share-streak", "msg-param-streak-months", "msg-param-sub-plan", "msg-param-sub-plan-name", "msg-param-viewerCount", "msg-param-ritual-name", "msg-param-threshold", "msg-param-gift-months", "msg-param-was-gifted", "msg-param-community-gift-id", "msg-param-mass-gift-count", "msg-param-origin-id"];
-    readonly USERSTATE: readonly ["badge-info", "badges", "color", "display-name", "emote-sets", "id", "mod", "subscriber", "turbo", "user-type"];
-    readonly WHISPER: readonly ["badges", "color", "display-name", "emotes", "message-id", "thread-id", "turbo", "user-id", "user-type"];
-};
 export {};