yukimu 1.3.0 → 2.0.8

package/src/Queue.ts

@@ -1,66 +0,0 @@
-import type { Track } from "./types";
-
-export class Queue {
-  public current: Track | null = null;
-  public previous: Track[] = [];
-  private tracks: Track[] = [];
-
-  public add(tracks: Track | Track[], position?: number): void {
-    const arr = Array.isArray(tracks) ? tracks : [tracks];
-    if (position !== undefined) this.tracks.splice(position, 0, ...arr);
-    else this.tracks.push(...arr);
-  }
-
-  public next(): Track | null {
-    if (this.current) {
-      this.previous.unshift(this.current);
-      if (this.previous.length > 10) this.previous.pop();
-    }
-    this.current = this.tracks.shift() ?? null;
-    return this.current;
-  }
-
-  public remove(index: number): Track | null {
-    if (index < 0 || index >= this.tracks.length) return null;
-    const [removed] = this.tracks.splice(index, 1);
-    return removed;
-  }
-
-  public removeRange(start: number, end: number): Track[] {
-    return this.tracks.splice(start, end - start);
-  }
-
-  public clear(): void {
-    this.tracks = [];
-    this.current = null;
-    this.previous = [];
-  }
-
-  public shuffle(): void {
-    for (let i = this.tracks.length - 1; i > 0; i--) {
-      const j = Math.floor(Math.random() * (i + 1));
-      [this.tracks[i], this.tracks[j]] = [this.tracks[j], this.tracks[i]];
-    }
-  }
-
-  public move(from: number, to: number): void {
-    if (from < 0 || to < 0 || from >= this.tracks.length || to >= this.tracks.length) return;
-    const [track] = this.tracks.splice(from, 1);
-    this.tracks.splice(to, 0, track);
-  }
-
-  public skipto(index: number): Track | null {
-    if (index < 0 || index >= this.tracks.length) return null;
-    this.tracks.splice(0, index);
-    return this.next();
-  }
-
-  public peek(count: number = 10): Track[] { return this.tracks.slice(0, count); }
-  public find(predicate: (track: Track) => boolean): Track | undefined { return this.tracks.find(predicate); }
-  public filter(predicate: (track: Track) => boolean): Track[] { return this.tracks.filter(predicate); }
-
-  get size(): number { return this.tracks.length; }
-  get isEmpty(): boolean { return this.tracks.length === 0; }
-  get totalDuration(): number { return this.tracks.reduce((acc, t) => acc + (t.info?.length ?? 0), 0); }
-  get list(): ReadonlyArray<Track> { return this.tracks; }
-}

package/src/Resolver.ts

