discord.js-seflbot-v13 1.1.0

package/src/util/Sweepers.js

@@ -0,0 +1,466 @@
+'use strict';
+
+const { setInterval } = require('node:timers');
+const { Events, ThreadChannelTypes, SweeperKeys } = require('./Constants');
+const { TypeError } = require('../errors/DJSError.js');
+
+/**
+ * @typedef {Function} GlobalSweepFilter
+ * @returns {Function|null} Return `null` to skip sweeping, otherwise a function passed to `sweep()`,
+ * See {@link [Collection#sweep](https://discord.js.org/docs/packages/collection/stable/Collection:Class?scrollTo=sweep)}
+ * for the definition of this function.
+ */
+
+/**
+ * A container for all cache sweeping intervals and their associated sweep methods.
+ */
+class Sweepers {
+  constructor(client, options) {
+    /**
+     * The client that instantiated this
+     * @type {Client}
+     * @readonly
+     */
+    Object.defineProperty(this, 'client', { value: client });
+
+    /**
+     * The options the sweepers were instantiated with
+     * @type {SweeperOptions}
+     */
+    this.options = options;
+
+    /**
+     * A record of interval timeout that is used to sweep the indicated items, or null if not being swept
+     * @type {Object<SweeperKey, ?Timeout>}
+     */
+    this.intervals = Object.fromEntries(SweeperKeys.map(key => [key, null]));
+
+    for (const key of SweeperKeys) {
+      if (!(key in options)) continue;
+
+      this._validateProperties(key);
+
+      const clonedOptions = { ...this.options[key] };
+
+      // Handle cases that have a "lifetime"
+      if (!('filter' in clonedOptions)) {
+        switch (key) {
+          case 'invites':
+            clonedOptions.filter = this.constructor.expiredInviteSweepFilter(clonedOptions.lifetime);
+            break;
+          case 'messages':
+            clonedOptions.filter = this.constructor.outdatedMessageSweepFilter(clonedOptions.lifetime);
+            break;
+          case 'threads':
+            clonedOptions.filter = this.constructor.archivedThreadSweepFilter(clonedOptions.lifetime);
+        }
+      }
+
+      this._initInterval(key, `sweep${key[0].toUpperCase()}${key.slice(1)}`, clonedOptions);
+    }
+  }
+
+  /**
+   * Sweeps all guild and global application commands and removes the ones which are indicated by the filter.
+   * @param {Function} filter The function used to determine which commands will be removed from the caches.
+   * @returns {number} Amount of commands that were removed from the caches
+   */
+  sweepApplicationCommands(filter) {
+    const { guilds, items: guildCommands } = this._sweepGuildDirectProp('commands', filter, { emit: false });
+
+    const globalCommands = this.client.application?.commands.cache.sweep(filter) ?? 0;
+
+    this.client.emit(
+      Events.CACHE_SWEEP,
+      `Swept ${globalCommands} global application commands and ${guildCommands} guild commands in ${guilds} guilds.`,
+    );
+    return guildCommands + globalCommands;
+  }
+
+  /**
+   * Sweeps all auto moderation rules and removes the ones which are indicated by the filter.
+   * @param {Function} filter The function used to determine
+   * which auto moderation rules will be removed from the caches
+   * @returns {number} Amount of auto moderation rules that were removed from the caches
+   */
+  sweepAutoModerationRules(filter) {
+    return this._sweepGuildDirectProp('autoModerationRules', filter).items;
+  }
+
+  /**
+   * Sweeps all guild bans and removes the ones which are indicated by the filter.
+   * @param {Function} filter The function used to determine which bans will be removed from the caches.
+   * @returns {number} Amount of bans that were removed from the caches
+   */
+  sweepBans(filter) {
+    return this._sweepGuildDirectProp('bans', filter).items;
+  }
+
+  /**
+   * Sweeps all guild emojis and removes the ones which are indicated by the filter.
+   * @param {Function} filter The function used to determine which emojis will be removed from the caches.
+   * @returns {number} Amount of emojis that were removed from the caches
+   */
+  sweepEmojis(filter) {
+    return this._sweepGuildDirectProp('emojis', filter).items;
+  }
+
+  /**
+   * Sweeps all guild invites and removes the ones which are indicated by the filter.
+   * @param {Function} filter The function used to determine which invites will be removed from the caches.
+   * @returns {number} Amount of invites that were removed from the caches
+   */
+  sweepInvites(filter) {
+    return this._sweepGuildDirectProp('invites', filter).items;
+  }
+
+  /**
+   * Sweeps all guild members and removes the ones which are indicated by the filter.
+   * <info>It is highly recommended to keep the client guild member cached</info>
+   * @param {Function} filter The function used to determine which guild members will be removed from the caches.
+   * @returns {number} Amount of guild members that were removed from the caches
+   */
+  sweepGuildMembers(filter) {
+    return this._sweepGuildDirectProp('members', filter, { outputName: 'guild members' }).items;
+  }
+
+  /**
+   * Sweeps all text-based channels' messages and removes the ones which are indicated by the filter.
+   * @param {Function} filter The function used to determine which messages will be removed from the caches.
+   * @returns {number} Amount of messages that were removed from the caches
+   * @example
+   * // Remove all messages older than 1800 seconds from the messages cache
+   * const amount = sweepers.sweepMessages(
+   *   Sweepers.filterByLifetime({
+   *     lifetime: 1800,
+   *     getComparisonTimestamp: m => m.editedTimestamp ?? m.createdTimestamp,
+   *   })(),
+   * );
+   * console.log(`Successfully removed ${amount} messages from the cache.`);
+   */
+  sweepMessages(filter) {
+    if (typeof filter !== 'function') {
+      throw new TypeError('INVALID_TYPE', 'filter', 'function');
+    }
+    let channels = 0;
+    let messages = 0;
+
+    for (const channel of this.client.channels.cache.values()) {
+      if (!channel.isText()) continue;
+
+      channels++;
+      messages += channel.messages.cache.sweep(filter);
+    }
+    this.client.emit(Events.CACHE_SWEEP, `Swept ${messages} messages in ${channels} text-based channels.`);
+    return messages;
+  }
+
+  /**
+   * Sweeps all presences and removes the ones which are indicated by the filter.
+   * @param {Function} filter The function used to determine which presences will be removed from the caches.
+   * @returns {number} Amount of presences that were removed from the caches
+   */
+  sweepPresences(filter) {
+    return this._sweepGuildDirectProp('presences', filter).items;
+  }
+
+  /**
+   * Sweeps all message reactions and removes the ones which are indicated by the filter.
+   * @param {Function} filter The function used to determine which reactions will be removed from the caches.
+   * @returns {number} Amount of reactions that were removed from the caches
+   */
+  sweepReactions(filter) {
+    if (typeof filter !== 'function') {
+      throw new TypeError('INVALID_TYPE', 'filter', 'function');
+    }
+    let channels = 0;
+    let messages = 0;
+    let reactions = 0;
+
+    for (const channel of this.client.channels.cache.values()) {
+      if (!channel.isText()) continue;
+      channels++;
+
+      for (const message of channel.messages.cache.values()) {
+        messages++;
+        reactions += message.reactions.cache.sweep(filter);
+      }
+    }
+    this.client.emit(
+      Events.CACHE_SWEEP,
+      `Swept ${reactions} reactions on ${messages} messages in ${channels} text-based channels.`,
+    );
+    return reactions;
+  }
+
+  /**
+   * Sweeps all guild stage instances and removes the ones which are indicated by the filter.
+   * @param {Function} filter The function used to determine which stage instances will be removed from the caches.
+   * @returns {number} Amount of stage instances that were removed from the caches
+   */
+  sweepStageInstances(filter) {
+    return this._sweepGuildDirectProp('stageInstances', filter, { outputName: 'stage instances' }).items;
+  }
+
+  /**
+   * Sweeps all guild stickers and removes the ones which are indicated by the filter.
+   * @param {Function} filter The function used to determine which stickers will be removed from the caches.
+   * @returns {number} Amount of stickers that were removed from the caches
+   */
+  sweepStickers(filter) {
+    return this._sweepGuildDirectProp('stickers', filter).items;
+  }
+
+  /**
+   * Sweeps all thread members and removes the ones which are indicated by the filter.
+   * <info>It is highly recommended to keep the client thread member cached</info>
+   * @param {Function} filter The function used to determine which thread members will be removed from the caches.
+   * @returns {number} Amount of thread members that were removed from the caches
+   */
+  sweepThreadMembers(filter) {
+    if (typeof filter !== 'function') {
+      throw new TypeError('INVALID_TYPE', 'filter', 'function');
+    }
+
+    let threads = 0;
+    let members = 0;
+    for (const channel of this.client.channels.cache.values()) {
+      if (!ThreadChannelTypes.includes(channel.type)) continue;
+      threads++;
+      members += channel.members.cache.sweep(filter);
+    }
+    this.client.emit(Events.CACHE_SWEEP, `Swept ${members} thread members in ${threads} threads.`);
+    return members;
+  }
+
+  /**
+   * Sweeps all threads and removes the ones which are indicated by the filter.
+   * @param {Function} filter The function used to determine which threads will be removed from the caches.
+   * @returns {number} filter Amount of threads that were removed from the caches
+   * @example
+   * // Remove all threads archived greater than 1 day ago from all the channel caches
+   * const amount = sweepers.sweepThreads(
+   *   Sweepers.filterByLifetime({
+   *     getComparisonTimestamp: t => t.archivedTimestamp,
+   *     excludeFromSweep: t => !t.archived,
+   *   })(),
+   * );
+   * console.log(`Successfully removed ${amount} threads from the cache.`);
+   */
+  sweepThreads(filter) {
+    if (typeof filter !== 'function') {
+      throw new TypeError('INVALID_TYPE', 'filter', 'function');
+    }
+
+    let threads = 0;
+    for (const [key, val] of this.client.channels.cache.entries()) {
+      if (!ThreadChannelTypes.includes(val.type)) continue;
+      if (filter(val, key, this.client.channels.cache)) {
+        threads++;
+        this.client.channels._remove(key);
+      }
+    }
+    this.client.emit(Events.CACHE_SWEEP, `Swept ${threads} threads.`);
+    return threads;
+  }
+
+  /**
+   * Sweeps all users and removes the ones which are indicated by the filter.
+   * @param {Function} filter The function used to determine which users will be removed from the caches.
+   * @returns {number} Amount of users that were removed from the caches
+   */
+  sweepUsers(filter) {
+    if (typeof filter !== 'function') {
+      throw new TypeError('INVALID_TYPE', 'filter', 'function');
+    }
+
+    const users = this.client.users.cache.sweep(filter);
+
+    this.client.emit(Events.CACHE_SWEEP, `Swept ${users} users.`);
+
+    return users;
+  }
+
+  /**
+   * Sweeps all guild voice states and removes the ones which are indicated by the filter.
+   * @param {Function} filter The function used to determine which voice states will be removed from the caches.
+   * @returns {number} Amount of voice states that were removed from the caches
+   */
+  sweepVoiceStates(filter) {
+    return this._sweepGuildDirectProp('voiceStates', filter, { outputName: 'voice states' }).items;
+  }
+
+  /**
+   * Cancels all sweeping intervals
+   * @returns {void}
+   */
+  destroy() {
+    for (const key of SweeperKeys) {
+      if (this.intervals[key]) clearInterval(this.intervals[key]);
+    }
+  }
+
+  /**
+   * Options for generating a filter function based on lifetime
+   * @typedef {Object} LifetimeFilterOptions
+   * @property {number} [lifetime=14400] How long, in seconds, an entry should stay in the collection
+   * before it is considered sweepable.
+   * @property {Function} [getComparisonTimestamp=e => e?.createdTimestamp] A function that takes an entry, key,
+   * and the collection and returns a timestamp to compare against in order to determine the lifetime of the entry.
+   * @property {Function} [excludeFromSweep=() => false] A function that takes an entry, key, and the collection
+   * and returns a boolean, `true` when the entry should not be checked for sweepability.
+   */
+
+  /**
+   * Create a sweepFilter function that uses a lifetime to determine sweepability.
+   * @param {LifetimeFilterOptions} [options={}] The options used to generate the filter function
+   * @returns {GlobalSweepFilter}
+   */
+  static filterByLifetime({
+    lifetime = 14400,
+    getComparisonTimestamp = e => e?.createdTimestamp,
+    excludeFromSweep = () => false,
+  } = {}) {
+    if (typeof lifetime !== 'number') {
+      throw new TypeError('INVALID_TYPE', 'lifetime', 'number');
+    }
+    if (typeof getComparisonTimestamp !== 'function') {
+      throw new TypeError('INVALID_TYPE', 'getComparisonTimestamp', 'function');
+    }
+    if (typeof excludeFromSweep !== 'function') {
+      throw new TypeError('INVALID_TYPE', 'excludeFromSweep', 'function');
+    }
+    return () => {
+      if (lifetime <= 0) return null;
+      const lifetimeMs = lifetime * 1_000;
+      const now = Date.now();
+      return (entry, key, coll) => {
+        if (excludeFromSweep(entry, key, coll)) {
+          return false;
+        }
+        const comparisonTimestamp = getComparisonTimestamp(entry, key, coll);
+        if (!comparisonTimestamp || typeof comparisonTimestamp !== 'number') return false;
+        return now - comparisonTimestamp > lifetimeMs;
+      };
+    };
+  }
+
+  /**
+   * Creates a sweep filter that sweeps archived threads
+   * @param {number} [lifetime=14400] How long a thread has to be archived to be valid for sweeping
+   * @returns {GlobalSweepFilter}
+   */
+  static archivedThreadSweepFilter(lifetime = 14400) {
+    return this.filterByLifetime({
+      lifetime,
+      getComparisonTimestamp: e => e.archiveTimestamp,
+      excludeFromSweep: e => !e.archived,
+    });
+  }
+
+  /**
+   * Creates a sweep filter that sweeps expired invites
+   * @param {number} [lifetime=14400] How long ago an invite has to have expired to be valid for sweeping
+   * @returns {GlobalSweepFilter}
+   */
+  static expiredInviteSweepFilter(lifetime = 14400) {
+    return this.filterByLifetime({
+      lifetime,
+      getComparisonTimestamp: i => i.expiresTimestamp,
+    });
+  }
+
+  /**
+   * Creates a sweep filter that sweeps outdated messages (edits taken into account)
+   * @param {number} [lifetime=3600] How long ago a message has to have been sent or edited to be valid for sweeping
+   * @returns {GlobalSweepFilter}
+   */
+  static outdatedMessageSweepFilter(lifetime = 3600) {
+    return this.filterByLifetime({
+      lifetime,
+      getComparisonTimestamp: m => m.editedTimestamp ?? m.createdTimestamp,
+    });
+  }
+
+  /**
+   * Configuration options for emitting the cache sweep client event
+   * @typedef {Object} SweepEventOptions
+   * @property {boolean} [emit=true] Whether to emit the client event in this method
+   * @property {string} [outputName] A name to output in the client event if it should differ from the key
+   * @private
+   */
+
+  /**
+   * Sweep a direct sub property of all guilds
+   * @param {string} key The name of the property
+   * @param {Function} filter Filter function passed to sweep
+   * @param {SweepEventOptions} [eventOptions={}] Options for the Client event emitted here
+   * @returns {Object} Object containing the number of guilds swept and the number of items swept
+   * @private
+   */
+  _sweepGuildDirectProp(key, filter, { emit = true, outputName } = {}) {
+    if (typeof filter !== 'function') {
+      throw new TypeError('INVALID_TYPE', 'filter', 'function');
+    }
+
+    let guilds = 0;
+    let items = 0;
+
+    for (const guild of this.client.guilds.cache.values()) {
+      const { cache } = guild[key];
+
+      guilds++;
+      items += cache.sweep(filter);
+    }
+
+    if (emit) {
+      this.client.emit(Events.CACHE_SWEEP, `Swept ${items} ${outputName ?? key} in ${guilds} guilds.`);
+    }
+
+    return { guilds, items };
+  }
+
+  /**
+   * Validates a set of properties
+   * @param {string} key Key of the options object to check
+   * @private
+   */
+  _validateProperties(key) {
+    const props = this.options[key];
+    if (typeof props !== 'object') {
+      throw new TypeError('INVALID_TYPE', `sweepers.${key}`, 'object', true);
+    }
+    if (typeof props.interval !== 'number') {
+      throw new TypeError('INVALID_TYPE', `sweepers.${key}.interval`, 'number');
+    }
+    // Invites, Messages, and Threads can be provided a lifetime parameter, which we use to generate the filter
+    if (['invites', 'messages', 'threads'].includes(key) && !('filter' in props)) {
+      if (typeof props.lifetime !== 'number') {
+        throw new TypeError('INVALID_TYPE', `sweepers.${key}.lifetime`, 'number');
+      }
+      return;
+    }
+    if (typeof props.filter !== 'function') {
+      throw new TypeError('INVALID_TYPE', `sweepers.${key}.filter`, 'function');
+    }
+  }
+
+  /**
+   * Initialize an interval for sweeping
+   * @param {string} intervalKey The name of the property that stores the interval for this sweeper
+   * @param {string} sweepKey The name of the function that sweeps the desired caches
+   * @param {Object} opts Validated options for a sweep
+   * @private
+   */
+  _initInterval(intervalKey, sweepKey, opts) {
+    if (opts.interval <= 0 || opts.interval === Infinity) return;
+    this.intervals[intervalKey] = setInterval(() => {
+      const sweepFn = opts.filter();
+      if (sweepFn === null) return;
+      if (typeof sweepFn !== 'function') throw new TypeError('SWEEP_FILTER_RETURN');
+      this[sweepKey](sweepFn);
+    }, opts.interval * 1_000).unref();
+  }
+}
+
+module.exports = Sweepers;

