@m7mdxzx1/discord-video-strem 0.0.1

package/dist/media/newApi.js

@@ -0,0 +1,387 @@
+import ffmpeg from 'fluent-ffmpeg';
+import pDebounce from 'p-debounce';
+import sharp from 'sharp';
+import Log from 'debug-level';
+import { PassThrough } from "node:stream";
+import { demux } from './LibavDemuxer.js';
+import { setTimeout as delay } from 'node:timers/promises';
+import { VideoStream } from './VideoStream.js';
+import { AudioStream } from './AudioStream.js';
+import { isFiniteNonZero } from '../utils.js';
+import { AVCodecID } from './LibavCodecId.js';
+import { createDecoder } from './LibavDecoder.js';
+import LibAV from '@lng2004/libav.js-variant-webcodecs-avf-with-decoders';
+export function prepareStream(input, options = {}, cancelSignal) {
+    cancelSignal?.throwIfAborted();
+    const defaultOptions = {
+        noTranscoding: false,
+        // negative values = resize by aspect ratio, see https://trac.ffmpeg.org/wiki/Scaling
+        width: -2,
+        height: -2,
+        frameRate: undefined,
+        videoCodec: "H264",
+        bitrateVideo: 5000,
+        bitrateVideoMax: 7000,
+        bitrateAudio: 128,
+        includeAudio: true,
+        hardwareAcceleratedDecoding: false,
+        minimizeLatency: false,
+        h26xPreset: "ultrafast",
+        customHeaders: {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.3",
+            "Connection": "keep-alive",
+        },
+        seekTime: 0,
+        customFfmpegFlags: []
+    };
+    function mergeOptions(opts) {
+        return {
+            noTranscoding: opts.noTranscoding ?? defaultOptions.noTranscoding,
+            width: isFiniteNonZero(opts.width) ? Math.round(opts.width) : defaultOptions.width,
+            height: isFiniteNonZero(opts.height) ? Math.round(opts.height) : defaultOptions.height,
+            frameRate: isFiniteNonZero(opts.frameRate) && opts.frameRate > 0
+                ? opts.frameRate
+                : defaultOptions.frameRate,
+            videoCodec: opts.videoCodec ?? defaultOptions.videoCodec,
+            bitrateVideo: isFiniteNonZero(opts.bitrateVideo) && opts.bitrateVideo > 0
+                ? Math.round(opts.bitrateVideo)
+                : defaultOptions.bitrateVideo,
+            bitrateVideoMax: isFiniteNonZero(opts.bitrateVideoMax) && opts.bitrateVideoMax > 0
+                ? Math.round(opts.bitrateVideoMax)
+                : defaultOptions.bitrateVideoMax,
+            bitrateAudio: isFiniteNonZero(opts.bitrateAudio) && opts.bitrateAudio > 0
+                ? Math.round(opts.bitrateAudio)
+                : defaultOptions.bitrateAudio,
+            includeAudio: opts.includeAudio ?? defaultOptions.includeAudio,
+            hardwareAcceleratedDecoding: opts.hardwareAcceleratedDecoding ?? defaultOptions.hardwareAcceleratedDecoding,
+            minimizeLatency: opts.minimizeLatency ?? defaultOptions.minimizeLatency,
+            h26xPreset: opts.h26xPreset ?? defaultOptions.h26xPreset,
+            customHeaders: {
+                ...defaultOptions.customHeaders, ...opts.customHeaders
+            },
+            seekTime: opts.seekTime ?? defaultOptions.seekTime,
+            customFfmpegFlags: opts.customFfmpegFlags ?? defaultOptions.customFfmpegFlags
+        };
+    }
+    const mergedOptions = mergeOptions(options);
+    let isHttpUrl = false;
+    let isHls = false;
+    if (typeof input === "string") {
+        isHttpUrl = input.startsWith('http') || input.startsWith('https');
+        isHls = input.includes('m3u');
+    }
+    const output = new PassThrough();
+    // command creation
+    const command = ffmpeg();
+    // Seeking if applicable (Must be applied before input for fast seek)
+    if (mergedOptions.seekTime && mergedOptions.seekTime > 0) {
+        command.inputOption('-ss', String(mergedOptions.seekTime));
+    }
+    command.input(input)
+        .addOption('-loglevel', 'info');
+    // input options
+    const { hardwareAcceleratedDecoding, minimizeLatency, customHeaders } = mergedOptions;
+    if (hardwareAcceleratedDecoding)
+        command.inputOption('-hwaccel', 'auto');
+    if (minimizeLatency) {
+        command.addOptions([
+            '-fflags nobuffer',
+            '-analyzeduration 0'
+        ]);
+    }
+    if (isHttpUrl) {
+        command.inputOption('-headers', Object.entries(customHeaders).map(([k, v]) => `${k}: ${v}`).join("\\r\\n") // Corrected escape sequence
+        );
+        if (!isHls) {
+            command.inputOptions([
+                '-reconnect 1',
+                '-reconnect_at_eof 1',
+                '-reconnect_streamed 1',
+                '-reconnect_delay_max 4294'
+            ]);
+        }
+    }
+    // general output options
+    command
+        .output(output)
+        .outputFormat("matroska");
+    // video setup
+    const { noTranscoding, width, height, frameRate, bitrateVideo, bitrateVideoMax, videoCodec, h26xPreset } = mergedOptions;
+    command.addOutputOption("-map 0:v");
+    if (noTranscoding) {
+        command.videoCodec("copy");
+    }
+    else {
+        command.videoFilter(`scale=${width}:${height}`);
+        if (frameRate)
+            command.fpsOutput(frameRate);
+        command.addOutputOption([
+            "-b:v", `${bitrateVideo}k`,
+            "-maxrate:v", `${bitrateVideoMax}k`,
+            "-bf", "0",
+            "-pix_fmt", "yuv420p",
+            "-force_key_frames", "expr:gte(t,n_forced*1)"
+        ]);
+        switch (videoCodec) {
+            case 'AV1':
+                command
+                    .videoCodec("libsvtav1");
+                break;
+            case 'VP8':
+                command
+                    .videoCodec("libvpx")
+                    .outputOption('-deadline', 'realtime');
+                break;
+            case 'VP9':
+                command
+                    .videoCodec("libvpx-vp9")
+                    .outputOption('-deadline', 'realtime');
+                break;
+            case 'H264':
+                command
+                    .videoCodec("libx264")
+                    .outputOptions([
+                    '-tune zerolatency',
+                    `-preset ${h26xPreset}`,
+                    '-profile:v baseline',
+                ]);
+                break;
+            case 'H265':
+                command
+                    .videoCodec("libx265")
+                    .outputOptions([
+                    '-tune zerolatency',
+                    `-preset ${h26xPreset}`,
+                    '-profile:v main',
+                ]);
+                break;
+        }
+    }
+    // audio setup
+    const { includeAudio, bitrateAudio } = mergedOptions;
+    if (includeAudio)
+        command
+            .addOutputOption("-map 0:a?")
+            .audioChannels(2)
+            /*
+             * I don't have much surround sound material to test this with,
+             * if you do and you have better settings for this, feel free to
+             * contribute!
+             */
+            .addOutputOption("-lfe_mix_level 1")
+            .audioFrequency(48000)
+            .audioCodec("libopus")
+            .audioBitrate(`${bitrateAudio}k`)
+            .audioFilters("volume@internal_lib=1.0");
+    // Add custom ffmpeg flags
+    if (mergedOptions.customFfmpegFlags && mergedOptions.customFfmpegFlags.length > 0) {
+        command.addOptions(mergedOptions.customFfmpegFlags);
+    }
+    // exit handling
+    const promise = new Promise((resolve, reject) => {
+        command.on("error", (err) => {
+            if (cancelSignal?.aborted)
+                /**
+                 * fluent-ffmpeg might throw an error when SIGTERM is sent to
+                 * the process, so we check if the abort signal is triggered
+                 * and throw that instead
+                 */
+                reject(cancelSignal.reason);
+            else
+                reject(err);
+        });
+        command.on("end", () => resolve());
+    });
+    promise.catch(() => { });
+    cancelSignal?.addEventListener("abort", () => command.kill("SIGTERM"), { once: true });
+    command.run();
+    return { command, output, promise };
+}
+export async function playStream(input, streamer, options = {}, cancelSignal, existingUdp = null) {
+    const logger = new Log("playStream");
+    cancelSignal?.throwIfAborted();
+    if (!streamer.voiceConnection)
+        throw new Error("Bot is not connected to a voice channel");
+    logger.debug("Initializing demuxer");
+    const { video, audio } = await demux(input);
+    cancelSignal?.throwIfAborted();
+    if (!video)
+        throw new Error("No video stream in media");
+    const cleanupFuncs = [];
+    const videoCodecMap = {
+        [AVCodecID.AV_CODEC_ID_H264]: "H264",
+        [AVCodecID.AV_CODEC_ID_H265]: "H265",
+        [AVCodecID.AV_CODEC_ID_VP8]: "VP8",
+        [AVCodecID.AV_CODEC_ID_VP9]: "VP9",
+        [AVCodecID.AV_CODEC_ID_AV1]: "AV1"
+    };
+    const defaultOptions = {
+        type: "go-live",
+        width: video.width,
+        height: video.height,
+        frameRate: video.framerate_num / video.framerate_den,
+        readrateInitialBurst: undefined,
+        streamPreview: false,
+        seekTime: 0,
+        customHeaders: {},
+        initialMuted: false,
+    };
+    function mergeOptions(opts) {
+        return {
+            type: opts.type ?? defaultOptions.type,
+            width: isFiniteNonZero(opts.width) && opts.width > 0
+                ? Math.round(opts.width)
+                : defaultOptions.width,
+            height: isFiniteNonZero(opts.height) && opts.height > 0
+                ? Math.round(opts.height)
+                : defaultOptions.height,
+            frameRate: Math.round(isFiniteNonZero(opts.frameRate) && opts.frameRate > 0
+                ? Math.round(opts.frameRate)
+                : defaultOptions.frameRate),
+            readrateInitialBurst: isFiniteNonZero(opts.readrateInitialBurst) && opts.readrateInitialBurst > 0
+                ? opts.readrateInitialBurst
+                : defaultOptions.readrateInitialBurst,
+            streamPreview: opts.streamPreview ?? defaultOptions.streamPreview,
+            seekTime: opts.seekTime ?? defaultOptions.seekTime,
+            customHeaders: {
+                ...defaultOptions.customHeaders, ...opts.customHeaders
+            },
+            initialMuted: opts.initialMuted ?? defaultOptions.initialMuted,
+        };
+    }
+    const mergedOptions = mergeOptions(options);
+    logger.debug({ options: mergedOptions }, "Merged options");
+    let udp;
+    let stopStream;
+    if (!existingUdp) {
+        udp = await streamer.createStream();
+    }
+    else {
+        udp = existingUdp;
+        udp.mediaConnection.setSpeaking(false);
+        udp.mediaConnection.setVideoAttributes(false);
+        await delay(250);
+    }
+    // stopStream = () => streamer.stopStream();
+    stopStream = () => console.log("Aborted");
+    udp.setPacketizer(videoCodecMap[video.codec]);
+    udp.mediaConnection.setSpeaking(true);
+    udp.mediaConnection.setVideoAttributes(true, {
+        width: mergedOptions.width,
+        height: mergedOptions.height,
+        fps: mergedOptions.frameRate
+    });
+    const vStream = new VideoStream(udp);
+    video.stream.pipe(vStream);
+    let audioStreamInstance;
+    if (audio) {
+        audioStreamInstance = new AudioStream(udp, false, mergedOptions.initialMuted);
+        audio.stream.pipe(audioStreamInstance);
+        vStream.syncStream = audioStreamInstance;
+        audioStreamInstance.syncStream = vStream;
+        const burstTime = mergedOptions.readrateInitialBurst;
+        if (typeof burstTime === "number") {
+            vStream.sync = false;
+            vStream.noSleep = audioStreamInstance.noSleep = true;
+            const stopBurst = (pts) => {
+                if (pts < burstTime * 1000)
+                    return;
+                vStream.sync = true;
+                if (audioStreamInstance) {
+                    vStream.noSleep = audioStreamInstance.noSleep = false;
+                }
+                vStream.off("pts", stopBurst);
+            };
+            vStream.on("pts", stopBurst);
+        }
+    }
+    if (mergedOptions.streamPreview && mergedOptions.type === "go-live") {
+        (async () => {
+            const logger = new Log("playStream:preview");
+            logger.debug("Initializing decoder for stream preview");
+            const decoder = await createDecoder(video.codec, video.codecpar);
+            if (!decoder) {
+                logger.warn("Failed to initialize decoder. Stream preview will be disabled");
+                return;
+            }
+            cleanupFuncs.push(() => {
+                logger.debug("Freeing decoder");
+                decoder.free();
+            });
+            const updatePreview = pDebounce.promise(async (packet) => {
+                if (!(packet.flags !== undefined && packet.flags & LibAV.AV_PKT_FLAG_KEY))
+                    return;
+                const decodeStart = performance.now();
+                const [frame] = await decoder.decode([packet]).catch(() => []);
+                if (!frame)
+                    return;
+                const decodeEnd = performance.now();
+                logger.debug(`Decoding a frame took ${decodeEnd - decodeStart}ms`);
+                return sharp(frame.data, {
+                    raw: {
+                        width: frame.width ?? 0,
+                        height: frame.height ?? 0,
+                        channels: 4
+                    }
+                })
+                    .resize(1024, 576, { fit: "inside" })
+                    .jpeg()
+                    .toBuffer()
+                    .then(image => streamer.setStreamPreview(image))
+                    .catch(() => { });
+            });
+            video.stream.on("data", updatePreview);
+            cleanupFuncs.push(() => video.stream.off("data", updatePreview));
+        })();
+    }
+    const streamPromise = new Promise((resolve, reject) => {
+        cleanupFuncs.push(() => {
+            stopStream();
+            udp.mediaConnection.setSpeaking(false);
+            udp.mediaConnection.setVideoAttributes(false);
+        });
+        let cleanedUp = false;
+        const cleanup = () => {
+            if (cleanedUp)
+                return;
+            cleanedUp = true;
+            for (const f of cleanupFuncs)
+                f();
+        };
+        cancelSignal?.addEventListener("abort", () => {
+            cleanup();
+            reject(cancelSignal.reason);
+        }, { once: true });
+        vStream.once("finish", () => {
+            if (cancelSignal?.aborted)
+                return;
+            cleanup();
+            resolve();
+        });
+        vStream.once("error", (err) => {
+            if (cancelSignal?.aborted)
+                return;
+            cleanup();
+            reject(err);
+        });
+        if (audio) {
+            audio.stream.once("error", (err) => {
+                if (cancelSignal?.aborted)
+                    return;
+                cleanup();
+                reject(err);
+            });
+        }
+    }).catch((err) => {
+        if (!cancelSignal?.aborted) {
+            logger.error("Error during playStream:", err);
+        }
+        if (err !== cancelSignal?.reason) {
+            throw err;
+        }
+    });
+    return {
+        audioController: audioStreamInstance,
+        done: streamPromise,
+    };
+}

