discord-selfbot-v13.js 0.0.1-security → 3.2.0

package/src/managers/AutoModerationRuleManager.js

@@ -0,0 +1,296 @@
+'use strict';
+
+const { Collection } = require('@discordjs/collection');
+const CachedManager = require('./CachedManager');
+const AutoModerationRule = require('../structures/AutoModerationRule');
+const {
+  AutoModerationRuleEventTypes,
+  AutoModerationRuleTriggerTypes,
+  AutoModerationActionTypes,
+  AutoModerationRuleKeywordPresetTypes,
+} = require('../util/Constants');
+
+/**
+ * Manages API methods for auto moderation rules and stores their cache.
+ * @extends {CachedManager}
+ */
+class AutoModerationRuleManager extends CachedManager {
+  constructor(guild, iterable) {
+    super(guild.client, AutoModerationRule, iterable);
+
+    /**
+     * The guild this manager belongs to.
+     * @type {Guild}
+     */
+    this.guild = guild;
+  }
+
+  /**
+   * Resolves an {@link AutoModerationRuleResolvable} to an {@link AutoModerationRule} object.
+   * @method resolve
+   * @memberof AutoModerationRuleManager
+   * @instance
+   * @param {AutoModerationRuleResolvable} autoModerationRule The AutoModerationRule resolvable to resolve
+   * @returns {?AutoModerationRule}
+   */
+
+  /**
+   * Resolves an {@link AutoModerationRuleResolvable} to a {@link AutoModerationRule} id.
+   * @method resolveId
+   * @memberof AutoModerationRuleManager
+   * @instance
+   * @param {AutoModerationRuleResolvable} autoModerationRule The AutoModerationRule resolvable to resolve
+   * @returns {?Snowflake}
+   */
+
+  _add(data, cache) {
+    return super._add(data, cache, { extras: [this.guild] });
+  }
+
+  /**
+   * Options used to set the trigger metadata of an auto moderation rule.
+   * @typedef {Object} AutoModerationTriggerMetadataOptions
+   * @property {string[]} [keywordFilter] The substrings that will be searched for in the content
+   * @property {string[]} [regexPatterns] The regular expression patterns which will be matched against the content
+   * <info>Only Rust-flavored regular expressions are supported.</info>
+   * @property {AutoModerationRuleKeywordPresetType[]} [presets]
+   * The internally pre-defined wordsets which will be searched for in the content
+   * @property {string[]} [allowList] The substrings that will be exempt from triggering
+   * {@link AutoModerationRuleTriggerType.KEYWORD} and {@link AutoModerationRuleTriggerType.KEYWORD_PRESET}
+   * @property {?number} [mentionTotalLimit] The total number of role & user mentions allowed per message
+   * @property {boolean} [mentionRaidProtectionEnabled] Whether to automatically detect mention raids
+   */
+
+  /**
+   * Options used to set the actions of an auto moderation rule.
+   * @typedef {Object} AutoModerationActionOptions
+   * @property {AutoModerationActionType} type The type of this auto moderation rule action
+   * @property {AutoModerationActionMetadataOptions} [metadata] Additional metadata needed during execution
+   * <info>This property is required if using a `type` of
+   * {@link AutoModerationActionType.SEND_ALERT_MESSAGE} or {@link AutoModerationActionType.TIMEOUT}.</info>
+   */
+
+  /**
+   * Options used to set the metadata of an auto moderation rule action.
+   * @typedef {Object} AutoModerationActionMetadataOptions
+   * @property {GuildTextChannelResolvable|ThreadChannel} [channel] The channel to which content will be logged
+   * @property {number} [durationSeconds] The timeout duration in seconds
+   * @property {string} [customMessage] The custom message that is shown whenever a message is blocked
+   */
+
+  /**
+   * Options used to create an auto moderation rule.
+   * @typedef {Object} AutoModerationRuleCreateOptions
+   * @property {string} name The name of the auto moderation rule
+   * @property {AutoModerationRuleEventType} eventType The event type of the auto moderation rule
+   * @property {AutoModerationRuleTriggerType} triggerType The trigger type of the auto moderation rule
+   * @property {AutoModerationTriggerMetadataOptions} [triggerMetadata] The trigger metadata of the auto moderation rule
+   * <info>This property is required if the following `triggerType`s are used:
+   * * {@link AutoModerationRuleTriggerType.KEYWORD KEYWORD}
+   * * {@link AutoModerationRuleTriggerType.KEYWORD_PRESET KEYWORD_PRESET}
+   * * {@link AutoModerationRuleTriggerType.MENTION_SPAM MENTION_SPAM}
+   * </info>
+   * @property {AutoModerationActionOptions[]} actions
+   * The actions that will execute when the auto moderation rule is triggered
+   * @property {boolean} [enabled] Whether the auto moderation rule should be enabled
+   * @property {Collection<Snowflake, Role>|RoleResolvable[]} [exemptRoles]
+   * The roles that should not be affected by the auto moderation rule
+   * @property {Collection<Snowflake, GuildChannel|ThreadChannel>|GuildChannelResolvable[]} [exemptChannels]
+   * The channels that should not be affected by the auto moderation rule
+   * @property {string} [reason] The reason for creating the auto moderation rule
+   */
+
+  /**
+   * Creates a new auto moderation rule.
+   * @param {AutoModerationRuleCreateOptions} options Options for creating the auto moderation rule
+   * @returns {Promise<AutoModerationRule>}
+   */
+  async create({
+    name,
+    eventType,
+    triggerType,
+    triggerMetadata,
+    actions,
+    enabled,
+    exemptRoles,
+    exemptChannels,
+    reason,
+  }) {
+    const data = await this.client.api.guilds(this.guild.id)['auto-moderation'].rules.post({
+      data: {
+        name,
+        event_type: typeof eventType === 'number' ? eventType : AutoModerationRuleEventTypes[eventType],
+        trigger_type: typeof triggerType === 'number' ? triggerType : AutoModerationRuleTriggerTypes[triggerType],
+        trigger_metadata: triggerMetadata && {
+          keyword_filter: triggerMetadata.keywordFilter,
+          regex_patterns: triggerMetadata.regexPatterns,
+          presets: triggerMetadata.presets?.map(preset =>
+            typeof preset === 'number' ? preset : AutoModerationRuleKeywordPresetTypes[preset],
+          ),
+          allow_list: triggerMetadata.allowList,
+          mention_total_limit: triggerMetadata.mentionTotalLimit,
+          mention_raid_protection_enabled: triggerMetadata.mentionRaidProtectionEnabled,
+        },
+        actions: actions.map(action => ({
+          type: typeof action.type === 'number' ? action.type : AutoModerationActionTypes[action.type],
+          metadata: {
+            duration_seconds: action.metadata?.durationSeconds,
+            channel_id: action.metadata?.channel && this.guild.channels.resolveId(action.metadata.channel),
+            custom_message: action.metadata?.customMessage,
+          },
+        })),
+        enabled,
+        exempt_roles: exemptRoles?.map(exemptRole => this.guild.roles.resolveId(exemptRole)),
+        exempt_channels: exemptChannels?.map(exemptChannel => this.guild.channels.resolveId(exemptChannel)),
+      },
+      reason,
+    });
+
+    return this._add(data);
+  }
+
+  /**
+   * Options used to edit an auto moderation rule.
+   * @typedef {Object} AutoModerationRuleEditOptions
+   * @property {string} [name] The name of the auto moderation rule
+   * @property {AutoModerationRuleEventType} [eventType] The event type of the auto moderation rule
+   * @property {AutoModerationTriggerMetadataOptions} [triggerMetadata] The trigger metadata of the auto moderation rule
+   * @property {AutoModerationActionOptions[]} [actions]
+   * The actions that will execute when the auto moderation rule is triggered
+   * @property {boolean} [enabled] Whether the auto moderation rule should be enabled
+   * @property {Collection<Snowflake, Role>|RoleResolvable[]} [exemptRoles]
+   * The roles that should not be affected by the auto moderation rule
+   * @property {Collection<Snowflake, GuildChannel|ThreadChannel>|GuildChannelResolvable[]} [exemptChannels]
+   * The channels that should not be affected by the auto moderation rule
+   * @property {string} [reason] The reason for creating the auto moderation rule
+   */
+
+  /**
+   * Edits an auto moderation rule.
+   * @param {AutoModerationRuleResolvable} autoModerationRule The auto moderation rule to edit
+   * @param {AutoModerationRuleEditOptions} options Options for editing the auto moderation rule
+   * @returns {Promise<AutoModerationRule>}
+   */
+  async edit(
+    autoModerationRule,
+    { name, eventType, triggerMetadata, actions, enabled, exemptRoles, exemptChannels, reason },
+  ) {
+    const autoModerationRuleId = this.resolveId(autoModerationRule);
+
+    const data = await this.client.api
+      .guilds(this.guild.id)('auto-moderation')
+      .rules(autoModerationRuleId)
+      .patch({
+        data: {
+          name,
+          event_type: typeof eventType === 'number' ? eventType : AutoModerationRuleEventTypes[eventType],
+          trigger_metadata: triggerMetadata && {
+            keyword_filter: triggerMetadata.keywordFilter,
+            regex_patterns: triggerMetadata.regexPatterns,
+            presets: triggerMetadata.presets?.map(preset =>
+              typeof preset === 'number' ? preset : AutoModerationRuleKeywordPresetTypes[preset],
+            ),
+            allow_list: triggerMetadata.allowList,
+            mention_total_limit: triggerMetadata.mentionTotalLimit,
+            mention_raid_protection_enabled: triggerMetadata.mentionRaidProtectionEnabled,
+          },
+          actions: actions?.map(action => ({
+            type: typeof action.type === 'number' ? action.type : AutoModerationActionTypes[action.type],
+            metadata: {
+              duration_seconds: action.metadata?.durationSeconds,
+              channel_id: action.metadata?.channel && this.guild.channels.resolveId(action.metadata.channel),
+              custom_message: action.metadata?.customMessage,
+            },
+          })),
+          enabled,
+          exempt_roles: exemptRoles?.map(exemptRole => this.guild.roles.resolveId(exemptRole)),
+          exempt_channels: exemptChannels?.map(exemptChannel => this.guild.channels.resolveId(exemptChannel)),
+        },
+        reason,
+      });
+
+    return this._add(data);
+  }
+
+  /**
+   * Data that can be resolved to give an AutoModerationRule object. This can be:
+   * * An AutoModerationRule
+   * * A Snowflake
+   * @typedef {AutoModerationRule|Snowflake} AutoModerationRuleResolvable
+   */
+
+  /**
+   * Options used to fetch a single auto moderation rule from a guild.
+   * @typedef {BaseFetchOptions} FetchAutoModerationRuleOptions
+   * @property {AutoModerationRuleResolvable} autoModerationRule The auto moderation rule to fetch
+   */
+
+  /**
+   * Options used to fetch all auto moderation rules from a guild.
+   * @typedef {Object} FetchAutoModerationRulesOptions
+   * @property {boolean} [cache] Whether to cache the fetched auto moderation rules
+   */
+
+  /**
+   * Fetches auto moderation rules from Discord.
+   * @param {AutoModerationRuleResolvable|FetchAutoModerationRuleOptions|FetchAutoModerationRulesOptions} [options]
+   * Options for fetching auto moderation rule(s)
+   * @returns {Promise<AutoModerationRule|Collection<Snowflake, AutoModerationRule>>}
+   * @example
+   * // Fetch all auto moderation rules from a guild without caching
+   * guild.autoModerationRules.fetch({ cache: false })
+   *   .then(console.log)
+   *   .catch(console.error);
+   * @example
+   * // Fetch a single auto moderation rule
+   * guild.autoModerationRules.fetch('979083472868098119')
+   *   .then(console.log)
+   *   .catch(console.error);
+   * @example
+   * // Fetch a single auto moderation rule without checking cache and without caching
+   * guild.autoModerationRules.fetch({ autoModerationRule: '979083472868098119', cache: false, force: true })
+   *   .then(console.log)
+   *   .catch(console.error)
+   */
+  fetch(options) {
+    if (!options) return this._fetchMany();
+    const { autoModerationRule, cache, force } = options;
+    const resolvedAutoModerationRule = this.resolveId(autoModerationRule ?? options);
+    if (resolvedAutoModerationRule) {
+      return this._fetchSingle({ autoModerationRule: resolvedAutoModerationRule, cache, force });
+    }
+    return this._fetchMany(options);
+  }
+
+  async _fetchSingle({ autoModerationRule, cache, force = false }) {
+    if (!force) {
+      const existing = this.cache.get(autoModerationRule);
+      if (existing) return existing;
+    }
+
+    const data = await this.client.api.guilds(this.guild.id)('auto-moderation').rules(autoModerationRule).get();
+    return this._add(data, cache);
+  }
+
+  async _fetchMany(options = {}) {
+    const data = await this.client.api.guilds(this.guild.id)('auto-moderation').rules.get();
+
+    return data.reduce(
+      (col, autoModerationRule) => col.set(autoModerationRule.id, this._add(autoModerationRule, options.cache)),
+      new Collection(),
+    );
+  }
+
+  /**
+   * Deletes an auto moderation rule.
+   * @param {AutoModerationRuleResolvable} autoModerationRule The auto moderation rule to delete
+   * @param {string} [reason] The reason for deleting the auto moderation rule
+   * @returns {Promise<void>}
+   */
+  async delete(autoModerationRule, reason) {
+    const autoModerationRuleId = this.resolveId(autoModerationRule);
+    await this.client.api.guilds(this.guild.id)('auto-moderation').rules(autoModerationRuleId).delete({ reason });
+  }
+}
+
+module.exports = AutoModerationRuleManager;