@@ -1,90 +0,0 @@
-import { SOURCE_PREFIXES, URL_PATTERNS } from "./Constants";
-import type { Yukimu } from "./Yukimu";
-import type { SearchResult, SearchSource, Track } from "./types";
-
-export class Resolver {
-  private manager: Yukimu;
-  private spotifyToken: string | null = null;
-  private spotifyExpiry: number = 0;
-
-  constructor(manager: Yukimu) { this.manager = manager; }
-
-  public async resolve(query: string, source: SearchSource, requester?: any): Promise<SearchResult> {
-    const node = this.manager.getBestNode();
-    const isUrl = /^https?:\/\//.test(query);
-    const identifier = isUrl ? query : `${SOURCE_PREFIXES[source] ?? "ytsearch"}:${query}`;
-
-    let result: SearchResult;
-    try {
-      result = await node.loadTracks(identifier);
-    } catch (err: any) {
-      console.error("[Resolver] loadTracks error:", err.message);
-      return { loadType: "error", tracks: [] };
-    }
-
-    if (!result) return { loadType: "empty", tracks: [] };
-    if (!result.tracks) result.tracks = [];
-
-    // Attach requester to all tracks
-    if (requester && result.tracks.length > 0) {
-      result.tracks.forEach((t: any) => { t.requester = requester; });
-    }
-
-    // Spotify fallback — if LavaSrc not installed
-    if ((result.loadType === "error" || result.loadType === "empty") && isUrl) {
-      const spotifyMatch = query.match(/spotify\.com\/track\/([a-zA-Z0-9]+)/);
-      if (spotifyMatch) {
-        const meta = await this.resolveSpotifyMeta(spotifyMatch[1]);
-        if (meta) return this.resolve(`${meta.title} ${meta.artist}`, "youtube", requester);
-      }
-    }
-
-    // Cache tracks
-    if (result.tracks.length > 0) {
-      for (const track of result.tracks) {
-        if (track?.encoded) this.manager.trackCache.set(track.encoded, track);
-      }
-    }
-
-    return result;
-  }
-
-  public detectSource(url: string): SearchSource | null {
-    for (const [source, patterns] of Object.entries(URL_PATTERNS)) {
-      if (patterns.some(p => p.test(url))) return source as SearchSource;
-    }
-    return null;
-  }
-
-  private async getSpotifyToken(): Promise<string | null> {
-    const opts = this.manager.options.spotify;
-    if (!opts) return null;
-    if (this.spotifyToken && Date.now() < this.spotifyExpiry) return this.spotifyToken;
-    try {
-      const res = await (globalThis as any).fetch("https://accounts.spotify.com/api/token", {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/x-www-form-urlencoded",
-          Authorization: `Basic ${Buffer.from(`${opts.clientId}:${opts.clientSecret}`).toString("base64")}`,
-        },
-        body: "grant_type=client_credentials",
-      });
-      const data = await res.json();
-      this.spotifyToken = data.access_token;
-      this.spotifyExpiry = Date.now() + data.expires_in * 1000 - 5000;
-      return this.spotifyToken;
-    } catch { return null; }
-  }
-
-  private async resolveSpotifyMeta(trackId: string): Promise<{ title: string; artist: string } | null> {
-    const token = await this.getSpotifyToken();
-    if (!token) return null;
-    try {
-      const res = await (globalThis as any).fetch(`https://api.spotify.com/v1/tracks/${trackId}`, {
-        headers: { Authorization: `Bearer ${token}` },
-      });
-      const data = await res.json();
-      return { title: data.name, artist: data.artists[0]?.name ?? "Unknown" };
-    } catch { return null; }
-  }
-}

package/src/Rest.ts