package/dist/media/utils.d.ts

@@ -0,0 +1 @@
+export declare function combineLoHi(hi: number, lo: number): number;

package/dist/media/utils.js

@@ -0,0 +1,4 @@
+import LibAV from "@lng2004/libav.js-variant-webcodecs-avf-with-decoders";
+export function combineLoHi(hi, lo) {
+    return LibAV.i64tof64(lo, hi);
+}

package/dist/utils.d.ts

@@ -0,0 +1,28 @@
+import type { AnyChannel, DMChannel, GroupDMChannel, VoiceBasedChannel } from "discord.js-selfbot-v13";
+export declare function normalizeVideoCodec(codec: string): "H264" | "H265" | "VP8" | "VP9" | "AV1";
+export declare const STREAMS_SIMULCAST: {
+    type: string;
+    rid: string;
+    quality: number;
+}[];
+export declare enum SupportedEncryptionModes {
+    AES256 = "aead_aes256_gcm_rtpsize",
+    XCHACHA20 = "aead_xchacha20_poly1305_rtpsize"
+}
+export type SupportedVideoCodec = "H264" | "H265" | "VP8" | "VP9" | "AV1";
+export declare const extensions: {
+    id: number;
+    len: number;
+    val: number;
+}[];
+export declare const max_int16bit: number;
+export declare const max_int32bit: number;
+export declare function isFiniteNonZero(n: number | undefined): n is number;
+export declare function parseStreamKey(streamKey: string): {
+    type: "guild" | "call";
+    channelId: string;
+    guildId: string | null;
+    userId: string;
+};
+export declare function generateStreamKey(type: "guild" | "call", guildId: string | null, channelId: string, userId: string): string;
+export declare function isVoiceChannel(channel: AnyChannel): channel is DMChannel | GroupDMChannel | VoiceBasedChannel;