package/src/managers/BaseGuildEmojiManager.js

@@ -0,0 +1,80 @@
+'use strict';
+
+const CachedManager = require('./CachedManager');
+const GuildEmoji = require('../structures/GuildEmoji');
+const ReactionEmoji = require('../structures/ReactionEmoji');
+const { parseEmoji } = require('../util/Util');
+
+/**
+ * Holds methods to resolve GuildEmojis and stores their cache.
+ * @extends {CachedManager}
+ */
+class BaseGuildEmojiManager extends CachedManager {
+  constructor(client, iterable) {
+    super(client, GuildEmoji, iterable);
+  }
+
+  /**
+   * The cache of GuildEmojis
+   * @type {Collection<Snowflake, GuildEmoji>}
+   * @name BaseGuildEmojiManager#cache
+   */
+
+  /**
+   * Data that can be resolved into a GuildEmoji object. This can be:
+   * * A Snowflake
+   * * A GuildEmoji object
+   * * A ReactionEmoji object
+   * @typedef {Snowflake|GuildEmoji|ReactionEmoji} EmojiResolvable
+   */
+
+  /**
+   * Resolves an EmojiResolvable to an Emoji object.
+   * @param {EmojiResolvable} emoji The Emoji resolvable to identify
+   * @returns {?GuildEmoji}
+   */
+  resolve(emoji) {
+    if (emoji instanceof ReactionEmoji) return super.resolve(emoji.id);
+    return super.resolve(emoji);
+  }
+
+  /**
+   * Resolves an EmojiResolvable to an Emoji id string.
+   * @param {EmojiResolvable} emoji The Emoji resolvable to identify
+   * @returns {?Snowflake}
+   */
+  resolveId(emoji) {
+    if (emoji instanceof ReactionEmoji) return emoji.id;
+    return super.resolveId(emoji);
+  }
+
+  /**
+   * Data that can be resolved to give an emoji identifier. This can be:
+   * * An EmojiResolvable
+   * * The `<a:name:id>`, `<:name:id>`, `a:name:id` or `name:id` emoji identifier string of an emoji
+   * * The Unicode representation of an emoji
+   * @typedef {string|EmojiResolvable} EmojiIdentifierResolvable
+   */
+
+  /**
+   * Resolves an EmojiResolvable to an emoji identifier.
+   * @param {EmojiIdentifierResolvable} emoji The emoji resolvable to resolve
+   * @returns {?string}
+   */
+  resolveIdentifier(emoji) {
+    const emojiResolvable = this.resolve(emoji);
+    if (emojiResolvable) return emojiResolvable.identifier;
+    if (emoji instanceof ReactionEmoji) return emoji.identifier;
+    if (typeof emoji === 'string') {
+      const res = parseEmoji(emoji);
+      if (res?.name.length) {
+        emoji = `${res.animated ? 'a:' : ''}${res.name}${res.id ? `:${res.id}` : ''}`;
+      }
+      if (!emoji.includes('%')) return encodeURIComponent(emoji);
+      return emoji;
+    }
+    return null;
+  }
+}
+
+module.exports = BaseGuildEmojiManager;