@@ -1,127 +0,0 @@
-import { RestError } from "./errors/YukimuError";
-import type { Node } from "./Node";
-import type { SearchResult, Track, NodeStats, NodeInfo } from "./types";
-
-const TIMEOUT_MS = 30000;
-
-export class Rest {
-  private node: Node;
-
-  constructor(node: Node) { this.node = node; }
-
-  get baseUrl(): string {
-    const protocol = this.node.options.secure ? "https" : "http";
-    return `${protocol}://${this.node.options.host}:${this.node.options.port}`;
-  }
-
-  get prefix(): string { return this.node.version === 4 ? "/v4" : ""; }
-
-  get headers(): Record<string, string> {
-    return {
-      Authorization: this.node.options.password,
-      "User-Id": this.node.manager.options.clientId,
-      "Client-Name": "Yukimu/1.3.0",
-      "Content-Type": "application/json",
-      ...(this.node.version === 3 ? { "Num-Shards": "1" } : {}),
-    };
-  }
-
-  public async request<T = any>(method: string, path: string, body?: any): Promise<T> {
-    const url = `${this.baseUrl}${this.prefix}${path}`;
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), TIMEOUT_MS);
-
-    try {
-      const res = await (globalThis as any).fetch(url, {
-        method,
-        headers: this.headers,
-        body: body ? JSON.stringify(body) : undefined,
-        signal: controller.signal,
-      });
-
-      clearTimeout(timeout);
-
-      if (!res.ok) {
-        const text = await res.text().catch(() => "Unknown error");
-        throw new RestError(`REST ${res.status} on ${method} ${path}: ${text}`, res.status, path);
-      }
-
-      if (res.status === 204) return undefined as T;
-
-      const text = await res.text();
-      let parsed: any;
-      try { parsed = JSON.parse(text); } catch { return null as T; }
-
-      // Normalize Lavalink v4.2+ response — uses "data" instead of "tracks"
-      if (parsed && parsed.data !== undefined && !parsed.tracks) {
-        parsed.tracks = Array.isArray(parsed.data) ? parsed.data : [parsed.data];
-      }
-
-      return parsed as T;
-    } catch (err: any) {
-      clearTimeout(timeout);
-      if (err.name === "AbortError") throw new RestError(`REST timeout on ${method} ${path}`, 408, path);
-      throw err;
-    }
-  }
-
-  public async loadTracks(identifier: string): Promise<SearchResult> {
-    const raw = await this.request<any>("GET", `/loadtracks?identifier=${encodeURIComponent(identifier)}`);
-    if (!raw) return { loadType: "empty", tracks: [] };
-    return this.node.version === 3 ? this.normalizeV3(raw) : raw;
-  }
-
-  public async decodeTrack(encoded: string): Promise<Track> {
-    return this.request("GET", `/decodetrack?encodedTrack=${encodeURIComponent(encoded)}`);
-  }
-
-  public async decodeTracks(encoded: string[]): Promise<Track[]> {
-    return this.request("POST", `/decodetracks`, encoded);
-  }
-
-  public async getInfo(): Promise<NodeInfo> {
-    return this.request("GET", "/info");
-  }
-
-  public async getStats(): Promise<NodeStats> {
-    return this.request("GET", "/stats");
-  }
-
-  public async updatePlayer(guildId: string, body: any, noReplace = false): Promise<any> {
-    const path = this.node.version === 4
-      ? `/sessions/${this.node.sessionId}/players/${guildId}?noReplace=${noReplace}`
-      : `/players/${guildId}`;
-    return this.request("PATCH", path, body);
-  }
-
-  public async destroyPlayer(guildId: string): Promise<void> {
-    const path = this.node.version === 4
-      ? `/sessions/${this.node.sessionId}/players/${guildId}`
-      : `/players/${guildId}`;
-    await this.request("DELETE", path).catch(() => {});
-  }
-
-  public async updateSession(body: { resuming?: boolean; timeout?: number }): Promise<any> {
-    if (this.node.version !== 4) return;
-    return this.request("PATCH", `/sessions/${this.node.sessionId}`, body);
-  }
-
-  private normalizeV3(raw: any): SearchResult {
-    const loadType = (raw?.loadType ?? "").toLowerCase();
-    const norm = (tracks: any[]): Track[] =>
-      (tracks ?? []).map((t: any) => ({
-        encoded: t.track ?? t.encoded,
-        info: t.info,
-        pluginInfo: t.pluginInfo ?? {},
-      }));
-
-    switch (loadType) {
-      case "track_loaded": return { loadType: "track", tracks: norm(raw.tracks) };
-      case "playlist_loaded": return { loadType: "playlist", tracks: norm(raw.tracks), playlistInfo: raw.playlistInfo };
-      case "search_result": return { loadType: "search", tracks: norm(raw.tracks) };
-      case "no_matches": return { loadType: "empty", tracks: [] };
-      case "load_failed": return { loadType: "error", tracks: [], exception: raw.exception };
-      default: return { loadType: "empty", tracks: [] };
-    }
-  }
-}

package/src/TrackCache.ts

@@ -1,46 +0,0 @@
-import type { Track } from "./types";
-
-interface CacheEntry {
-  track: Track;
-  expiresAt: number;
-}
-
-export class TrackCache {
-  private cache: Map<string, CacheEntry> = new Map();
-  private readonly ttl: number;
-  private sweepInterval: ReturnType<typeof setInterval>;
-
-  constructor(ttlMs: number = 3600000) {
-    this.ttl = ttlMs;
-    this.sweepInterval = setInterval(() => this.sweep(), 600000);
-  }
-
-  public set(encoded: string, track: Track): void {
-    this.cache.set(encoded, { track, expiresAt: Date.now() + this.ttl });
-  }
-
-  public get(encoded: string): Track | null {
-    const entry = this.cache.get(encoded);
-    if (!entry) return null;
-    if (Date.now() > entry.expiresAt) { this.cache.delete(encoded); return null; }
-    return entry.track;
-  }
-
-  public has(encoded: string): boolean { return this.get(encoded) !== null; }
-  public delete(encoded: string): void { this.cache.delete(encoded); }
-  public clear(): void { this.cache.clear(); }
-
-  private sweep(): void {
-    const now = Date.now();
-    for (const [key, entry] of this.cache) {
-      if (now > entry.expiresAt) this.cache.delete(key);
-    }
-  }
-
-  public destroy(): void {
-    clearInterval(this.sweepInterval);
-    this.cache.clear();
-  }
-
-  get size(): number { return this.cache.size; }
-}

package/src/WsQueue.ts