package/dist/utils.js

@@ -0,0 +1,54 @@
+export function normalizeVideoCodec(codec) {
+    if (/H\.?264|AVC/i.test(codec))
+        return "H264";
+    if (/H\.?265|HEVC/i.test(codec))
+        return "H265";
+    if (/VP(8|9)/i.test(codec))
+        return codec.toUpperCase();
+    if (/AV1/i.test(codec))
+        return "AV1";
+    throw new Error(`Unknown codec: ${codec}`);
+}
+// The available video streams are sent by client on connection to voice gateway using OpCode Identify (0)
+// The server then replies with the ssrc and rtxssrc for each available stream using OpCode Ready (2)
+// RID is used specifically to distinguish between different simulcast streams of the same video source,
+// but we don't really care about sending multiple quality streams, so we hardcode a single one
+export const STREAMS_SIMULCAST = [{ type: "screen", rid: "100", quality: 100 }];
+export var SupportedEncryptionModes;
+(function (SupportedEncryptionModes) {
+    SupportedEncryptionModes["AES256"] = "aead_aes256_gcm_rtpsize";
+    SupportedEncryptionModes["XCHACHA20"] = "aead_xchacha20_poly1305_rtpsize";
+})(SupportedEncryptionModes || (SupportedEncryptionModes = {}));
+// RTP extensions
+export const extensions = [{ id: 5, len: 2, val: 0 }];
+export const max_int16bit = 2 ** 16;
+export const max_int32bit = 2 ** 32;
+export function isFiniteNonZero(n) {
+    return !!n && Number.isFinite(n);
+}
+export function parseStreamKey(streamKey) {
+    const streamKeyArray = streamKey.split(":");
+    const type = streamKeyArray.shift();
+    if (type !== "guild" && type !== "call") {
+        throw new Error(`Invalid stream key type: ${type}`);
+    }
+    if ((type === "guild" && streamKeyArray.length < 3) || (type === "call" && streamKey.length < 2))
+        throw new Error(`Invalid stream key: ${streamKey}`); // invalid stream key
+    let guildId = null;
+    if (type === "guild") {
+        guildId = streamKeyArray.shift() ?? null;
+    }
+    const channelId = streamKeyArray.shift();
+    const userId = streamKeyArray.shift();
+    if (!channelId || !userId) {
+        throw new Error(`Invalid stream key: ${streamKey}`);
+    }
+    return { type, channelId, guildId, userId };
+}
+export function generateStreamKey(type, guildId, channelId, userId) {
+    const streamKey = `${type}${type === "guild" ? `:${guildId}` : ""}:${channelId}:${userId}`;
+    return streamKey;
+}
+export function isVoiceChannel(channel) {
+    return (channel.type === "DM" || channel.type === "GROUP_DM" || channel.type === "GUILD_STAGE_VOICE" || channel.type === "GUILD_VOICE");
+}