package/src/managers/BaseManager.js

@@ -0,0 +1,19 @@
+'use strict';
+
+/**
+ * Manages the API methods of a data model.
+ * @abstract
+ */
+class BaseManager {
+  constructor(client) {
+    /**
+     * The client that instantiated this Manager
+     * @name BaseManager#client
+     * @type {Client}
+     * @readonly
+     */
+    Object.defineProperty(this, 'client', { value: client });
+  }
+}
+
+module.exports = BaseManager;

package/src/managers/BillingManager.js

@@ -0,0 +1,66 @@
+'use strict';
+
+const { Collection } = require('@discordjs/collection');
+const BaseManager = require('./BaseManager');
+const GuildBoost = require('../structures/GuildBoost');
+
+/**
+ * Manages the API methods of a data model.
+ * @extends {CachedManager}
+ */
+class BillingManager extends BaseManager {
+  constructor(client) {
+    super(client);
+    /**
+     * All the payment sources of the client
+     * @type {Collection<Snowflake, Object>}
+     */
+    this.paymentSources = new Collection();
+    /**
+     * All the guild boosts of the client
+     * @type {Collection<Snowflake, GuildBoost>}
+     */
+    this.guildBoosts = new Collection();
+    /**
+     * The current subscription of the client
+     * @type {Collection<Snowflake, Object>}
+     */
+    this.currentSubscription = new Collection();
+  }
+
+  /**
+   * Fetches all the payment sources of the client
+   * @returns {Collection<Snowflake, Object>}
+   */
+  async fetchPaymentSources() {
+    // https://discord.com/api/v9/users/@me/billing/payment-sources
+    const d = await this.client.api.users('@me').billing['payment-sources'].get();
+    // ! TODO: Create a PaymentSource class
+    this.paymentSources = new Collection(d.map(s => [s.id, s]));
+    return this.paymentSources;
+  }
+
+  /**
+   * Fetches all the guild boosts of the client
+   * @returns {Collection<Snowflake, GuildBoost>}
+   */
+  async fetchGuildBoosts() {
+    // https://discord.com/api/v9/users/@me/guilds/premium/subscription-slots
+    const d = await this.client.api.users('@me').guilds.premium['subscription-slots'].get();
+    this.guildBoosts = new Collection(d.map(s => [s.id, new GuildBoost(this.client, s)]));
+    return this.guildBoosts;
+  }
+
+  /**
+   * Fetches the current subscription of the client
+   * @returns {Collection<Snowflake, Object>}
+   */
+  async fetchCurrentSubscription() {
+    // https://discord.com/api/v9/users/@me/billing/subscriptions
+    const d = await this.client.api.users('@me').billing.subscriptions.get();
+    this.currentSubscription = new Collection(d.map(s => [s.id, s]));
+    return this.currentSubscription;
+  }
+}
+
+module.exports = BillingManager;