@@ -1,58 +0,0 @@
-import WebSocket from "ws";
-
-interface QueuedMessage {
-  data: string;
-  resolve: () => void;
-  reject: (err: Error) => void;
-}
-
-export class WsQueue {
-  private queue: QueuedMessage[] = [];
-  private ws: WebSocket | null = null;
-
-  public setSocket(ws: WebSocket | null): void {
-    this.ws = ws;
-    if (ws) {
-      ws.on("open", () => this.flush());
-    }
-  }
-
-  public send(data: Record<string, any>): Promise<void> {
-    return new Promise((resolve, reject) => {
-      const serialized = JSON.stringify(data);
-      if (this.ws?.readyState === 1) {
-        this.ws.send(serialized, (err: any) => {
-          if (err) reject(err);
-          else resolve();
-        });
-      } else {
-        this.queue.push({ data: serialized, resolve, reject });
-      }
-    });
-  }
-
-  public flush(): void {
-    if (!this.ws) return;
-    const toSend = [...this.queue];
-    this.queue = [];
-    for (const msg of toSend) {
-      if (this.ws.readyState !== 1) {
-        this.queue.unshift(msg);
-        return;
-      }
-      this.ws.send(msg.data, (err: any) => {
-        if (err) msg.reject(err);
-        else msg.resolve();
-      });
-    }
-  }
-
-  public clear(): void {
-    for (const msg of this.queue) {
-      msg.reject(new Error("WsQueue cleared"));
-    }
-    this.queue = [];
-  }
-
-  get size(): number { return this.queue.length; }
-}

package/src/Yukimu.ts