package/package.json

@@ -0,0 +1,69 @@
+{
+    "name": "@m7mdxzx1/discord-video-strem",
+    "version": "0.0.1",
+    "description": "A fork from dank to use self-bot to do video share",
+    "exports": "./dist/index.js",
+    "types": "dist/index.d.ts",
+    "type": "module",
+    "files": [
+        "dist",
+        "src"
+    ],
+    "publishConfig": {
+        "access": "public"
+    },
+    "dependencies": {
+        "@lng2004/libav.js-variant-webcodecs-avf-with-decoders": "6.5.7-o3",
+        "debug-level": "^3.2.1",
+        "fluent-ffmpeg": "^2.1.3",
+        "p-debounce": "^4.0.0",
+        "sharp": "^0.33.5",
+        "sodium-plus": "^0.9.0",
+        "uid": "^2.0.2",
+        "ws": "^8.18.0",
+        "zeromq": "^6.4.2"
+    },
+    "devDependencies": {
+        "@biomejs/biome": "^1.9.4",
+        "@types/fluent-ffmpeg": "^2.1.27",
+        "@types/node": "^20.17.1",
+        "@types/ws": "^8.5.12",
+        "discord.js-selfbot-v13": "^3.6.0",
+        "pkg-pr-new": "^0.0.39",
+        "typed-emitter": "^2.1.0",
+        "typescript": "^5.6.3"
+    },
+    "peerDependencies": {
+        "discord.js-selfbot-v13": "^3.6.0"
+    },
+    "engines": {
+        "node": ">=21.0.0"
+    },
+    "scripts": {
+        "build": "tsc"
+    },
+    "keywords": [
+        "discord",
+        "video",
+        "voice",
+        "stream",
+        "go-live"
+    ],
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/ChamseddineDz/Discord-video-stream.git"
+    },
+    "contributors": [
+        "Long Nguyen <nguyen.long.908132@gmail.com>",
+        "dank074 <torresefrain10@gmail.com>",
+        "mrjvs <jellevs@gmail.com>",
+        "Elysia <71698422+aiko-chan-ai@users.noreply.github.com>",
+        "Fede14 <fede.ferri2001@gmail.com>",
+        "Malthe Morsing Larsen <57196060+malthemorsing@users.noreply.github.com>"
+    ],
+    "license": "ISC",
+    "bugs": {
+        "url": "https://github.com/ChamseddineDz/Discord-video-stream/issues"
+    },
+    "homepage": "https://github.com/ChamseddineDz/Discord-video-stream#readme"
+}