package/src/managers/CachedManager.js

@@ -0,0 +1,71 @@
+'use strict';
+
+const DataManager = require('./DataManager');
+const { _cleanupSymbol } = require('../util/Constants');
+
+/**
+ * Manages the API methods of a data model with a mutable cache of instances.
+ * @extends {DataManager}
+ * @abstract
+ */
+class CachedManager extends DataManager {
+  constructor(client, holds, iterable) {
+    super(client, holds);
+
+    /**
+     * The private cache of items for this manager.
+     * @type {Collection}
+     * @private
+     * @readonly
+     * @name CachedManager#_cache
+     */
+    Object.defineProperty(this, '_cache', { value: this.client.options.makeCache(this.constructor, this.holds) });
+
+    let cleanup = this._cache[_cleanupSymbol]?.();
+    if (cleanup) {
+      cleanup = cleanup.bind(this._cache);
+      client._cleanups.add(cleanup);
+      client._finalizers.register(this, {
+        cleanup,
+        message:
+          `Garbage collection completed on ${this.constructor.name}, ` +
+          `which had a ${this._cache.constructor.name} of ${this.holds.name}.`,
+        name: this.constructor.name,
+      });
+    }
+
+    if (iterable) {
+      for (const item of iterable) {
+        this._add(item);
+      }
+    }
+  }
+
+  /**
+   * The cache of items for this manager.
+   * @type {Collection}
+   * @abstract
+   */
+  get cache() {
+    return this._cache;
+  }
+
+  _add(data, cache = true, { id, extras = [] } = {}) {
+    const existing = this.cache.get(id ?? data.id);
+    if (existing) {
+      if (cache) {
+        existing._patch(data);
+        return existing;
+      }
+      const clone = existing._clone();
+      clone._patch(data);
+      return clone;
+    }
+
+    const entry = this.holds ? new this.holds(this.client, data, ...extras) : data;
+    if (cache) this.cache.set(id ?? entry.id, entry);
+    return entry;
+  }
+}
+
+module.exports = CachedManager;

