discord-sb.js 1.0.1 → 1.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "discord-sb.js",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "An unofficial discord.js fork for creating selfbots",
   "main": "./src/index.js",
   "types": "./typings/index.d.ts",

package/src/WebSocket.js

@@ -8,7 +8,7 @@ try {
   if (!erlpack.pack) erlpack = null;
 } catch {} // eslint-disable-line no-empty
 
-exports.WebSocket = WebSocket;
+exports.WebSocket = WebSocket; // eslint-disable-line
 
 const ab = new TextDecoder();
 

package/src/client/Client.js

@@ -457,6 +457,31 @@ class Client extends BaseClient {
     return regions;
   }
 
+  /**
+   * Requests a sync of guild data with Discord. Only works for user accounts.
+   * @param {Guild[]|Collection<Snowflake, Guild>} [guilds=this.guilds] Guilds to sync
+   * @returns {void}
+   */
+  syncGuilds(guilds = this.guilds) {
+    if (this.user?.bot) return;
+    // Avoid rebuilding arrays if already mapped once
+    const ids = guilds instanceof Collection ? guilds.map((_, id) => id) : guilds.map(g => g.id);
+    this.ws.send({
+      op: 12,
+      d: ids,
+    });
+  }
+
+  /**
+   * Obtains a user from Discord, or the user cache if it's already available.
+   * @param {UserResolvable} user The user to fetch
+   * @param {BaseFetchOptions} [options] Additional options for this fetch
+   * @returns {Promise<User>}
+   */
+  fetchUser(user, options = {}) {
+    return this.users.fetch(user, options);
+  }
+
   /**
    * Obtains a sticker from Discord.
    * @param {Snowflake} id The sticker's id
@@ -812,34 +837,37 @@ class Client extends BaseClient {
   /**
    * Install User Apps
    * @param {Snowflake} applicationId  Discord Application id
-   * @returns {Promise<void>}
-   */
-  installUserApps(applicationId) {
-    return this.api
-      .applications(applicationId)
-      .public.get({
-        query: {
-          with_guild: false,
+   * @param {string[]|string} [scopes=['applications.commands']] OAuth scopes to request when installing
+   * @returns {Promise<boolean>}
+   */
+  async installUserApps(applicationId, scopes = ['applications.commands']) {
+    const scope = Array.isArray(scopes) ? scopes.join(' ') : scopes;
+    await this.api.oauth2.authorize.post({
+      query: {
+        client_id: applicationId,
+        scope,
+      },
+      data: {
+        permissions: '0',
+        authorize: true,
+        integration_type: 1,
+        dm_settings: {
+          allow_mobile_push: false,
         },
-      })
-      .then(rawData => {
-        const installTypes = rawData.integration_types_config['1'];
-        if (installTypes) {
-          return this.api.oauth2.authorize.post({
-            query: {
-              client_id: applicationId,
-              scope: installTypes.oauth2_install_params.scopes.join(' '),
-            },
-            data: {
-              permissions: '0',
-              authorize: true,
-              integration_type: 1,
-            },
-          });
-        } else {
-          return false;
-        }
-      });
+      },
+    });
+
+    return true;
+  }
+
+  /**
+   * Uninstall a previously authorized user application.
+   * @param {Snowflake} applicationId Discord Application id
+   * @returns {Promise<boolean>}
+   */
+  async unInstallUserApp(applicationId) {
+    await this.api.oauth2.tokens(applicationId).delete();
+    return true;
   }
 
   /**

package/src/managers/DeveloperManager.js

@@ -10,10 +10,6 @@ const DataResolver = require('../util/DataResolver');
  * @extends {BaseManager}
  */
 class DeveloperManager extends BaseManager {
-  constructor(client) {
-    super(client);
-  }
-
   /**
    * Fetches all applications owned by the current user
    * @param {boolean} [withTeamApplications=true] Whether to include team applications
@@ -81,15 +77,30 @@ class DeveloperManager extends BaseManager {
   async edit(applicationId, data) {
     const _data = {};
 
-    if (data.name) _data.name = data.name;
-    if (data.description !== undefined) _data.description = data.description;
-    if (data.icon !== undefined) _data.icon = await DataResolver.resolveImage(data.icon);
-    if (data.tags) _data.tags = data.tags;
-    if (data.interactionsEndpointUrl !== undefined) _data.interactions_endpoint_url = data.interactionsEndpointUrl;
-    if (data.roleConnectionsVerificationUrl !== undefined)
+    if (data.name) {
+      _data.name = data.name;
+    }
+    if (data.description !== undefined) {
+      _data.description = data.description;
+    }
+    if (data.icon !== undefined) {
+      _data.icon = await DataResolver.resolveImage(data.icon);
+    }
+    if (data.tags) {
+      _data.tags = data.tags;
+    }
+    if (data.interactionsEndpointUrl !== undefined) {
+      _data.interactions_endpoint_url = data.interactionsEndpointUrl;
+    }
+    if (data.roleConnectionsVerificationUrl !== undefined) {
       _data.role_connections_verification_url = data.roleConnectionsVerificationUrl;
-    if (data.termsOfServiceUrl !== undefined) _data.terms_of_service_url = data.termsOfServiceUrl;
-    if (data.privacyPolicyUrl !== undefined) _data.privacy_policy_url = data.privacyPolicyUrl;
+    }
+    if (data.termsOfServiceUrl !== undefined) {
+      _data.terms_of_service_url = data.termsOfServiceUrl;
+    }
+    if (data.privacyPolicyUrl !== undefined) {
+      _data.privacy_policy_url = data.privacyPolicyUrl;
+    }
 
     const result = await this.client.api.applications(applicationId).patch({ data: _data });
     return new Application(this.client, result);

package/src/managers/QuestManager.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const { setTimeout } = require('node:timers');
 const { Collection } = require('@discordjs/collection');
 const BaseManager = require('./BaseManager');
 
@@ -90,6 +91,14 @@ class QuestManager extends BaseManager {
     return data;
   }
 
+  /**
+   * Refresh the quest cache from the API
+   * @returns {Promise<Object>} Latest quest data
+   */
+  async refreshCache() {
+    return this.get();
+  }
+
   /**
    * Get user's orb balance (virtual currency)
    * @returns {Promise<Object>} Balance data
@@ -197,19 +206,22 @@ class QuestManager extends BaseManager {
       quest.updateUserStatus(data);
     }
 
-    return quest;
+    await this.refreshCache();
+    return this.getQuest(questId);
   }
 
   /**
    * Update progress for a video quest
    * @param {string} questId The quest ID
    * @param {number} timestamp Current progress timestamp
+   * @param {boolean} [refresh=true] Whether to refresh the quest cache after the update
    * @returns {Promise<Object>} Progress update result
    */
-  async videoProgress(questId, timestamp) {
+  async videoProgress(questId, timestamp, refresh = true) {
     const data = await this.client.api.quests(questId)['video-progress'].post({
       data: { timestamp },
     });
+    if (refresh) await this.refreshCache();
     return data;
   }
 
@@ -218,15 +230,17 @@ class QuestManager extends BaseManager {
    * @param {string} questId The quest ID
    * @param {string} applicationId Application ID
    * @param {boolean} [terminal=false] Whether this is a terminal heartbeat
+   * @param {boolean} [refresh=true] Whether to refresh the quest cache after the update
    * @returns {Promise<Object>} Heartbeat result
    */
-  async heartbeat(questId, applicationId, terminal = false) {
+  async heartbeat(questId, applicationId, terminal = false, refresh = true) {
     const data = await this.client.api.quests(questId).heartbeat.post({
       data: {
         application_id: applicationId,
         terminal,
       },
     });
+    if (refresh) await this.refreshCache();
     return data;
   }
 
@@ -260,25 +274,28 @@ class QuestManager extends BaseManager {
       'WATCH_VIDEO_ON_MOBILE',
     ].find(x => taskConfig.tasks?.[x] != null);
 
-    if (!taskName) return console.log(`Unknown task type for quest "${questName}"`);
+    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') {
+      let secondsDone = quest.userStatus?.progress?.[taskName]?.value ?? 0;
       const maxFuture = 10;
       const speed = 7;
       const interval = 1;
       const enrolledAt = new Date(quest.userStatus?.enrolled_at).getTime();
       let completed = false;
 
-      while (true) {
+      while (!completed && secondsDone < secondsNeeded) {
         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()));
+          const res = await this.videoProgress(quest.id, Math.min(secondsNeeded, timestamp + Math.random()), false);
           completed = res.completed_at != null;
           secondsDone = Math.min(secondsNeeded, timestamp);
         }
@@ -291,22 +308,23 @@ class QuestManager extends BaseManager {
       }
 
       if (!completed) {
-        await this.videoProgress(quest.id, secondsNeeded);
+        await this.videoProgress(quest.id, secondsNeeded, false);
       }
     } 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);
+        const res = await this.heartbeat(quest.id, quest.config.application.id, false, false);
         quest.updateUserStatus(res);
 
         await this.timeout(interval * 1000);
       }
 
-      const res = await this.heartbeat(quest.id, quest.config.application.id, true);
+      const res = await this.heartbeat(quest.id, quest.config.application.id, true, false);
       quest.updateUserStatus(res);
     }
+
+    await this.refreshCache();
   }
 
   /**

package/src/managers/RelationshipManager.js

@@ -14,6 +14,10 @@ const { RelationshipTypes } = require('../util/Constants');
 class RelationshipManager extends BaseManager {
   constructor(client, users) {
     super(client);
+    this._friendCache = new Collection();
+    this._blockedCache = new Collection();
+    this._incomingCache = new Collection();
+    this._outgoingCache = new Collection();
     /**
      * A collection of users this manager is caching. (Type: Number)
      * @type {Collection<Snowflake, RelationshipType>}
@@ -36,10 +40,7 @@ class RelationshipManager extends BaseManager {
    * @readonly
    */
   get friendCache() {
-    const users = this.cache
-      .filter(value => value === RelationshipTypes.FRIEND)
-      .map((_, key) => [key, this.client.users.cache.get(key)]);
-    return new Collection(users);
+    return this._friendCache;
   }
 
   /**
@@ -48,10 +49,7 @@ class RelationshipManager extends BaseManager {
    * @readonly
    */
   get blockedCache() {
-    const users = this.cache
-      .filter(value => value === RelationshipTypes.BLOCKED)
-      .map((_, key) => [key, this.client.users.cache.get(key)]);
-    return new Collection(users);
+    return this._blockedCache;
   }
 
   /**
@@ -60,10 +58,7 @@ class RelationshipManager extends BaseManager {
    * @readonly
    */
   get incomingCache() {
-    const users = this.cache
-      .filter(value => value === RelationshipTypes.PENDING_INCOMING)
-      .map((_, key) => [key, this.client.users.cache.get(key)]);
-    return new Collection(users);
+    return this._incomingCache;
   }
 
   /**
@@ -72,10 +67,7 @@ class RelationshipManager extends BaseManager {
    * @readonly
    */
   get outgoingCache() {
-    const users = this.cache
-      .filter(value => value === RelationshipTypes.PENDING_OUTGOING)
-      .map((_, key) => [key, this.client.users.cache.get(key)]);
-    return new Collection(users);
+    return this._outgoingCache;
   }
 
   /**
@@ -106,10 +98,20 @@ class RelationshipManager extends BaseManager {
    */
   _setup(users) {
     if (!Array.isArray(users)) return;
+    // Reset caches so full fetches don't leave stale relationships behind
+    this.cache.clear();
+    this.friendNicknames.clear();
+    this.sinceCache.clear();
+    this._friendCache.clear();
+    this._blockedCache.clear();
+    this._incomingCache.clear();
+    this._outgoingCache.clear();
     for (const relationShip of users) {
+      if (relationShip.user) this.client.users._add(relationShip.user);
       this.friendNicknames.set(relationShip.id, relationShip.nickname);
       this.cache.set(relationShip.id, relationShip.type);
       this.sinceCache.set(relationShip.id, new Date(relationShip.since || 0));
+      this._updateRelationshipCaches(relationShip.id, relationShip.type);
     }
   }
 