package/src/client/GatewayEvents.ts

@@ -0,0 +1,41 @@
+type GatewayEventGeneric<Type extends string = string, Data = unknown> = {
+    t: Type,
+    d: Data
+}
+
+export namespace GatewayEvent {
+    export type VoiceStateUpdate = GatewayEventGeneric<
+        "VOICE_STATE_UPDATE", {
+            user_id: string,
+            session_id: string
+        }
+    >
+    export type VoiceServerUpdate = GatewayEventGeneric<
+        "VOICE_SERVER_UPDATE", {
+            guild_id: string,
+            channel_id?: string,
+            endpoint: string,
+            token: string
+        }
+    >
+    export type StreamCreate = GatewayEventGeneric<
+        "STREAM_CREATE", {
+            stream_key: string,
+            rtc_server_id: string
+        }
+    >
+    export type StreamServerUpdate = GatewayEventGeneric<
+        "STREAM_SERVER_UPDATE", {
+            stream_key: string,
+            endpoint: string,
+            token: string
+        }
+    >
+}
+
+
+export type GatewayEvent =
+    GatewayEvent.VoiceStateUpdate |
+    GatewayEvent.VoiceServerUpdate |
+    GatewayEvent.StreamCreate |
+    GatewayEvent.StreamServerUpdate