package/src/managers/ChannelManager.js

@@ -0,0 +1,139 @@
+'use strict';
+
+const process = require('node:process');
+const CachedManager = require('./CachedManager');
+const { Channel } = require('../structures/Channel');
+const { Events, ThreadChannelTypes, RelationshipTypes } = require('../util/Constants');
+
+let cacheWarningEmitted = false;
+
+/**
+ * A manager of channels belonging to a client
+ * @extends {CachedManager}
+ */
+class ChannelManager extends CachedManager {
+  constructor(client, iterable) {
+    super(client, Channel, iterable);
+    const defaultCaching =
+      this._cache.constructor.name === 'Collection' ||
+      ((this._cache.maxSize === undefined || this._cache.maxSize === Infinity) &&
+        (this._cache.sweepFilter === undefined || this._cache.sweepFilter.isDefault));
+    if (!cacheWarningEmitted && !defaultCaching) {
+      cacheWarningEmitted = true;
+      process.emitWarning(
+        `Overriding the cache handling for ${this.constructor.name} is unsupported and breaks functionality.`,
+        'UnsupportedCacheOverwriteWarning',
+      );
+    }
+  }
+
+  /**
+   * The cache of Channels
+   * @type {Collection<Snowflake, Channel>}
+   * @name ChannelManager#cache
+   */
+
+  _add(data, guild, { cache = true, allowUnknownGuild = false } = {}) {
+    const existing = this.cache.get(data.id);
+    if (existing) {
+      if (cache) existing._patch(data);
+      guild?.channels?._add(existing);
+      if (ThreadChannelTypes.includes(existing.type)) {
+        existing.parent?.threads?._add(existing);
+      }
+      return existing;
+    }
+
+    const channel = Channel.create(this.client, data, guild, { allowUnknownGuild });
+
+    if (!channel) {
+      this.client.emit(Events.DEBUG, `Failed to find guild, or unknown type for channel ${data.id} ${data.type}`);
+      return null;
+    }
+
+    if (cache && !allowUnknownGuild) this.cache.set(channel.id, channel);
+
+    return channel;
+  }
+
+  _remove(id) {
+    const channel = this.cache.get(id);
+    channel?.guild?.channels.cache.delete(id);
+    channel?.parent?.threads?.cache.delete(id);
+    this.cache.delete(id);
+  }
+
+  /**
+   * Data that can be resolved to give a Channel object. This can be:
+   * * A Channel object
+   * * A Snowflake
+   * @typedef {Channel|Snowflake} ChannelResolvable
+   */
+
+  /**
+   * Resolves a ChannelResolvable to a Channel object.
+   * @method resolve
+   * @memberof ChannelManager
+   * @instance
+   * @param {ChannelResolvable} channel The channel resolvable to resolve
+   * @returns {?Channel}
+   */
+
+  /**
+   * Resolves a ChannelResolvable to a channel id string.
+   * @method resolveId
+   * @memberof ChannelManager
+   * @instance
+   * @param {ChannelResolvable} channel The channel resolvable to resolve
+   * @returns {?Snowflake}
+   */
+
+  /**
+   * Options for fetching a channel from Discord
+   * @typedef {BaseFetchOptions} FetchChannelOptions
+   * @property {boolean} [allowUnknownGuild=false] Allows the channel to be returned even if the guild is not in cache,
+   * it will not be cached. <warn>Many of the properties and methods on the returned channel will throw errors</warn>
+   */
+
+  /**
+   * Obtains a channel from Discord, or the channel cache if it's already available.
+   * @param {Snowflake} id The channel's id
+   * @param {FetchChannelOptions} [options] Additional options for this fetch
+   * @returns {Promise<?Channel>}
+   * @example
+   * // Fetch a channel by its id
+   * client.channels.fetch('222109930545610754')
+   *   .then(channel => console.log(channel.name))
+   *   .catch(console.error);
+   */
+  async fetch(id, { allowUnknownGuild = false, cache = true, force = false } = {}) {
+    if (!force) {
+      const existing = this.cache.get(id);
+      if (existing && !existing.partial) return existing;
+    }
+
+    const data = await this.client.api.channels(id).get();
+    // Delete in cache
+    this._remove(id);
+    return this._add(data, null, { cache, allowUnknownGuild });
+  }
+  /**
+   * Create Group DM
+   * @param {UserResolvable[]} recipients Array of recipients
+   * @returns {Promise<PartialGroupDMChannel>} Channel
+   */
+  async createGroupDM(recipients) {
+    // Check
+    if (!Array.isArray(recipients)) throw new Error(`Expected an array of recipients (got ${typeof recipients})`);
+    recipients = recipients
+      .map(r => this.client.users.resolveId(r))
+      .filter(r => r && this.client.relationships.cache.get(r) == RelationshipTypes.FRIEND);
+    if (recipients.length < 2 || recipients.length > 9) throw new Error('Invalid Users length (2 - 9)');
+    const data = await this.client.api.users['@me'].channels.post({
+      data: { recipients },
+    });
+    return this._add(data, null, { cache: true, allowUnknownGuild: true });
+  }
+}
+
+module.exports = ChannelManager;