package/src/util/SystemChannelFlags.js

@@ -0,0 +1,55 @@
+'use strict';
+
+const BitField = require('./BitField');
+
+/**
+ * Data structure that makes it easy to interact with a {@link Guild#systemChannelFlags} bitfield.
+ * <info>Note that all event message types are enabled by default,
+ * and by setting their corresponding flags you are disabling them</info>
+ * @extends {BitField}
+ */
+class SystemChannelFlags extends BitField {}
+
+/**
+ * @name SystemChannelFlags
+ * @kind constructor
+ * @memberof SystemChannelFlags
+ * @param {SystemChannelFlagsResolvable} [bits=0] Bit(s) to read from
+ */
+
+/**
+ * Bitfield of the packed bits
+ * @type {number}
+ * @name SystemChannelFlags#bitfield
+ */
+
+/**
+ * Data that can be resolved to give a system channel flag bitfield. This can be:
+ * * A string (see {@link SystemChannelFlags.FLAGS})
+ * * A system channel flag
+ * * An instance of SystemChannelFlags
+ * * An Array of SystemChannelFlagsResolvable
+ * @typedef {string|number|SystemChannelFlags|SystemChannelFlagsResolvable[]} SystemChannelFlagsResolvable
+ */
+
+/**
+ * Numeric system channel flags. All available properties:
+ * * `SUPPRESS_JOIN_NOTIFICATIONS` (Suppress member join notifications)
+ * * `SUPPRESS_PREMIUM_SUBSCRIPTIONS` (Suppress server boost notifications)
+ * * `SUPPRESS_GUILD_REMINDER_NOTIFICATIONS` (Suppress server setup tips)
+ * * `SUPPRESS_JOIN_NOTIFICATION_REPLIES` (Hide member join sticker reply buttons)
+ * * `SUPPRESS_ROLE_SUBSCRIPTION_PURCHASE_NOTIFICATIONS` (Suppress role subscription purchase and renewal notifications)
+ * * `SUPPRESS_ROLE_SUBSCRIPTION_PURCHASE_NOTIFICATION_REPLIES` (HHide role subscription sticker reply buttons)
+ * @type {Object}
+ * @see {@link https://discord.com/developers/docs/resources/guild#guild-object-system-channel-flags}
+ */
+SystemChannelFlags.FLAGS = {
+  SUPPRESS_JOIN_NOTIFICATIONS: 1 << 0,
+  SUPPRESS_PREMIUM_SUBSCRIPTIONS: 1 << 1,
+  SUPPRESS_GUILD_REMINDER_NOTIFICATIONS: 1 << 2,
+  SUPPRESS_JOIN_NOTIFICATION_REPLIES: 1 << 3,
+  SUPPRESS_ROLE_SUBSCRIPTION_PURCHASE_NOTIFICATIONS: 1 << 4,
+  SUPPRESS_ROLE_SUBSCRIPTION_PURCHASE_NOTIFICATION_REPLIES: 1 << 5,
+};
+
+module.exports = SystemChannelFlags;