@@ -1,213 +0,0 @@
-import { EventEmitter } from "events";
-import { Node } from "./Node";
-import { Player } from "./Player";
-import { Resolver } from "./Resolver";
-import { ConnectionPool } from "./ConnectionPool";
-import { TrackCache } from "./TrackCache";
-import { URL_PATTERNS } from "./Constants";
-import { YukimuError } from "./errors/YukimuError";
-import type { Plugin } from "./Plugin";
-import type { Connector } from "./connector/Connector";
-import type { YukimuOptions, NodeOptions, PlayerOptions, YukimuEvents, SearchSource, SearchResult } from "./types";
-
-export class Yukimu extends EventEmitter {
-  public readonly options: YukimuOptions;
-  public readonly nodes: Map<string, Node> = new Map();
-  public readonly players: Map<string, Player> = new Map();
-  public readonly connector: Connector;
-  public readonly resolver: Resolver;
-  public readonly pool: ConnectionPool;
-  public readonly trackCache: TrackCache;
-  private readonly plugins: Map<string, Plugin> = new Map();
-  public nodeResolver?: (nodes: Map<string, Node>) => Node | undefined;
-
-  constructor(options: YukimuOptions, connector: Connector, nodes: NodeOptions[], plugins: Plugin[] = []) {
-    super();
-    this.options = { moveOnDisconnect: true, voiceConnectionTimeout: 15000, ...options };
-    this.connector = connector.set(this);
-    this.resolver = new Resolver(this);
-    this.pool = new ConnectionPool(this);
-    this.trackCache = new TrackCache();
-    for (const plugin of plugins) this.use(plugin);
-    this.connector.listen();
-    for (const node of nodes) this.addNode(node);
-  }
-
-  // ─── Plugin System ────────────────────────────────────────────────
-  public use(plugin: Plugin): this {
-    if (this.plugins.has(plugin.name)) throw new YukimuError(`Plugin "${plugin.name}" already loaded`);
-    plugin.load(this);
-    this.plugins.set(plugin.name, plugin);
-    console.log(`[Yukimu] Plugin "${plugin.name}" loaded`);
-    return this;
-  }
-
-  public unuse(name: string): this {
-    const plugin = this.plugins.get(name);
-    if (!plugin) throw new YukimuError(`Plugin "${name}" not found`);
-    plugin.unload?.(this);
-    this.plugins.delete(name);
-    return this;
-  }
-
-  public getPlugin<T extends Plugin>(name: string): T | undefined {
-    return this.plugins.get(name) as T;
-  }
-
-  // ─── Node Management ──────────────────────────────────────────────
-  public addNode(options: NodeOptions): Node {
-    if (this.nodes.has(options.name)) throw new YukimuError(`Node "${options.name}" already exists`);
-    const node = new Node(this, options);
-    this.nodes.set(options.name, node);
-    node.connect();
-    return node;
-  }
-
-  public removeNode(name: string): void {
-    const node = this.nodes.get(name);
-    if (!node) throw new YukimuError(`Node "${name}" not found`);
-    node.destroy();
-    this.nodes.delete(name);
-  }
-
-  public getNode(name?: string): Node {
-    if (name) {
-      const node = this.nodes.get(name);
-      if (!node) throw new YukimuError(`Node "${name}" not found`);
-      return node;
-    }
-    return this.getBestNode();
-  }
-
-  public getBestNode(): Node {
-    const connected = [...this.nodes.values()].filter(n => n.connected);
-    if (!connected.length) throw new YukimuError("No connected Lavalink nodes available");
-    if (this.nodeResolver) {
-      const resolved = this.nodeResolver(this.nodes);
-      if (resolved?.connected) return resolved;
-    }
-    return connected.sort((a, b) => a.calculatePenalties() - b.calculatePenalties())[0];
-  }
-
-  // ─── Player Management ────────────────────────────────────────────
-  public createPlayer(options: PlayerOptions): Player {
-    const existing = this.players.get(options.guildId);
-    if (existing) return existing;
-    const node = options.nodeName ? this.getNode(options.nodeName) : this.getBestNode();
-    const player = new Player(this, node, options);
-    this.players.set(options.guildId, player);
-    this.pool.add(options.guildId, options.voiceChannelId);
-    this.emit("playerCreate", player);
-    return player;
-  }
-
-  public getPlayer(guildId: string): Player | null {
-    return this.players.get(guildId) ?? null;
-  }
-
-  public async destroyPlayer(guildId: string): Promise<void> {
-    const player = this.players.get(guildId);
-    if (!player) return;
-    await player.destroy();
-    this.players.delete(guildId);
-    this.pool.remove(guildId);
-    this.emit("playerDestroy", player);
-  }
-
-  // ─── Search ───────────────────────────────────────────────────────
-  public async search(query: string, options?: { source?: SearchSource; requester?: any }): Promise<SearchResult> {
-    return this.resolver.resolve(
-      query,
-      options?.source ?? this.options.defaultSource ?? "youtube",
-      options?.requester
-    );
-  }
-
-  // ─── Voice Gateway ────────────────────────────────────────────────
-  public handleVoiceStateUpdate(data: any): void {
-    if (data.user_id !== this.options.clientId) return;
-    if (!data.guild_id) return;
-
-    const player = this.players.get(data.guild_id);
-
-    if (!data.channel_id) {
-      this.pool.remove(data.guild_id);
-      if (player && this.options.moveOnDisconnect) {
-        this.destroyPlayer(data.guild_id).catch(() => {});
-      }
-      return;
-    }
-
-    this.pool.updateSession(data.guild_id, data.session_id, data.channel_id);
-
-    if (player) {
-      const oldChannel = player.voiceChannelId;
-      player.voiceChannelId = data.channel_id;
-      player.sessionId = data.session_id;
-
-      if (oldChannel && oldChannel !== data.channel_id) {
-        this.emit("playerMove", player, oldChannel, data.channel_id);
-      }
-
-      if (this.pool.isReady(data.guild_id)) {
-        const vs = this.pool.getVoiceState(data.guild_id)!;
-        player.voiceToken = vs.token;
-        player.voiceEndpoint = vs.endpoint;
-        player.checkVoiceReady();
-        this.pool.markConnected(data.guild_id);
-      }
-    }
-  }
-
-  public handleVoiceServerUpdate(data: any): void {
-    if (!data.endpoint) return;
-    this.pool.updateServer(data.guild_id, data.token, data.endpoint);
-    const player = this.players.get(data.guild_id);
-    if (!player) return;
-    player.voiceToken = data.token;
-    player.voiceEndpoint = data.endpoint;
-    if (this.pool.isReady(data.guild_id)) {
-      player.checkVoiceReady();
-      this.pool.markConnected(data.guild_id);
-    }
-  }
-
-  // ─── Utility ─────────────────────────────────────────────────────
-  public detectSource(url: string): SearchSource | null {
-    for (const [source, patterns] of Object.entries(URL_PATTERNS)) {
-      if (patterns.some(p => p.test(url))) return source as SearchSource;
-    }
-    return null;
-  }
-
-  public getStats() {
-    const nodes = [...this.nodes.values()];
-    return {
-      nodes: nodes.length,
-      connectedNodes: nodes.filter(n => n.connected).length,
-      players: this.players.size,
-      playingPlayers: [...this.players.values()].filter(p => p.playing).length,
-      cachedTracks: this.trackCache.size,
-    };
-  }
-
-  public destroy(): void {
-    for (const node of this.nodes.values()) node.destroy();
-    this.trackCache.destroy();
-    this.nodes.clear();
-  }
-
-  // ─── Typed EventEmitter ───────────────────────────────────────────
-  public on<K extends keyof YukimuEvents>(event: K, listener: (...args: YukimuEvents[K]) => void): this {
-    return super.on(event, listener as any);
-  }
-  public once<K extends keyof YukimuEvents>(event: K, listener: (...args: YukimuEvents[K]) => void): this {
-    return super.once(event, listener as any);
-  }
-  public off<K extends keyof YukimuEvents>(event: K, listener: (...args: YukimuEvents[K]) => void): this {
-    return super.off(event, listener as any);
-  }
-  public emit<K extends keyof YukimuEvents>(event: K, ...args: YukimuEvents[K]): boolean {
-    return super.emit(event, ...args);
-  }
-}