@@ -123,7 +125,8 @@ class RelationshipManager extends BaseManager {
     if (user instanceof GuildMember) return user.user.id;
     if (user instanceof Message) return user.author.id;
     if (user instanceof User) return user.id;
-    return user.match(/\d{17,19}/)?.[0] || null;
+    if (typeof user === 'string') return user.match(/\d{17,19}/)?.[0] || null;
+    return null;
   }
 
   /**
@@ -152,12 +155,28 @@ class RelationshipManager extends BaseManager {
         const existing = this.cache.get(id);
         if (existing && !existing.partial) return existing;
       }
-      const data = await this.client.api.users['@me'].relationships.get();
-      await this._setup(data);
-      return this.cache.get(id);
+      // Try incremental hydrate: if user already cached, avoid full sync
+      if (this.cache.has(id)) return this.cache.get(id);
+      const data = await this.client.api.users['@me']
+        .relationships(id)
+        .get()
+        .catch(() => null);
+      if (data) {
+        const type = data.type ?? RelationshipTypes.NONE;
+        this.cache.set(id, type);
+        this.friendNicknames.set(id, data.nickname);
+        this.sinceCache.set(id, new Date(data.since || 0));
+        this._updateRelationshipCaches(id, type);
+        if (data.user) this.client.users._add(data.user);
+        return type;
+      }
+      // Fallback: full refresh
+      const list = await this.client.api.users['@me'].relationships.get();
+      this._setup(list);
+      return this.cache.get(id) ?? null;
     } else {
       const data = await this.client.api.users['@me'].relationships.get();
-      await this._setup(data);
+      this._setup(data);
       return this;
     }
   }
@@ -168,19 +187,25 @@ class RelationshipManager extends BaseManager {
    * @returns {Promise<boolean>}
    */
   async deleteRelationship(user) {
-    throw new Error('Risky action, not finished yet.');
-    // eslint-disable-next-line no-unreachable
     const id = this.resolveId(user);
+    if (!id) return false;
     if (
-      ![RelationshipTypes.FRIEND, RelationshipTypes.BLOCKED, RelationshipTypes.PENDING_OUTGOING].includes(
-        this.cache.get(id),
-      )
+      ![
+        RelationshipTypes.FRIEND,
+        RelationshipTypes.BLOCKED,
+        RelationshipTypes.PENDING_OUTGOING,
+        RelationshipTypes.PENDING_INCOMING,
+      ].includes(this.cache.get(id))
     ) {
       return Promise.resolve(false);
     }
     await this.client.api.users['@me'].relationships[id].delete({
       DiscordContext: { location: 'ContextMenu' },
     });
+    this.cache.delete(id);
+    this.friendNicknames.delete(id);
+    this.sinceCache.delete(id);
+    this._updateRelationshipCaches(id, RelationshipTypes.NONE);
     return true;
   }
 
