djs-selfbot-v13 3.7.1 → 3.7.2

package/README.md

@@ -14,6 +14,32 @@
 
 - discord.js-selfbot-v13 is a [Node.js](https://nodejs.org) module that allows user accounts to interact with the Discord API v9.
 
+## Nouveautés
+
+> **Nouvelles fonctionnalités ajoutées :**
+- `guild.mute()` - Supprime completement les pings
+- `guild.unmute()` - Remet les pings sur le serveur
+
+- `rpc.setDetailsURL(url)` - Met une URL pour les details du RPC
+- `rpc.setStateURL(url)` - Met une URL pour le state du RPC
+
+- `client.user.setNameStyle(fontName, effectName, color1, color2?)` - Définir le style du nom d'affichage avec police, effet et couleurs
+- `client.user.setClan(GuildID)` - Changer votre TAG de serveur
+- `client.user.deleteClan()` - Retire le TAG de serveur
+
+- `client.user.addWidget(type, gameId, comment?, tags?)` - Ajouter un widget de jeu au profil
+- `client.user.delWidget(type, gameId?)` - Supprimer un widget ou un jeu spécifique
+- `client.user.widgetsList()` - Obtenir la liste de tous les widgets
+
+- `client.quests.get()` - Récupérer toutes les quêtes disponibles
+- `client.quests.orbs()` - Obtenir le solde de la monnaie virtuelle
+- `client.quests.acceptQuest(questId, options?)` - S'inscrire à une quête
+- `client.quests.doingQuest(quest)` - Compléter automatiquement une quête
+- `client.quests.autoCompleteAll()` - Compléter automatiquement toutes les quêtes valides
+- `client.quests.getCompleted()` - Obtenir les quêtes terminées
+- `client.quests.getClaimable()` - Obtenir les quêtes réclamables
+- `client.quests.filterQuestsValid()` - Filtrer les quêtes valides
+
 
 <div align="center">
   <p>
@@ -49,13 +75,13 @@
 > **Node.js 20.18.0 or newer is required**
 
 ```sh-session
-npm install discord.js-selfbot-v13-next@latest
+npm install djs-selfbot-v13@latest
 ```
 
 ## Example
 
 ```js
-const { Client } = require('discord.js-selfbot-v13-next');
+const { Client } = require('djs-selfbot-v13');
 const client = new Client();
 
 client.on('ready', async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "djs-selfbot-v13",
-  "version": "3.7.1",
+  "version": "3.7.2",
   "description": "An unofficial discord.js fork for creating selfbots",
   "main": "./src/index.js",
   "types": "./typings/index.d.ts",

package/src/client/Client.js

@@ -17,6 +17,7 @@ const ChannelManager = require('../managers/ChannelManager');
 const ClientUserSettingManager = require('../managers/ClientUserSettingManager');
 const GuildManager = require('../managers/GuildManager');
 const PresenceManager = require('../managers/PresenceManager');
+const QuestManager = require('../managers/QuestManager');
 const RelationshipManager = require('../managers/RelationshipManager');
 const SessionManager = require('../managers/SessionManager');
 const UserManager = require('../managers/UserManager');
@@ -158,6 +159,12 @@ class Client extends BaseClient {
      */
     this.billing = new BillingManager(this);
 
+    /**
+     * Manages quest-related API methods
+     * @type {QuestManager}
+     */
+    this.quests = new QuestManager(this);
+
     /**
      * All of the sessions of the client
      * @type {SessionManager}

package/src/managers/QuestManager.js

@@ -0,0 +1,376 @@
+'use strict';
+
+const { Collection } = require('@discordjs/collection');
+const BaseManager = require('./BaseManager');
+
+/**
+ * Represents a single quest
+ */
+class Quest {
+  constructor(data) {
+    this.id = data.id;
+    this.config = data.config;
+    this.userStatus = data.user_status;
+  }
+
+  /**
+   * Check if quest is expired
+   * @param {Date} [date=new Date()] Date to check against
+   * @returns {boolean}
+   */
+  isExpired(date = new Date()) {
+    if (!this.config.expires_at) return false;
+    return new Date(this.config.expires_at) < date;
+  }
+
+  /**
+   * Check if quest is completed
+   * @returns {boolean}
+   */
+  isCompleted() {
+    return this.userStatus?.completed_at != null;
+  }
+
+  /**
+   * Check if quest rewards have been claimed
+   * @returns {boolean}
+   */
+  hasClaimedRewards() {
+    return this.userStatus?.claimed_at != null;
+  }
+
+  /**
+   * Check if user is enrolled in quest
+   * @returns {boolean}
+   */
+  isEnrolledQuest() {
+    return this.userStatus?.enrolled_at != null;
+  }
+
+  /**
+   * Update user status for this quest
+   * @param {Object} status New status data
+   */
+  updateUserStatus(status) {
+    this.userStatus = { ...this.userStatus, ...status };
+  }
+}
+
+/**
+ * Manages API methods for Discord quests
+ * @extends {BaseManager}
+ */
+class QuestManager extends BaseManager {
+  constructor(client) {
+    super(client);
+    
+    /**
+     * Collection of cached quests
+     * @type {Collection<string, Quest>}
+     */
+    this.cache = new Collection();
+  }
+
+  /**
+   * Get all available quests for the user
+   * @returns {Promise<Object>} Quest data
+   */
+  async get() {
+    const data = await this.client.api.users('@me').quests.get();
+    
+    // Cache quests
+    if (data.quests) {
+      this.cache.clear();
+      data.quests.forEach(questData => {
+        const quest = new Quest(questData);
+        this.cache.set(quest.id, quest);
+      });
+    }
+    
+    return data;
+  }
+
+  /**
+   * Get user's orb balance (virtual currency)
+   * @returns {Promise<Object>} Balance data
+   */
+  async orbs() {
+    const data = await this.client.api.users['@me']['virtual-currency'].balance.get();
+    return data;
+  }
+
+  /**
+   * Get quest by ID from cache
+   * @param {string} id Quest ID
+   * @returns {Quest|undefined}
+   */
+  getQuest(id) {
+    return this.cache.get(id);
+  }
+
+  /**
+   * Get all cached quests as array
+   * @returns {Quest[]}
+   */
+  list() {
+    return Array.from(this.cache.values());
+  }
+
+  /**
+   * Get expired quests
+   * @param {Date} [date=new Date()] Date to check against
+   * @returns {Quest[]}
+   */
+  getExpired(date = new Date()) {
+    return this.list().filter(quest => quest.isExpired(date));
+  }
+
+  /**
+   * Get completed quests
+   * @returns {Quest[]}
+   */
+  getCompleted() {
+    return this.list().filter(quest => quest.isCompleted());
+  }
+
+  /**
+   * Get claimable quests (completed but not claimed)
+   * @returns {Quest[]}
+   */
+  getClaimable() {
+    return this.list().filter(quest => quest.isCompleted() && !quest.hasClaimedRewards());
+  }
+
+  /**
+   * Get valid quests (not completed, not expired, not blacklisted)
+   * @returns {Quest[]}
+   */
+  filterQuestsValid() {
+    return this.list().filter(quest =>
+      quest.id !== '1412491570820812933' &&
+      !quest.isCompleted() &&
+      !quest.isExpired()
+    );
+  }
+
+  /**
+   * Check if quest exists in cache
+   * @param {string} id Quest ID
+   * @returns {boolean}
+   */
+  hasQuest(id) {
+    return this.cache.has(id);
+  }
+
+  /**
+   * Get application data for given IDs
+   * @param {string[]} ids Application IDs
+   * @returns {Promise<Object[]>}
+   */
+  async getApplicationData(ids) {
+    const query = new URLSearchParams();
+    ids.forEach(id => query.append('application_ids', id));
+    
+    return this.client.api.applications.public.get({ query: query.toString() });
+  }
+
+  /**
+   * Enroll in a specific quest
+   * @param {string} questId The quest ID to enroll in
+   * @param {Object} [options] Enrollment options
+   * @param {number} [options.location=11] Location parameter
+   * @param {boolean} [options.isTargeted=false] Whether the quest is targeted
+   * @param {*} [options.metadataRaw=null] Raw metadata
+   * @returns {Promise<Quest|undefined>} Updated quest or undefined
+   */
+  async acceptQuest(questId, options = {}) {
+    const { location = 11, isTargeted = false, metadataRaw = null } = options;
+    
+    const data = await this.client.api.quests(questId).enroll.post({
+      data: { 
+        location, 
+        is_targeted: isTargeted,
+        metadata_raw: metadataRaw
+      }
+    });
+    
+    const quest = this.getQuest(questId);
+    if (quest) {
+      quest.updateUserStatus(data);
+    }
+    
+    return quest;
+  }
+
+  /**
+   * Update progress for a video quest
+   * @param {string} questId The quest ID
+   * @param {number} timestamp Current progress timestamp
+   * @returns {Promise<Object>} Progress update result
+   */
+  async videoProgress(questId, timestamp) {
+    const data = await this.client.api.quests(questId)['video-progress'].post({
+      data: { timestamp }
+    });
+    return data;
+  }
+
+  /**
+   * Send heartbeat for desktop quests
+   * @param {string} questId The quest ID
+   * @param {string} applicationId Application ID
+   * @param {boolean} [terminal=false] Whether this is a terminal heartbeat
+   * @returns {Promise<Object>} Heartbeat result
+   */
+  async heartbeat(questId, applicationId, terminal = false) {
+    const data = await this.client.api.quests(questId).heartbeat.post({
+      data: {
+        application_id: applicationId,
+        terminal
+      }
+    });
+    return data;
+  }
+
+  /**
+   * Helper function for timeout
+   * @param {number} ms Milliseconds to wait
+   * @returns {Promise<void>}
+   * @private
+   */
+  async timeout(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+
+  /**
+   * Complete a quest automatically
+   * @param {Quest} quest Quest to complete
+   * @returns {Promise<void>}
+   */
+  async doingQuest(quest) {
+    const questName = quest.config.messages?.quest_name || 'Unknown Quest';
+    
+    if (!quest.isEnrolledQuest()) {
+      console.log(`Enrolling in quest "${questName}"...`);
+      await this.acceptQuest(quest.id);
+    }
+
+    const applicationName = quest.config.application?.name || 'Unknown App';
+    const taskConfig = quest.config.task_config;
+    
+    const taskName = [
+      'WATCH_VIDEO',
+      'PLAY_ON_DESKTOP', 
+      'STREAM_ON_DESKTOP',
+      'PLAY_ACTIVITY',
+      'WATCH_VIDEO_ON_MOBILE'
+    ].find(x => taskConfig.tasks?.[x] != null);
+
+    if (!taskName) {
+      console.log(`Unknown task type for quest "${questName}"`);
+      return;
+    }
+
+    const secondsNeeded = taskConfig.tasks[taskName].target;
+    let secondsDone = quest.userStatus?.progress?.[taskName]?.value ?? 0;
+
+    if (taskName === 'WATCH_VIDEO' || taskName === 'WATCH_VIDEO_ON_MOBILE') {
+      const maxFuture = 10;
+      const speed = 7;
+      const interval = 1;
+      const enrolledAt = new Date(quest.userStatus?.enrolled_at).getTime();
+      let completed = false;
+
+      console.log(`Spoofing video for ${questName}.`);
+
+      while (true) {
+        const maxAllowed = Math.floor((Date.now() - enrolledAt) / 1000) + maxFuture;
+        const diff = maxAllowed - secondsDone;
+        const timestamp = secondsDone + speed;
+
+        if (diff >= speed) {
+          const res = await this.videoProgress(quest.id, Math.min(secondsNeeded, timestamp + Math.random()));
+          completed = res.completed_at != null;
+          secondsDone = Math.min(secondsNeeded, timestamp);
+        }
+
+        if (timestamp >= secondsNeeded) {
+          break;
+        }
+
+        await this.timeout(interval * 1000);
+      }
+
+      if (!completed) {
+        await this.videoProgress(quest.id, secondsNeeded);
+      }
+
+      console.log(`Quest "${questName}" completed!`);
+
+    } else if (taskName === 'PLAY_ON_DESKTOP') {
+      const interval = 60;
+
+      while (!quest.isCompleted()) {
+        const secondsDone = quest.userStatus?.progress?.[taskName]?.value || 0;
+        const res = await this.heartbeat(quest.id, quest.config.application.id, false);
+        quest.updateUserStatus(res);
+
+        console.log(`Spoofed your game to ${applicationName}. Wait for ${Math.ceil((secondsNeeded - secondsDone) / 60)} more minutes.`);
+        await this.timeout(interval * 1000);
+      }
+
+      const res = await this.heartbeat(quest.id, quest.config.application.id, true);
+      quest.updateUserStatus(res);
+      console.log(`Quest "${questName}" completed!`);
+
+    } else if (taskName === 'STREAM_ON_DESKTOP') {
+      console.log('This no longer works in node for non-video quests. Use the discord desktop app to complete the', questName, 'quest!');
+    } else if (taskName === 'PLAY_ACTIVITY') {
+      console.log('This quest not supported. Use the discord desktop app to complete the', questName, 'quest!');
+    } else {
+      console.log('Unknown quest type. Use the discord desktop app to complete the', questName, 'quest!');
+    }
+  }
+
+  /**
+   * Auto-complete all valid quests
+   * @returns {Promise<void>}
+   */
+  async autoCompleteAll() {
+    await this.get(); // Refresh quest data
+    const validQuests = this.filterQuestsValid();
+    
+    for (const quest of validQuests) {
+      try {
+        await this.doingQuest(quest);
+      } catch (error) {
+        console.error(`Failed to complete quest ${quest.id}:`, error);
+      }
+    }
+  }
+
+  /**
+   * Get cache size
+   * @returns {number}
+   */
+  get size() {
+    return this.cache.size;
+  }
+
+  /**
+   * Clear quest cache
+   */
+  clear() {
+    this.cache.clear();
+  }
+
+  /**
+   * Make QuestManager iterable
+   * @returns {IterableIterator<Quest>}
+   */
+  [Symbol.iterator]() {
+    return this.cache.values();
+  }
+}
+
+module.exports = QuestManager;

package/src/structures/ClientUser.js

@@ -447,12 +447,186 @@ class ClientUser extends User {
   }
 
   /**
-   * Set pronouns
-   * @param {?string} pronouns Your pronouns
+   * Add a widget to the user's profile
+   * @param {string} type Widget type (favorite_games, current_games, played_games, want_to_play_games)
+   * @param {string} gameId The game ID to add
+   * @param {string} [comment] Optional comment for the game
+   * @param {string[]} [tags] Optional tags for the game
+   * @returns {Promise<Object>}
+   */
+  async addWidget(type, gameId, comment = null, tags = []) {
+    if (!type || !gameId) {
+      throw new TypeError('Widget type and game ID are required');
+    }
+
+    const validTypes = ['favorite_games', 'current_games', 'played_games', 'want_to_play_games'];
+    if (!validTypes.includes(type)) {
+      throw new TypeError(`Invalid widget type. Must be one of: ${validTypes.join(', ')}`);
+    }
+
+    // Get current widgets first
+    const currentWidgets = await this.widgetsList();
+    
+    // Find existing widget of this type or create new one
+    let targetWidget = currentWidgets.widgets.find(w => w.data.type === type);
+    
+    if (!targetWidget) {
+      // Create new widget if it doesn't exist
+      targetWidget = {
+        id: Date.now().toString(), // Generate temporary ID
+        data: {
+          type: type,
+          games: []
+        }
+      };
+      currentWidgets.widgets.push(targetWidget);
+    }
+
+    // Add the game if it doesn't already exist
+    const existingGame = targetWidget.data.games.find(g => g.game_id === gameId);
+    if (!existingGame) {
+      const gameData = { game_id: gameId };
+      if (comment !== null) gameData.comment = comment;
+      if (tags.length > 0) gameData.tags = tags;
+      
+      targetWidget.data.games.push(gameData);
+    }
+
+    // Update widgets via API
+    return this.client.api.users['@me'].profile.patch({
+      data: { widgets: currentWidgets.widgets }
+    });
+  }
+
+  /**
+   * Delete a widget or remove a game from a widget
+   * @param {string} type Widget type to modify
+   * @param {string} [gameId] Optional game ID to remove (if not provided, removes entire widget)
+   * @returns {Promise<Object>}
+   */
+  async delWidget(type, gameId = null) {
+    if (!type) {
+      throw new TypeError('Widget type is required');
+    }
+
+    const validTypes = ['favorite_games', 'current_games', 'played_games', 'want_to_play_games'];
+    if (!validTypes.includes(type)) {
+      throw new TypeError(`Invalid widget type. Must be one of: ${validTypes.join(', ')}`);
+    }
+
+    // Get current widgets
+    const currentWidgets = await this.widgetsList();
+    
+    if (gameId) {
+      // Remove specific game from widget
+      const targetWidget = currentWidgets.widgets.find(w => w.data.type === type);
+      if (targetWidget) {
+        targetWidget.data.games = targetWidget.data.games.filter(g => g.game_id !== gameId);
+      }
+    } else {
+      // Remove entire widget
+      currentWidgets.widgets = currentWidgets.widgets.filter(w => w.data.type !== type);
+    }
+
+    // Update widgets via API
+    return this.client.api.users['@me'].profile.patch({
+      data: { widgets: currentWidgets.widgets }
+    });
+  }
+
+  /**
+   * Get the list of all widgets for the user
+   * @returns {Promise<Object>} Object containing widgets array
+   */
+  async widgetsList() {
+    try {
+      const data = await this.client.api.users['@me'].profile.get();
+      return data.widgets ? { widgets: data.widgets } : { widgets: [] };
+    } catch (error) {
+      // If profile endpoint doesn't exist or fails, return empty widgets
+      return { widgets: [] };
+    }
+  }
+
+  /**
+   * Set display name style with font, effect, and colors
+   * @param {string|number} fontName Font name or ID
+   * @param {string|number} effectName Effect name or ID  
+   * @param {number|string} color1 Primary color (hex or decimal)
+   * @param {number|string} [color2] Secondary color for gradient effects (hex or decimal)
    * @returns {Promise<ClientUser>}
+   * @example
+   * // Set Sans font with gradient effect
+   * client.user.setNameStyle('Sans', 'Gradient', 7183099, 6082490);
+   * // Set Tempo font with solid effect
+   * client.user.setNameStyle('Tempo', 'Solid', 7183099);
+   * // Using IDs directly
+   * client.user.setNameStyle(11, 2, 7183099, 6082490);
    */
-  setPronouns(pronouns = '') {
-    return this.edit({ pronouns });
+  async setNameStyle(fontName, effectName, color1, color2 = null) {
+    // Font name/ID mapping
+    const fontMap = {
+      'Sans': 11,
+      'Tempo': 12,
+      'Sakura': 3,
+      'JellyBean': 4,
+      'Modern': 6,
+      'Medieval': 7,
+      '8Bit': 8,
+      'Vampire': 10
+    };
+
+    // Effect name/ID mapping
+    const effectMap = {
+      'Solid': 1,
+      'Gradient': 2,
+      'Neon': 3,
+      'Toon': 4,
+      'Pop': 5
+    };
+
+    // Resolve font ID
+    let fontId = typeof fontName === 'string' ? fontMap[fontName] : fontName;
+    if (!fontId) {
+      throw new TypeError(`Invalid font name. Must be one of: ${Object.keys(fontMap).join(', ')} or a valid font ID`);
+    }
+
+    // Resolve effect ID
+    let effectId = typeof effectName === 'string' ? effectMap[effectName] : effectName;
+    if (!effectId) {
+      throw new TypeError(`Invalid effect name. Must be one of: ${Object.keys(effectMap).join(', ')} or a valid effect ID`);
+    }
+
+    // Resolve colors
+    const resolveColor = (color) => {
+      if (typeof color === 'string') {
+        // Handle hex colors
+        if (color.startsWith('#')) {
+          return parseInt(color.slice(1), 16);
+        }
+        return parseInt(color, 16);
+      }
+      return color;
+    };
+
+    const primaryColor = resolveColor(color1);
+    const colors = [primaryColor];
+    
+    if (color2 !== null) {
+      const secondaryColor = resolveColor(color2);
+      colors.push(secondaryColor);
+    }
+
+    // Build the data object
+    const data = {
+      display_name_font_id: fontId,
+      display_name_effect_id: effectId,
+      display_name_colors: colors
+    };
+
+    // Send PATCH request to Discord API
+    await this.client.api.users('@me').patch({ data });
+    return this;
   }
 
   /**

package/src/structures/Guild.js

@@ -1605,6 +1605,60 @@ class Guild extends AnonymousGuild {
     };
   }
 
+  /**
+   * Mute this guild
+   * @param {GuildMuteOptions} [options] Options for muting the guild
+   * @returns {Promise<Object>} The updated guild settings
+   * @example
+   * // Mute the guild with default settings
+   * guild.mute();
+   * @example
+   * // Mute the guild with custom options
+   * guild.mute({
+   *   muted: true,
+   *   suppressRoles: false,
+   *   suppressEveryone: true,
+   *   muteScheduledEvents: false
+   * });
+   */
+  async mute(options = {}) {
+    const {
+      muted = true,
+      suppressRoles = true,
+      suppressEveryone = true,
+      muteScheduledEvents = true
+    } = options;
+
+    const data = await this.client.api.users('@me').guilds(this.id).settings.patch({
+      data: {
+        muted,
+        suppress_roles: suppressRoles,
+        suppress_everyone: suppressEveryone,
+        mute_scheduled_events: muteScheduledEvents
+      }
+    });
+    return data;
+  }
+
+  /**
+   * Unmute this guild
+   * @returns {Promise<Object>} The updated guild settings
+   * @example
+   * // Unmute the guild
+   * guild.unmute();
+   */
+  async unmute() {
+    const data = await this.client.api.users('@me').guilds(this.id).settings.patch({
+      data: {
+        muted: false,
+        suppress_roles: false,
+        suppress_everyone: false,
+        mute_scheduled_events: false
+      }
+    });
+    return data;
+  }
+
   /**
    * Creates a collection of this guild's roles, sorted by their position and ids.
    * @returns {Collection<Snowflake, Role>}

package/src/structures/Presence.js

@@ -800,6 +800,22 @@ class RichPresence extends Activity {
     return this;
   }
 
+  /**
+   * Set the URL of the state of the activity
+   * @param {?string} url The url of the state
+   * @returns {RichPresence}
+   */
+  setStateURL(url){
+    if (!url)
+      throw new Error('Detail URL must be a url');
+
+    if (typeof url !== 'string') throw new Error('Detail URL must be a url');
+    if (!URL.canParse(url)) throw new Error('Detail URL must be a valid url');
+  
+    this.state_url  = url;
+    return this;
+  }
+
   /**
    * Set the details of the activity
    * @param {?string} details The details of the activity
@@ -810,6 +826,22 @@ class RichPresence extends Activity {
     return this;
   }
 
+  /**
+   * Set the URL of the details of the activity
+   * @param {?string} url The url of the details
+   * @returns {RichPresence}
+   */
+  setDetailsURL(url){
+    if (!url)
+      throw new Error('Detail URL must be a url');
+
+    if (typeof url !== 'string') throw new Error('Detail URL must be a url');
+    if (!URL.canParse(url)) throw new Error('Detail URL must be a valid url');
+  
+    this.details_url = url;
+    return this;
+  }
+
   /**
    * @typedef {Object} RichParty
    * @property {string} id The id of the party

package/typings/index.d.ts

@@ -216,7 +216,9 @@ export class RichPresence extends Activity {
   public setType(type?: ActivityType): this;
   public setApplicationId(id?: Snowflake): this;
   public setDetails(details?: string): this;
+  public setDetailsURL(url?: string): this;
   public setState(state?: string): this;
+  public setStateURL(url?: string): this;
   public setParty(party?: { max: number; current: number; id?: string }): this;
   public setStartTimestamp(timestamp: Date | number | null): this;
   public setEndTimestamp(timestamp: Date | number | null): this;
@@ -860,6 +862,7 @@ export class Client<Ready extends boolean = boolean> extends BaseClient {
   public sessions: SessionManager;
   public presences: PresenceManager;
   public billing: BillingManager;
+  public quests: QuestManager;
   public settings: ClientUserSettingManager;
   public readonly sessionId: If<Ready, string, undefined>;
   public destroy(): void;
@@ -980,7 +983,13 @@ export class ClientUser extends User {
   public stopRinging(channel: ChannelResolvable): Promise<void>;
   public fetchBurstCredit(): Promise<number>;
   public setPronouns(pronouns?: string | null): Promise<this>;
+  public setClan(guild?: GuildIDResolve): Promise<this>;
+  public deleteClan(): Promise<this>;
   public setGlobalName(globalName?: string | null): Promise<this>;
+  public addWidget(type: WidgetType, gameId: string, comment?: string | null, tags?: string[]): Promise<any>;
+  public delWidget(type: WidgetType, gameId?: string): Promise<any>;
+  public widgetsList(): Promise<WidgetsResponse>;
+  public setNameStyle(fontName: FontName | number, effectName: EffectName | number, color1: number | string, color2?: number | string | null): Promise<this>;
 }
 
 export class Options extends null {
@@ -1662,6 +1671,8 @@ export class Guild extends AnonymousGuild {
   ): Promise<this>;
   public topEmojis(): Promise<Collection<number, GuildEmoji>>;
   public setVanityCode(code?: string): Promise<this>;
+  public mute(options?: GuildMuteOptions): Promise<any>;
+  public unmute(): Promise<any>;
 }
 
 export class GuildAuditLogs<T extends GuildAuditLogsResolvable = 'ALL'> {
@@ -2637,6 +2648,29 @@ export class BillingManager extends BaseManager {
   public fetchCurrentSubscription(): Promise<Collection<Snowflake, object>>;
 }
 
+export class QuestManager extends BaseManager {
+  constructor(client: Client);
+  public cache: Collection<string, Quest>;
+  public get(): Promise<QuestData>;
+  public orbs(): Promise<OrbsData>;
+  public getQuest(id: string): Quest | undefined;
+  public list(): Quest[];
+  public getExpired(date?: Date): Quest[];
+  public getCompleted(): Quest[];
+  public getClaimable(): Quest[];
+  public filterQuestsValid(): Quest[];
+  public hasQuest(id: string): boolean;
+  public getApplicationData(ids: string[]): Promise<ApplicationData[]>;
+  public acceptQuest(questId: string, options?: QuestEnrollOptions): Promise<Quest | undefined>;
+  public videoProgress(questId: string, timestamp: number): Promise<any>;
+  public heartbeat(questId: string, applicationId: string, terminal?: boolean): Promise<any>;
+  public doingQuest(quest: Quest): Promise<void>;
+  public autoCompleteAll(): Promise<void>;
+  public readonly size: number;
+  public clear(): void;
+  public [Symbol.iterator](): IterableIterator<Quest>;
+}
+
 export class Session extends Base {
   constructor(client: Client);
   public id?: string;
@@ -3739,6 +3773,117 @@ export interface Collectibles {
   nameplate: NameplateData | null;
 }
 
+export type WidgetType = 'favorite_games' | 'current_games' | 'played_games' | 'want_to_play_games';
+
+export interface WidgetGameData {
+  game_id: string;
+  comment?: string | null;
+  tags?: string[];
+}
+
+export interface WidgetData {
+  id: string;
+  data: {
+    type: WidgetType;
+    games: WidgetGameData[];
+  };
+}
+
+export interface WidgetsResponse {
+  widgets: WidgetData[];
+}
+
+export interface QuestEnrollOptions {
+  location?: number;
+  isTargeted?: boolean;
+  metadataRaw?: any;
+}
+
+export interface QuestTaskConfig {
+  tasks?: {
+    WATCH_VIDEO?: { target: number };
+    WATCH_VIDEO_ON_MOBILE?: { target: number };
+    PLAY_ON_DESKTOP?: { target: number };
+    STREAM_ON_DESKTOP?: { target: number };
+    PLAY_ACTIVITY?: { target: number };
+  };
+}
+
+export interface QuestUserStatus {
+  enrolled_at?: string;
+  completed_at?: string;
+  claimed_at?: string;
+  progress?: {
+    WATCH_VIDEO?: { value: number };
+    WATCH_VIDEO_ON_MOBILE?: { value: number };
+    PLAY_ON_DESKTOP?: { value: number };
+    STREAM_ON_DESKTOP?: { value: number };
+    PLAY_ACTIVITY?: { value: number };
+  };
+}
+
+export interface QuestConfig {
+  expires_at?: string;
+  messages?: {
+    quest_name?: string;
+  };
+  application?: {
+    id: string;
+    name: string;
+  };
+  task_config: QuestTaskConfig;
+  task_config_v2?: QuestTaskConfig;
+}
+
+export interface QuestRawData {
+  id: string;
+  config: QuestConfig;
+  user_status?: QuestUserStatus;
+}
+
+export class Quest {
+  constructor(data: QuestRawData);
+  public id: string;
+  public config: QuestConfig;
+  public userStatus?: QuestUserStatus;
+  public isExpired(date?: Date): boolean;
+  public isCompleted(): boolean;
+  public hasClaimedRewards(): boolean;
+  public isEnrolledQuest(): boolean;
+  public updateUserStatus(status: Partial<QuestUserStatus>): void;
+}
+
+export interface QuestData {
+  quests?: QuestRawData[];
+}
+
+export interface OrbsData {
+  balance?: number;
+}
+
+export interface ApplicationData {
+  id: string;
+  name: string;
+  icon: string;
+  description: string;
+  executables: {
+    os: string;
+    name: string;
+    is_launcher: boolean;
+  }[];
+}
+
+export type FontName = 'Sans' | 'Tempo' | 'Sakura' | 'JellyBean' | 'Modern' | 'Medieval' | '8Bit' | 'Vampire';
+
+export type EffectName = 'Solid' | 'Gradient' | 'Neon' | 'Toon' | 'Pop';
+
+export interface GuildMuteOptions {
+  muted?: boolean;
+  suppressRoles?: boolean;
+  suppressEveryone?: boolean;
+  muteScheduledEvents?: boolean;
+}
+
 export class User extends PartialTextBasedChannel(Base) {
   protected constructor(client: Client, data: RawUserData);
   private _equals(user: APIUser): boolean;