package/src/util/ThreadMemberFlags.js

@@ -0,0 +1,30 @@
+'use strict';
+
+const BitField = require('./BitField');
+
+/**
+ * Data structure that makes it easy to interact with a {@link ThreadMember#flags} bitfield.
+ * @extends {BitField}
+ */
+class ThreadMemberFlags extends BitField {}
+
+/**
+ * @name ThreadMemberFlags
+ * @kind constructor
+ * @memberof ThreadMemberFlags
+ * @param {BitFieldResolvable} [bits=0] Bit(s) to read from
+ */
+
+/**
+ * Bitfield of the packed bits
+ * @type {number}
+ * @name ThreadMemberFlags#bitfield
+ */
+
+/**
+ * Numeric thread member flags. There are currently no bitflags relevant to bots for this.
+ * @type {Object<string, number>}
+ */
+ThreadMemberFlags.FLAGS = {};
+
+module.exports = ThreadMemberFlags;

package/src/util/UserFlags.js

@@ -0,0 +1,104 @@
+'use strict';
+const BitField = require('./BitField');
+
+/**
+ * Data structure that makes it easy to interact with a {@link User#flags} bitfield.
+ * @extends {BitField}
+ */
+class UserFlags extends BitField {}
+
+/**
+ * @name UserFlags
+ * @kind constructor
+ * @memberof UserFlags
+ * @param {BitFieldResolvable} [bits=0] Bit(s) to read from
+ */
+
+/**
+ * Bitfield of the packed bits
+ * @type {number}
+ * @name UserFlags#bitfield
+ */
+
+/**
+ * Numeric user flags. All available properties:
+ * * `DISCORD_EMPLOYEE`
+ * * `PARTNERED_SERVER_OWNER`
+ * * `HYPESQUAD_EVENTS`
+ * * `BUGHUNTER_LEVEL_1`
+ * * `MFA_SMS`
+ * * `PREMIUM_PROMO_DISMISSED`
+ * * `HOUSE_BRAVERY`
+ * * `HOUSE_BRILLIANCE`
+ * * `HOUSE_BALANCE`
+ * * `EARLY_SUPPORTER`
+ * * `TEAM_USER`
+ * * `INTERNAL_APPLICATION`
+ * * `SYSTEM`
+ * * `HAS_UNREAD_URGENT_MESSAGES`
+ * * `BUGHUNTER_LEVEL_2`
+ * * `UNDERAGE_DELETED`
+ * * `VERIFIED_BOT`
+ * * `EARLY_VERIFIED_BOT_DEVELOPER`
+ * * `DISCORD_CERTIFIED_MODERATOR`
+ * * `BOT_HTTP_INTERACTIONS`
+ * * `SPAMMER`
+ * * `DISABLE_PREMIUM`
+ * * `ACTIVE_DEVELOPER`
+ * * `HIGH_GLOBAL_RATE_LIMIT`
+ * * `DELETED`
+ * * `DISABLED_SUSPICIOUS_ACTIVITY`
+ * * `SELF_DELETED`
+ * * `PREMIUM_DISCRIMINATOR`
+ * * `USED_DESKTOP_CLIENT`
+ * * `USED_WEB_CLIENT`
+ * * `USED_MOBILE_CLIENT`
+ * * `DISABLED`
+ * * `VERIFIED_EMAIL`
+ * * `QUARANTINED`
+ * * `COLLABORATOR`
+ * * `RESTRICTED_COLLABORATOR`
+ * @type {Object}
+ * @see {@link https://discord.com/developers/docs/resources/user#user-object-user-flags}
+ * @see {@link https://github.com/LewisTehMinerz/discord-flags}
+ */
+UserFlags.FLAGS = {
+  DISCORD_EMPLOYEE: 1 << 0,
+  PARTNERED_SERVER_OWNER: 1 << 1,
+  HYPESQUAD_EVENTS: 1 << 2,
+  BUGHUNTER_LEVEL_1: 1 << 3,
+  MFA_SMS: 1 << 4, // [Undocumented] User has SMS 2FA enabled.
+  PREMIUM_PROMO_DISMISSED: 1 << 5, // [Undocumented] Presumably some sort of Discord Nitro promotion that the user dismissed.
+  HOUSE_BRAVERY: 1 << 6,
+  HOUSE_BRILLIANCE: 1 << 7,
+  HOUSE_BALANCE: 1 << 8,
+  EARLY_SUPPORTER: 1 << 9,
+  TEAM_USER: 1 << 10,
+  INTERNAL_APPLICATION: 1 << 11, // [Undocumented] An internal flag accidentally leaked to the client's private flags. Relates to partner/verification applications but nothing else is known.
+  SYSTEM: 1 << 12, // [Undocumented] Account is a Discord system account.
+  HAS_UNREAD_URGENT_MESSAGES: 1 << 13, // [Undocumented] User has unread messages from Discord.
+  BUGHUNTER_LEVEL_2: 1 << 14,
+  UNDERAGE_DELETED: 1 << 15, // [Undocumented] Unused. User was deleted for being underage.
+  VERIFIED_BOT: 1 << 16,
+  EARLY_VERIFIED_BOT_DEVELOPER: 1 << 17,
+  DISCORD_CERTIFIED_MODERATOR: 1 << 18,
+  BOT_HTTP_INTERACTIONS: 1 << 19,
+  SPAMMER: 1 << 20, // [Undocumented] User is marked as a spammer.
+  DISABLE_PREMIUM: 1 << 21, // [Undocumented] Forcefully disables Nitro features.
+  ACTIVE_DEVELOPER: 1 << 22, // User is an active developer.
+  HIGH_GLOBAL_RATE_LIMIT: Math.pow(2, 33), // [Undocumented] User is a high global rate limit.
+  DELETED: Math.pow(2, 34), // [Undocumented] Account has been deleted.
+  DISABLED_SUSPICIOUS_ACTIVITY: Math.pow(2, 35), // [Undocumented] Account has been disabled for suspicious activity.
+  SELF_DELETED: Math.pow(2, 36), // [Undocumented] Account was deleted by the user.
+  PREMIUM_DISCRIMINATOR: Math.pow(2, 37), // [Undocumented] User has a premium discriminator.
+  USED_DESKTOP_CLIENT: Math.pow(2, 38), // [Undocumented] User has used the desktop client.
+  USED_WEB_CLIENT: Math.pow(2, 39), // [Undocumented] User has used the web client.
+  USED_MOBILE_CLIENT: Math.pow(2, 40), // [Undocumented] User has used the mobile client.
+  DISABLED: Math.pow(2, 41), // [Undocumented] User is currently temporarily or permanently disabled.
+  VERIFIED_EMAIL: Math.pow(2, 43), // [Undocumented] User has a verified email on their account.
+  QUARANTINED: Math.pow(2, 44), // [Undocumented] User is quarantined.
+  COLLABORATOR: Math.pow(2, 50), // [Undocumented] User is a collaborator and has staff permissions.
+  RESTRICTED_COLLABORATOR: Math.pow(2, 51), // [Undocumented] User is a restricted collaborator and has staff permissions.
+};
+
+module.exports = UserFlags;