@@ -190,16 +215,21 @@ class RelationshipManager extends BaseManager {
    * @returns {Promise<boolean>}
    */
   async sendFriendRequest(options) {
-    throw new Error('Risky action, not finished yet.');
-    // eslint-disable-next-line no-unreachable
     const id = this.resolveId(options);
     if (id) {
+      if ([RelationshipTypes.FRIEND, RelationshipTypes.PENDING_OUTGOING].includes(this.cache.get(id))) {
+        return Promise.resolve(false);
+      }
       await this.client.api.users['@me'].relationships[id].put({
         data: {},
         DiscordContext: { location: 'ContextMenu' },
       });
+      this.cache.set(id, RelationshipTypes.PENDING_OUTGOING);
+      this.sinceCache.set(id, new Date());
+      this._updateRelationshipCaches(id, RelationshipTypes.PENDING_OUTGOING);
     } else {
       const username = this.resolveUsername(options);
+      if (typeof username !== 'string') return false;
       await this.client.api.users['@me'].relationships.post({
         versioned: true,
         data: {
@@ -218,9 +248,8 @@ class RelationshipManager extends BaseManager {
    * @returns {Promise<boolean>}
    */
   async addFriend(user) {
-    throw new Error('Risky action, not finished yet.');
-    // eslint-disable-next-line no-unreachable
     const id = this.resolveId(user);
+    if (!id) return false;
     // Check if already friends
     if (this.cache.get(id) === RelationshipTypes.FRIEND) return Promise.resolve(false);
     // Check if outgoing request
@@ -229,6 +258,9 @@ class RelationshipManager extends BaseManager {
       data: { confirm_stranger_request: true },
       DiscordContext: { location: 'Friends' },
     });
+    this.cache.set(id, RelationshipTypes.FRIEND);
+    this.sinceCache.set(id, new Date());
+    this._updateRelationshipCaches(id, RelationshipTypes.FRIEND);
     return true;
   }
 
@@ -260,9 +292,8 @@ class RelationshipManager extends BaseManager {
    * @returns {Promise<boolean>}
    */
   async addBlocked(user) {
-    throw new Error('Risky action, not finished yet.');
-    // eslint-disable-next-line no-unreachable
     const id = this.resolveId(user);
+    if (!id) return false;
     // Check
     if (this.cache.get(id) === RelationshipTypes.BLOCKED) return Promise.resolve(false);
     await this.client.api.users['@me'].relationships[id].put({
@@ -271,8 +302,30 @@ class RelationshipManager extends BaseManager {
       },
       DiscordContext: { location: 'ContextMenu' },
     });
+    this.cache.set(id, RelationshipTypes.BLOCKED);
+    this.friendNicknames.delete(id);
+    this.sinceCache.set(id, new Date());
+    this._updateRelationshipCaches(id, RelationshipTypes.BLOCKED);
     return true;
   }
+
+  _updateRelationshipCaches(id, type) {
+    this._friendCache.delete(id);
+    this._blockedCache.delete(id);
+    this._incomingCache.delete(id);
+    this._outgoingCache.delete(id);
+    const user = this.client.users.cache.get(id);
+    if (!user) return;
+    if (type === RelationshipTypes.FRIEND) {
+      this._friendCache.set(id, user);
+    } else if (type === RelationshipTypes.BLOCKED) {
+      this._blockedCache.set(id, user);
+    } else if (type === RelationshipTypes.PENDING_INCOMING) {
+      this._incomingCache.set(id, user);
+    } else if (type === RelationshipTypes.PENDING_OUTGOING) {
+      this._outgoingCache.set(id, user);
+    }
+  }
 }
 
 module.exports = RelationshipManager;

package/src/structures/ClientUser.js

@@ -4,10 +4,10 @@ const { setInterval } = require('node:timers');
 const { Collection } = require('@discordjs/collection');
 const Invite = require('./Invite');
 const User = require('./User');
+const { Error, TypeError } = require('../errors');
 const DataResolver = require('../util/DataResolver');
 const PremiumUsageFlags = require('../util/PremiumUsageFlags');
 const PurchasedFlags = require('../util/PurchasedFlags');
-const { Error, TypeError } = require('../errors');
 const Util = require('../util/Util');
 
 /**
@@ -117,6 +117,46 @@ class ClientUser extends User {
     }
   }
 
+  /**
+   * A collection of friends for the logged in user (user accounts only).
+   * @type {Collection<Snowflake, User>}
+   * @readonly
+   * @deprecated Use {@link Client#relationships} for the full API surface.
+   */
+  get friends() {
+    return this.client.relationships.friendCache;
+  }
+
+  /**
+   * A collection of blocked users for the logged in user (user accounts only).
+   * @type {Collection<Snowflake, User>}
+   * @readonly
+   * @deprecated Use {@link Client#relationships} for the full API surface.
+   */
+  get blocked() {
+    return this.client.relationships.blockedCache;
+  }
+
+  /**
+   * A collection of pending incoming friend requests for the logged in user (user accounts only).
+   * @type {Collection<Snowflake, User>}
+   * @readonly
+   * @deprecated Use {@link Client#relationships} for the full API surface.
+   */
+  get pending() {
+    return this.client.relationships.incomingCache;
+  }
+
+  /**
+   * A collection of outgoing friend requests for the logged in user (user accounts only).
+   * @type {Collection<Snowflake, User>}
+   * @readonly
+   * @deprecated Use {@link Client#relationships} for the full API surface.
+   */
+  get outgoing() {
+    return this.client.relationships.outgoingCache;
+  }
+
   /**
    * Represents the client user's presence
    * @type {ClientPresence}

package/src/structures/Guild.js

@@ -1746,7 +1746,7 @@ class Guild extends AnonymousGuild {
     const data = await this.client.api.guilds(this.id).messages.search.get({ query });
 
     if (limit && data.messages) {
-      // data.messages est souvent un tableau de tableaux dans l'API search
+      // Data.messages est souvent un tableau de tableaux dans l'API search
       data.messages = data.messages.flat().slice(0, limit);
     }
 

package/typings/enums.d.ts

@@ -333,8 +333,6 @@ export enum NameplatePalette {
   White = 'white',
 }
 
-
-
 export const enum OverwriteTypes {
   role = 0,
   member = 1,
@@ -437,3 +435,103 @@ export const enum ApplicationType {
    */
   CREATOR_MONETIZATION = 4,
 }
+
+export enum ClientEvents {
+  RateLimit = 'rateLimit',
+  InvalidRequestWarning = 'invalidRequestWarning',
+  ApiResponse = 'apiResponse',
+  ApiRequest = 'apiRequest',
+  ClientReady = 'ready',
+  ApplicationCommandCreate = 'applicationCommandCreate',
+  ApplicationCommandDelete = 'applicationCommandDelete',
+  ApplicationCommandUpdate = 'applicationCommandUpdate',
+  ApplicationCommandPermissionsUpdate = 'applicationCommandPermissionsUpdate',
+  AutoModerationActionExecution = 'autoModerationActionExecution',
+  AutoModerationRuleCreate = 'autoModerationRuleCreate',
+  AutoModerationRuleDelete = 'autoModerationRuleDelete',
+  AutoModerationRuleUpdate = 'autoModerationRuleUpdate',
+  GuildAvailable = 'guildAvailable',
+  GuildCreate = 'guildCreate',
+  GuildDelete = 'guildDelete',
+  GuildUpdate = 'guildUpdate',
+  GuildUnavailable = 'guildUnavailable',
+  GuildMemberAdd = 'guildMemberAdd',
+  GuildMemberRemove = 'guildMemberRemove',
+  GuildMemberUpdate = 'guildMemberUpdate',
+  GuildMemberAvailable = 'guildMemberAvailable',
+  GuildMembersChunk = 'guildMembersChunk',
+  GuildIntegrationsUpdate = 'guildIntegrationsUpdate',
+  GuildRoleCreate = 'roleCreate',
+  GuildRoleDelete = 'roleDelete',
+  InviteCreate = 'inviteCreate',
+  InviteDelete = 'inviteDelete',
+  GuildRoleUpdate = 'roleUpdate',
+  GuildEmojiCreate = 'emojiCreate',
+  GuildEmojiDelete = 'emojiDelete',
+  GuildEmojiUpdate = 'emojiUpdate',
+  GuildBanAdd = 'guildBanAdd',
+  GuildBanRemove = 'guildBanRemove',
+  ChannelCreate = 'channelCreate',
+  ChannelDelete = 'channelDelete',
+  ChannelUpdate = 'channelUpdate',
+  ChannelPinsUpdate = 'channelPinsUpdate',
+  MessageCreate = 'messageCreate',
+  MessageDelete = 'messageDelete',
+  MessageUpdate = 'messageUpdate',
+  MessageBulkDelete = 'messageDeleteBulk',
+  MessageReactionAdd = 'messageReactionAdd',
+  MessageReactionRemove = 'messageReactionRemove',
+  MessageReactionRemoveAll = 'messageReactionRemoveAll',
+  MessageReactionRemoveEmoji = 'messageReactionRemoveEmoji',
+  ThreadCreate = 'threadCreate',
+  ThreadDelete = 'threadDelete',
+  ThreadUpdate = 'threadUpdate',
+  ThreadListSync = 'threadListSync',
+  ThreadMemberUpdate = 'threadMemberUpdate',
+  ThreadMembersUpdate = 'threadMembersUpdate',
+  UserUpdate = 'userUpdate',
+  PresenceUpdate = 'presenceUpdate',
+  VoiceServerUpdate = 'voiceServerUpdate',
+  VoiceStateUpdate = 'voiceStateUpdate',
+  TypingStart = 'typingStart',
+  WebhooksUpdate = 'webhookUpdate',
+  Error = 'error',
+  Warn = 'warn',
+  Debug = 'debug',
+  CacheSweep = 'cacheSweep',
+  ShardDisconnect = 'shardDisconnect',
+  ShardError = 'shardError',
+  ShardReconnecting = 'shardReconnecting',
+  ShardReady = 'shardReady',
+  ShardResume = 'shardResume',
+  Invalidated = 'invalidated',
+  Raw = 'raw',
+  StageInstanceCreate = 'stageInstanceCreate',
+  StageInstanceUpdate = 'stageInstanceUpdate',
+  StageInstanceDelete = 'stageInstanceDelete',
+  GuildStickerCreate = 'stickerCreate',
+  GuildStickerDelete = 'stickerDelete',
+  GuildStickerUpdate = 'stickerUpdate',
+  GuildScheduledEventCreate = 'guildScheduledEventCreate',
+  GuildScheduledEventUpdate = 'guildScheduledEventUpdate',
+  GuildScheduledEventDelete = 'guildScheduledEventDelete',
+  GuildScheduledEventUserAdd = 'guildScheduledEventUserAdd',
+  GuildScheduledEventUserRemove = 'guildScheduledEventUserRemove',
+  GuildAuditLogEntryCreate = 'guildAuditLogEntryCreate',
+  UnhandledPacket = 'unhandledPacket',
+  RelationshipAdd = 'relationshipAdd',
+  RelationshipUpdate = 'relationshipUpdate',
+  RelationshipRemove = 'relationshipRemove',
+  ChannelRecipientAdd = 'channelRecipientAdd',
+  ChannelRecipientRemove = 'channelRecipientRemove',
+  InteractionCreate = 'interactionCreate',
+  InteractionModalCreate = 'interactionModalCreate',
+  CallCreate = 'callCreate',
+  CallUpdate = 'callUpdate',
+  CallDelete = 'callDelete',
+  MessagePollVoteAdd = 'messagePollVoteAdd',
+  MessagePollVoteRemove = 'messagePollVoteRemove',
+  VoiceChannelEffectSend = 'voiceChannelEffectSend',
+  VoiceBroadcastSubscribe = 'subscribe',
+  VoiceBroadcastUnsubscribe = 'unsubscribe',
+}

package/typings/index.d.ts

@@ -889,6 +889,9 @@ export class Client<Ready extends boolean = boolean> extends BaseClient {
   public fetchGuildWidget(guild: GuildResolvable): Promise<Widget>;
   public refreshAttachmentURL(...urls: string[]): Promise<{ original: string; refreshed: string }[]>;
   public sleep(timeout: number): Promise<void>;
+  /** @deprecated User accounts only */
+  public syncGuilds(guilds?: Guild[] | Collection<Snowflake, Guild>): void;
+  public fetchUser(user: UserResolvable, options?: BaseFetchOptions): Promise<User>;
   public login(token?: string): Promise<string>;
   /** @deprecated This method will not be updated until I find the most convenient way to implement MFA. */
   public passLogin(email: string, password: string): Promise<string | null>;
@@ -904,7 +907,8 @@ export class Client<Ready extends boolean = boolean> extends BaseClient {
   ): Promise<Guild | DMChannel | GroupDMChannel>;
   public redeemNitro(nitro: string, channel?: TextChannelResolvable, paymentSourceId?: Snowflake): Promise<any>;
   public authorizeURL(urlOAuth2: string, options?: OAuth2AuthorizeOptions): Promise<{ location: string }>;
-  public installUserApps(applicationId: Snowflake): Promise<void>;
+  public installUserApps(applicationId: Snowflake, scopes?: string[] | string): Promise<boolean>;
+  public unInstallUserApp(applicationId: Snowflake): Promise<boolean>;
   public deauthorize(id: Snowflake, type?: 'application' | 'token'): Promise<void>;
   public authorizedApplications(): Promise<
     Collection<
@@ -1003,6 +1007,10 @@ export class ClientUser extends User {
   public setActivity(name: string, options?: Omit<ActivityOptions, 'name'>): ClientPresence;
   public setAFK(afk?: boolean, shardId?: number | number[]): ClientPresence;
   public setAvatar(avatar: BufferResolvable | Base64Resolvable | null): Promise<this>;
+  public readonly friends: Collection<Snowflake, User>;
+  public readonly blocked: Collection<Snowflake, User>;
+  public readonly pending: Collection<Snowflake, User>;
+  public readonly outgoing: Collection<Snowflake, User>;
   public setPresence(data: PresenceData): ClientPresence;
   public setStatus(status: PresenceStatusData, shardId?: number | number[]): ClientPresence;
   public setUsername(username: string, password: string): Promise<this>;
@@ -1033,7 +1041,12 @@ export class ClientUser extends User {
   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>;
+  public setNameStyle(
+    fontName: FontName | number,
+    effectName: EffectName | number,
+    color1: number | string,
+    color2?: number | string | null,
+  ): Promise<this>;
 }
 
 export class Options extends null {