package/src/connector/Connector.ts

@@ -1,13 +0,0 @@
-import type { Yukimu } from "../Yukimu";
-
-export abstract class Connector {
-  protected manager!: Yukimu;
-
-  public set(manager: Yukimu): this {
-    this.manager = manager;
-    return this;
-  }
-
-  public abstract listen(): void;
-  public abstract sendPayload(guildId: string, payload: unknown): void;
-}

package/src/connector/DiscordJS.ts

@@ -1,26 +0,0 @@
-import { Connector } from "./Connector";
-
-export class DiscordJS extends Connector {
-  private client: any;
-
-  constructor(client: any) {
-    super();
-    this.client = client;
-  }
-
-  public listen(): void {
-    this.client.on("raw", (packet: any) => {
-      if (packet.t === "VOICE_STATE_UPDATE") {
-        this.manager.handleVoiceStateUpdate(packet.d);
-      }
-      if (packet.t === "VOICE_SERVER_UPDATE") {
-        this.manager.handleVoiceServerUpdate(packet.d);
-      }
-    });
-  }
-
-  public sendPayload(guildId: string, payload: unknown): void {
-    const guild = this.client.guilds.cache.get(guildId);
-    if (guild) guild.shard.send(payload);
-  }
-}

package/src/connector/Eris.ts

@@ -1,24 +0,0 @@
-import { Connector } from "./Connector";
-
-export class Eris extends Connector {
-  private client: any;
-
-  constructor(client: any) {
-    super();
-    this.client = client;
-  }
-
-  public listen(): void {
-    this.client.on("rawWS", (packet: any) => {
-      if (packet.t === "VOICE_STATE_UPDATE") this.manager.handleVoiceStateUpdate(packet.d);
-      if (packet.t === "VOICE_SERVER_UPDATE") this.manager.handleVoiceServerUpdate(packet.d);
-    });
-  }
-
-  public sendPayload(guildId: string, payload: unknown): void {
-    const guild = this.client.guilds.get(guildId);
-    if (!guild) return;
-    const shard = this.client.shards.get(guild.shard.id);
-    if (shard) shard.sendWS(4, (payload as any).d);
-  }
-}

package/src/connector/Oceanic.ts

@@ -1,22 +0,0 @@
-import { Connector } from "./Connector";
-
-export class Oceanic extends Connector {
-  private client: any;
-
-  constructor(client: any) {
-    super();
-    this.client = client;
-  }
-
-  public listen(): void {
-    this.client.on("packet", (packet: any) => {
-      if (packet.t === "VOICE_STATE_UPDATE") this.manager.handleVoiceStateUpdate(packet.d);
-      if (packet.t === "VOICE_SERVER_UPDATE") this.manager.handleVoiceServerUpdate(packet.d);
-    });
-  }
-
-  public sendPayload(guildId: string, payload: unknown): void {
-    const guild = this.client.guilds.get(guildId);
-    if (guild) guild.shard.send(payload);
-  }
-}