package/src/client/GatewayOpCodes.ts

@@ -0,0 +1,40 @@
+export enum GatewayOpCodes {
+    DISPATCH = 0,
+    HEARTBEAT = 1,
+    IDENTIFY = 2,
+    PRESENCE_UPDATE = 3,
+    VOICE_STATE_UPDATE = 4,
+    VOICE_SERVER_PING = 5,
+    RESUME = 6,
+    RECONNECT = 7,
+    REQUEST_GUILD_MEMBERS = 8,
+    INVALID_SESSION = 9,
+    HELLO = 10,
+    HEARTBEAT_ACK = 11,
+    CALL_CONNECT = 13,
+    GUILD_SUBSCRIPTIONS = 14,
+    LOBBY_CONNECT = 15,
+    LOBBY_DISCONNECT = 16,
+    LOBBY_VOICE_STATES_UPDATE = 17,
+    STREAM_CREATE = 18,
+    STREAM_DELETE = 19,
+    STREAM_WATCH = 20,
+    STREAM_PING = 21,
+    STREAM_SET_PAUSED = 22,
+    REQUEST_GUILD_APPLICATION_COMMANDS = 24,
+    EMBEDDED_ACTIVITY_LAUNCH = 25,
+    EMBEDDED_ACTIVITY_CLOSE = 26,
+    EMBEDDED_ACTIVITY_UPDATE = 27,
+    REQUEST_FORUM_UNREADS = 28,
+    REMOTE_COMMAND = 29,
+    GET_DELETED_ENTITY_IDS_NOT_MATCHING_HASH = 30,
+    REQUEST_SOUNDBOARD_SOUNDS = 31,
+    SPEED_TEST_CREATE = 32,
+    SPEED_TEST_DELETE = 33,
+    REQUEST_LAST_MESSAGES = 34,
+    SEARCH_RECENT_MEMBERS = 35,
+    REQUEST_CHANNEL_STATUSES = 36,
+    GUILD_SUBSCRIPTIONS_BULK = 37,
+    GUILD_CHANNELS_RESYNC = 38,
+    REQUEST_CHANNEL_MEMBER_COUNT = 39,
+}