feat: Auto Moderation (#7938)

* feat: initial AutoMod commit

* types: Typo in class name

Co-authored-by: Jonathan <54381371+axisiscool@users.noreply.github.com>

* refactor: move things around

* refactor: remove undocumented property

* chore: add new intents to issue form

* feat: add initial basic manager

* feat(AutoModRule): add new properties

* feat: add events

* feat(GuildAuditLog): cache rules

* refactor: move JSDoc to where it is actually used

* refactor(AutoModRule): add `_patch()` method

* feat(AutoModRuleManager): add resolvers

* feat(Sweepers): add new manager

* types: nullify first parameter of `autoModerationRuleUpdate`

* types: add manager to `Caches`

* docs(AutoModRule): update `metadata` docstring

* feat: add execution event

* fix(AutoModActionExecution): export class

* refactor(AutoModRule): `triggerType` is not modifiable

* docs(AutoModRule): link class

* feat: add trigger metadata definitions

* docs(AutoModRule): typos

* feat(AutoModRule): action metadata

* types: Proper casing of name

Co-authored-by: MateoDeveloper <79017590+Mateo-tem@users.noreply.github.com>

* refactor: only patch data if exists

* types: `preset` is an array

* types(AutoModRuleActionMetadata): nullify all

* feat(AutoModRuleManager): add `fetch()`

* docs(AutoModRule): tweak some wording

* docs(AutoModRule): use "array" over "list"

* docs(AutoModRuleResolvable): fix union

* types: adjust some names

* feat(AutoModRuleManager): add `create()`

* feat(AutoModRuleManager): add `delete()`

* refactor: prefer full auto moderation name

* docs(AutoModerationRuleManager): fix a fetch example

* refactor(Sweepers): alphabetise methods

* chore: remove testing

* fix(AutoModerationRuleCreateOptions): add `reason`

* fix: typo for `presets`

* fix(AutoModerationRuleCreateOptions): `actions` is required

* fix(AutoModerationRuleManager): handle properties that are unrequired

* feat(AutoModerationRuleManager): add `edit()`

* feat(GuildAuditLogsEntry): add auto moderation rules

* refactor: prefer "AutoModerationActionExecutionAction"

* refactor: annotate todos and doc fixes

* feat(AutoModerationRule): add guild getter

* docs(AutoModerationRule): rule -> auto moderation rule

* docs(AutoModerationRuleEditOptions): `eventType` is optional

* feat(AutoModerationRule): add helpers

* docs: random string updates

* chore: add TODOs

* feat(AutoModerationActionExecution): add helpers

* feat: support role and channel resolvables

* chore: high priority todo to keep me in solitary

* refactor(AutoModerationActionMetadataOptions): allow resolvables

* chore: tidy up from merge

* docs(AutoModerationRule): document extension

* feat: export `AutoModerationRuleManager`

* chore(ActionsManager): add new actions

* chore: add to websocket index

* refactor(AutoModerationActionExecution): send the guild across

* docs(AutoModerationActionExecution): typo

* docs(AutoModerationRule): deduplicate a word

* docs(Guild): dot

* test: add some basic tests

* docs(AutoModerationRuleManager): fetch is optional

* docs(AutoModerationActionExecution): prefer non-links

* types: `presets` is an array of numbers

* docs(AutoModerationRuleEditOptions): `name` is optional

* docs(AutoModerationRule): fix type for `exemptChannels`

* docs(AutoModerationRuleUpdateAction): remove "object"

* feat: add `allow_list`

* fix(GuildAuditLogsEntry): pass guild

* docs(AutoModerationRuleManager): correct fetch example

* chore: prettier

* refactor: remove unneeded optional chaining operator

* feat: add mention limit

* docs(AutoModerationRuleManager): document new requirement

* refactor: conform to message content intent

* docs: document permission for event

* docs: refactor intent message

* docs: dot

* docs: remove string in link

* refactor: document upstream changes

* fix(AutoModerationRuleDelete): Correct event fire

Co-authored-by: GoldenAngel <50855202+GoldenAngel2@users.noreply.github.com>

* feat(AutoModerationRule): Add `setMentionTotalLimit()` helper method

* feat(AuditLogEntries): add new extra fields

* types: add `guild` in constructors

* types: update typings

* refactor(AutoModerationRuleManager): `&&` shorthand

* types: remove leftover type

* chore: types

* docs: update API types

* docs: Tweak guild wording

Co-authored-by: Aura Román <kyradiscord@gmail.com>

* feat: add regular expression matching

* docs: update `allowList` wording

* refactor: deduplicate `guildId`

Co-authored-by: Jonathan <54381371+axisiscool@users.noreply.github.com>
Co-authored-by: MateoDeveloper <79017590+Mateo-tem@users.noreply.github.com>
Co-authored-by: GoldenAngel <50855202+GoldenAngel2@users.noreply.github.com>
Co-authored-by: Aura Román <kyradiscord@gmail.com>

packages/discord.js/src/client/actions/ActionsManager.js

@@ -5,6 +5,10 @@ class ActionsManager {
     this.client = client;
 
     this.register(require('./ApplicationCommandPermissionsUpdate'));
+    this.register(require('./AutoModerationActionExecution'));
+    this.register(require('./AutoModerationRuleCreate'));
+    this.register(require('./AutoModerationRuleDelete'));
+    this.register(require('./AutoModerationRuleUpdate'));
     this.register(require('./ChannelCreate'));
     this.register(require('./ChannelDelete'));
     this.register(require('./ChannelUpdate'));

packages/discord.js/src/client/actions/AutoModerationActionExecution.js

@@ -0,0 +1,26 @@
+'use strict';
+
+const Action = require('./Action');
+const AutoModerationActionExecution = require('../../structures/AutoModerationActionExecution');
+const Events = require('../../util/Events');
+
+class AutoModerationActionExecutionAction extends Action {
+  handle(data) {
+    const { client } = this;
+    const guild = client.guilds.cache.get(data.guild_id);
+
+    if (guild) {
+      /**
+       * Emitted whenever an auto moderation rule is triggered.
+       * <info>This event requires the {@link PermissionFlagsBits.ManageGuild} permission.</info>
+       * @event Client#autoModerationActionExecution
+       * @param {AutoModerationActionExecution} autoModerationActionExecution The data of the execution
+       */
+      client.emit(Events.AutoModerationActionExecution, new AutoModerationActionExecution(data, guild));
+    }
+
+    return {};
+  }
+}
+
+module.exports = AutoModerationActionExecutionAction;

packages/discord.js/src/client/actions/AutoModerationRuleCreate.js

@@ -0,0 +1,27 @@
+'use strict';
+
+const Action = require('./Action');
+const Events = require('../../util/Events');
+
+class AutoModerationRuleCreateAction extends Action {
+  handle(data) {
+    const { client } = this;
+    const guild = client.guilds.cache.get(data.guild_id);
+
+    if (guild) {
+      const autoModerationRule = guild.autoModerationRules._add(data);
+
+      /**
+       * Emitted whenever an auto moderation rule is created.
+       * <info>This event requires the {@link PermissionFlagsBits.ManageGuild} permission.</info>
+       * @event Client#autoModerationRuleCreate
+       * @param {AutoModerationRule} autoModerationRule The created auto moderation rule
+       */
+      client.emit(Events.AutoModerationRuleCreate, autoModerationRule);
+    }
+
+    return {};
+  }
+}
+
+module.exports = AutoModerationRuleCreateAction;

packages/discord.js/src/client/actions/AutoModerationRuleDelete.js

@@ -0,0 +1,31 @@
+'use strict';
+
+const Action = require('./Action');
+const Events = require('../../util/Events');
+
+class AutoModerationRuleDeleteAction extends Action {
+  handle(data) {
+    const { client } = this;
+    const guild = client.guilds.cache.get(data.guild_id);
+
+    if (guild) {
+      const autoModerationRule = guild.autoModerationRules.cache.get(data.id);
+
+      if (autoModerationRule) {
+        guild.autoModerationRules.cache.delete(autoModerationRule.id);
+
+        /**
+         * Emitted whenever an auto moderation rule is deleted.
+         * <info>This event requires the {@link PermissionFlagsBits.ManageGuild} permission.</info>
+         * @event Client#autoModerationRuleDelete
+         * @param {AutoModerationRule} autoModerationRule The deleted auto moderation rule
+         */
+        client.emit(Events.AutoModerationRuleDelete, autoModerationRule);
+      }
+    }
+
+    return {};
+  }
+}
+
+module.exports = AutoModerationRuleDeleteAction;

packages/discord.js/src/client/actions/AutoModerationRuleUpdate.js

@@ -0,0 +1,29 @@
+'use strict';
+
+const Action = require('./Action');
+const Events = require('../../util/Events');
+
+class AutoModerationRuleUpdateAction extends Action {
+  handle(data) {
+    const { client } = this;
+    const guild = client.guilds.cache.get(data.guild_id);
+
+    if (guild) {
+      const oldAutoModerationRule = guild.autoModerationRules.cache.get(data.id)?._clone() ?? null;
+      const newAutoModerationRule = guild.autoModerationRules._add(data);
+
+      /**
+       * Emitted whenever an auto moderation rule gets updated.
+       * <info>This event requires the {@link PermissionFlagsBits.ManageGuild} permission.</info>
+       * @event Client#autoModerationRuleUpdate
+       * @param {?AutoModerationRule} oldAutoModerationRule The auto moderation rule before the update
+       * @param {AutoModerationRule} newAutoModerationRule The auto moderation rule after the update
+       */
+      client.emit(Events.AutoModerationRuleUpdate, oldAutoModerationRule, newAutoModerationRule);
+    }
+
+    return {};
+  }
+}
+
+module.exports = AutoModerationRuleUpdateAction;

packages/discord.js/src/client/websocket/handlers/AUTO_MODERATION_ACTION_EXECUTION.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.AutoModerationActionExecution.handle(packet.d);
+};

packages/discord.js/src/client/websocket/handlers/AUTO_MODERATION_RULE_CREATE.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.AutoModerationRuleCreate.handle(packet.d);
+};

packages/discord.js/src/client/websocket/handlers/AUTO_MODERATION_RULE_DELETE.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.AutoModerationRuleDelete.handle(packet.d);
+};

packages/discord.js/src/client/websocket/handlers/AUTO_MODERATION_RULE_UPDATE.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = (client, packet) => {
+  client.actions.AutoModerationRuleUpdate.handle(packet.d);
+};

packages/discord.js/src/client/websocket/handlers/index.js

@@ -2,6 +2,10 @@
 
 const handlers = Object.fromEntries([
   ['APPLICATION_COMMAND_PERMISSIONS_UPDATE', require('./APPLICATION_COMMAND_PERMISSIONS_UPDATE')],
+  ['AUTO_MODERATION_ACTION_EXECUTION', require('./AUTO_MODERATION_ACTION_EXECUTION')],
+  ['AUTO_MODERATION_RULE_CREATE', require('./AUTO_MODERATION_RULE_CREATE')],
+  ['AUTO_MODERATION_RULE_DELETE', require('./AUTO_MODERATION_RULE_DELETE')],
+  ['AUTO_MODERATION_RULE_UPDATE', require('./AUTO_MODERATION_RULE_UPDATE')],
   ['CHANNEL_CREATE', require('./CHANNEL_CREATE')],
   ['CHANNEL_DELETE', require('./CHANNEL_DELETE')],
   ['CHANNEL_PINS_UPDATE', require('./CHANNEL_PINS_UPDATE')],

packages/discord.js/src/index.js

@@ -48,6 +48,7 @@ exports.version = require('../package.json').version;
 // Managers
 exports.ApplicationCommandManager = require('./managers/ApplicationCommandManager');
 exports.ApplicationCommandPermissionsManager = require('./managers/ApplicationCommandPermissionsManager');
+exports.AutoModerationRuleManager = require('./managers/AutoModerationRuleManager');
 exports.BaseGuildEmojiManager = require('./managers/BaseGuildEmojiManager');
 exports.CachedManager = require('./managers/CachedManager');
 exports.ChannelManager = require('./managers/ChannelManager');
@@ -88,6 +89,8 @@ exports.AnonymousGuild = require('./structures/AnonymousGuild');
 exports.Application = require('./structures/interfaces/Application');
 exports.ApplicationCommand = require('./structures/ApplicationCommand');
 exports.AutocompleteInteraction = require('./structures/AutocompleteInteraction');
+exports.AutoModerationActionExecution = require('./structures/AutoModerationActionExecution');
+exports.AutoModerationRule = require('./structures/AutoModerationRule');
 exports.Base = require('./structures/Base');
 exports.BaseGuild = require('./structures/BaseGuild');
 exports.BaseGuildEmoji = require('./structures/BaseGuildEmoji');

packages/discord.js/src/managers/AutoModerationRuleManager.js

@@ -0,0 +1,276 @@
+'use strict';
+
+const { Collection } = require('@discordjs/collection');
+const { Routes } = require('discord-api-types/v10');
+const CachedManager = require('./CachedManager');
+const AutoModerationRule = require('../structures/AutoModerationRule');
+
+/**
+ * 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;
+  }
+
+  _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.KeywordPreset}
+   * @property {?number} [mentionTotalLimit] The total number of role & user mentions allowed per message
+   */
+
+  /**
+   * 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.SendAlertMessage} 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
+   */
+
+  /**
+   * 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 using a `triggerType` of
+   * {@link AutoModerationRuleTriggerType.Keyword}, {@link AutoModerationRuleTriggerType.KeywordPreset},
+   * or {@link AutoModerationRuleTriggerType.MentionSpam}.</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.rest.post(Routes.guildAutoModerationRules(this.guild.id), {
+      body: {
+        name,
+        event_type: eventType,
+        trigger_type: triggerType,
+        trigger_metadata: triggerMetadata && {
+          keyword_filter: triggerMetadata.keywordFilter,
+          regex_patterns: triggerMetadata.regexPatterns,
+          presets: triggerMetadata.presets,
+          allow_list: triggerMetadata.allowList,
+          mention_total_limit: triggerMetadata.mentionTotalLimit,
+        },
+        actions: actions.map(action => ({
+          type: action.type,
+          metadata: {
+            duration_seconds: action.metadata?.durationSeconds,
+            channel_id: action.metadata?.channel && this.guild.channels.resolveId(action.metadata.channel),
+          },
+        })),
+        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.rest.patch(Routes.guildAutoModerationRule(this.guild.id, autoModerationRuleId), {
+      body: {
+        name,
+        event_type: eventType,
+        trigger_metadata: triggerMetadata && {
+          keyword_filter: triggerMetadata.keywordFilter,
+          regex_patterns: triggerMetadata.regexPatterns,
+          presets: triggerMetadata.presets,
+          allow_list: triggerMetadata.allowList,
+          mention_total_limit: triggerMetadata.mentionTotalLimit,
+        },
+        actions: actions?.map(action => ({
+          type: action.type,
+          metadata: {
+            duration_seconds: action.metadata?.durationSeconds,
+            channel_id: action.metadata?.channel && this.guild.channels.resolveId(action.metadata.channel),
+          },
+        })),
+        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.rest.get(Routes.guildAutoModerationRule(this.guild.id, autoModerationRule));
+    return this._add(data, cache);
+  }
+
+  async _fetchMany(options = {}) {
+    const data = await this.client.rest.get(Routes.guildAutoModerationRules(this.guild.id));
+
+    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.rest.delete(Routes.guildAutoModerationRule(this.guild.id, autoModerationRuleId), { reason });
+  }
+
+  /**
+   * 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}
+   */
+}
+
+module.exports = AutoModerationRuleManager;

packages/discord.js/src/structures/AutoModerationActionExecution.js

@@ -0,0 +1,87 @@
+'use strict';
+
+/**
+ * Represents the structure of an executed action when an {@link AutoModerationRule} is triggered.
+ */
+class AutoModerationActionExecution {
+  constructor(data, guild) {
+    /**
+     * The guild where this action was executed from.
+     * @type {Guild}
+     */
+    this.guild = guild;
+
+    /**
+     * The action that was executed.
+     * @type {AutoModerationAction}
+     */
+    this.action = data.action;
+
+    /**
+     * The id of the auto moderation rule this action belongs to.
+     * @type {Snowflake}
+     */
+    this.ruleId = data.rule_id;
+
+    /**
+     * The trigger type of the auto moderation rule which was triggered.
+     * @type {AutoModerationRuleTriggerType}
+     */
+    this.ruleTriggerType = data.rule_trigger_type;
+
+    /**
+     * The id of the user that triggered this action.
+     * @type {Snowflake}
+     */
+    this.userId = data.user_id;
+
+    /**
+     * The id of the channel where this action was triggered from.
+     * @type {?Snowflake}
+     */
+    this.channelId = data.channel_id ?? null;
+
+    /**
+     * The id of the message that triggered this action.
+     * @type {?Snowflake}
+     * <info>This will not be present if the message was blocked or the content was not part of any message.</info>
+     */
+    this.messageId = data.message_id ?? null;
+
+    /**
+     * The id of any system auto moderation messages posted as a result of this action.
+     * @type {?Snowflake}
+     */
+    this.alertSystemMessageId = data.alert_system_message_id ?? null;
+
+    /**
+     * The content that triggered this action.
+     * <info>This property requires the {@link GatewayIntentBits.MessageContent} privileged gateway intent.</info>
+     * @type {string}
+     */
+    this.content = data.content;
+
+    /**
+     * The word or phrase configured in the rule that triggered this action.
+     * @type {?string}
+     */
+    this.matchedKeyword = data.matched_keyword ?? null;
+
+    /**
+     * The substring in content that triggered this action.
+     * @type {?string}
+     */
+    this.matchedContent = data.matched_content ?? null;
+  }
+
+  /**
+   * The auto moderation rule this action belongs to.
+   * @type {?AutoModerationRule}
+   * @readonly
+   */
+  get autoModerationRule() {
+    return this.guild.autoModerationRules.cache.get(this.ruleId) ?? null;
+  }
+}
+
+module.exports = AutoModerationActionExecution;

packages/discord.js/src/structures/AutoModerationRule.js

@@ -0,0 +1,273 @@
+'use strict';
+
+const { Collection } = require('@discordjs/collection');
+const Base = require('./Base');
+
+/**
+ * Represents an auto moderation rule.
+ * @extends {Base}
+ */
+class AutoModerationRule extends Base {
+  constructor(client, data, guild) {
+    super(client);
+
+    /**
+     * The id of this auto moderation rule.
+     * @type {Snowflake}
+     */
+    this.id = data.id;
+
+    /**
+     * The guild this auto moderation rule is for.
+     * @type {Guild}
+     */
+    this.guild = guild;
+
+    /**
+     * The user that created this auto moderation rule.
+     * @type {Snowflake}
+     */
+    this.creatorId = data.creator_id;
+
+    /**
+     * The trigger type of this auto moderation rule.
+     * @type {AutoModerationRuleTriggerType}
+     */
+    this.triggerType = data.trigger_type;
+
+    this._patch(data);
+  }
+
+  _patch(data) {
+    if ('name' in data) {
+      /**
+       * The name of this auto moderation rule.
+       * @type {string}
+       */
+      this.name = data.name;
+    }
+
+    if ('event_type' in data) {
+      /**
+       * The event type of this auto moderation rule.
+       * @type {AutoModerationRuleEventType}
+       */
+      this.eventType = data.event_type;
+    }
+
+    if ('trigger_metadata' in data) {
+      /**
+       * Additional data used to determine whether an auto moderation rule should be triggered.
+       * @typedef {Object} AutoModerationTriggerMetadata
+       * @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.KeywordPreset}
+       * @property {?number} mentionTotalLimit The total number of role & user mentions allowed per message
+       */
+
+      /**
+       * The trigger metadata of the rule.
+       * @type {AutoModerationTriggerMetadata}
+       */
+      this.triggerMetadata = {
+        keywordFilter: data.trigger_metadata.keyword_filter ?? [],
+        regexPatterns: data.trigger_metadata.regex_patterns ?? [],
+        presets: data.trigger_metadata.presets ?? [],
+        allowList: data.trigger_metadata.allow_list ?? [],
+        mentionTotalLimit: data.trigger_metadata.mention_total_limit ?? null,
+      };
+    }
+
+    if ('actions' in data) {
+      /**
+       * An object containing information about an auto moderation rule action.
+       * @typedef {Object} AutoModerationAction
+       * @property {AutoModerationActionType} type The type of this auto moderation rule action
+       * @property {AutoModerationActionMetadata} metadata Additional metadata needed during execution
+       */
+
+      /**
+       * Additional data used when an auto moderation rule is executed.
+       * @typedef {Object} AutoModerationActionMetadata
+       * @property {?Snowflake} channelId The id of the channel to which content will be logged
+       * @property {?number} durationSeconds The timeout duration in seconds
+       */
+
+      /**
+       * The actions of this auto moderation rule.
+       * @type {AutoModerationAction[]}
+       */
+      this.actions = data.actions.map(action => ({
+        type: action.type,
+        metadata: {
+          durationSeconds: action.metadata.duration_seconds ?? null,
+          channelId: action.metadata.channel_id ?? null,
+        },
+      }));
+    }
+
+    if ('enabled' in data) {
+      /**
+       * Whether this auto moderation rule is enabled.
+       * @type {boolean}
+       */
+      this.enabled = data.enabled;
+    }
+
+    if ('exempt_roles' in data) {
+      /**
+       * The roles exempt by this auto moderation rule.
+       * @type {Collection<Snowflake, Role>}
+       */
+      this.exemptRoles = new Collection(
+        data.exempt_roles.map(exemptRole => [exemptRole, this.guild.roles.cache.get(exemptRole)]),
+      );
+    }
+
+    if ('exempt_channels' in data) {
+      /**
+       * The channels exempt by this auto moderation rule.
+       * @type {Collection<Snowflake, GuildChannel|ThreadChannel>}
+       */
+      this.exemptChannels = new Collection(
+        data.exempt_channels.map(exemptChannel => [exemptChannel, this.guild.channels.cache.get(exemptChannel)]),
+      );
+    }
+  }
+
+  /**
+   * Edits this auto moderation rule.
+   * @param {AutoModerationRuleEditOptions} options Options for editing this auto moderation rule
+   * @returns {Promise<AutoModerationRule>}
+   */
+  edit(options) {
+    return this.guild.autoModerationRules.edit(this.id, options);
+  }
+
+  /**
+   * Deletes this auto moderation rule.
+   * @param {string} [reason] The reason for deleting this auto moderation rule
+   * @returns {Promise<void>}
+   */
+  delete(reason) {
+    return this.guild.autoModerationRules.delete(this.id, reason);
+  }
+
+  /**
+   * Sets the name for this auto moderation rule.
+   * @param {string} name The name of this auto moderation rule
+   * @param {string} [reason] The reason for changing the name of this auto moderation rule
+   * @returns {Promise<AutoModerationRule>}
+   */
+  setName(name, reason) {
+    return this.edit({ name, reason });
+  }
+
+  /**
+   * Sets the event type for this auto moderation rule.
+   * @param {AutoModerationRuleEventType} eventType The event type of this auto moderation rule
+   * @param {string} [reason] The reason for changing the event type of this auto moderation rule
+   * @returns {Promise<AutoModerationRule>}
+   */
+  setEventType(eventType, reason) {
+    return this.edit({ eventType, reason });
+  }
+
+  /**
+   * Sets the keyword filter for this auto moderation rule.
+   * @param {string[]} keywordFilter The keyword filter of this auto moderation rule
+   * @param {string} [reason] The reason for changing the keyword filter of this auto moderation rule
+   * @returns {Promise<AutoModerationRule>}
+   */
+  setKeywordFilter(keywordFilter, reason) {
+    return this.edit({ triggerMetadata: { keywordFilter }, reason });
+  }
+
+  /**
+   * Sets the regular expression patterns for this auto moderation rule.
+   * @param {string[]} regexPatterns The regular expression patterns of this auto moderation rule
+   * <info>Only Rust-flavored regular expressions are supported.</info>
+   * @param {string} [reason] The reason for changing the regular expression patterns of this auto moderation rule
+   * @returns {Promise<AutoModerationRule>}
+   */
+  setRegexPatterns(regexPatterns, reason) {
+    return this.edit({ triggerMetadata: { regexPatterns }, reason });
+  }
+
+  /**
+   * Sets the presets for this auto moderation rule.
+   * @param {AutoModerationRuleKeywordPresetType[]} presets The presets of this auto moderation rule
+   * @param {string} [reason] The reason for changing the presets of this auto moderation rule
+   * @returns {Promise<AutoModerationRule>}
+   */
+  setPresets(presets, reason) {
+    return this.edit({ triggerMetadata: { presets }, reason });
+  }
+
+  /**
+   * Sets the allow list for this auto moderation rule.
+   * @param {string[]} allowList The allow list of this auto moderation rule
+   * @param {string} [reason] The reason for changing the allow list of this auto moderation rule
+   * @returns {Promise<AutoModerationRule>}
+   */
+  setAllowList(allowList, reason) {
+    return this.edit({ triggerMetadata: { allowList }, reason });
+  }
+
+  /**
+   * Sets the mention total limit for this auto moderation rule.
+   * @param {number} mentionTotalLimit The mention total limit of this auto moderation rule
+   * @param {string} [reason] The reason for changing the mention total limit of this auto moderation rule
+   * @returns {Promise<AutoModerationRule>}
+   */
+  setMentionTotalLimit(mentionTotalLimit, reason) {
+    return this.edit({ triggerMetadata: { mentionTotalLimit }, reason });
+  }
+
+  /**
+   * Sets the actions for this auto moderation rule.
+   * @param {AutoModerationActionOptions} actions The actions of this auto moderation rule
+   * @param {string} [reason] The reason for changing the actions of this auto moderation rule
+   * @returns {Promise<AutoModerationRule>}
+   */
+  setActions(actions, reason) {
+    return this.edit({ actions, reason });
+  }
+
+  /**
+   * Sets whether this auto moderation rule should be enabled.
+   * @param {boolean} [enabled=true] Whether to enable this auto moderation rule
+   * @param {string} [reason] The reason for enabling or disabling this auto moderation rule
+   * @returns {Promise<AutoModerationRule>}
+   */
+  setEnabled(enabled = true, reason) {
+    return this.edit({ enabled, reason });
+  }
+
+  /**
+   * Sets the exempt roles for this auto moderation rule.
+   * @param {Collection<Snowflake, Role>|RoleResolvable[]} [exemptRoles] The exempt roles of this auto moderation rule
+   * @param {string} [reason] The reason for changing the exempt roles of this auto moderation rule
+   * @returns {Promise<AutoModerationRule>}
+   */
+  setExemptRoles(exemptRoles, reason) {
+    return this.edit({ exemptRoles, reason });
+  }
+
+  /**
+   * Sets the exempt channels for this auto moderation rule.
+   * @param {Collection<Snowflake, GuildChannel|ThreadChannel>|GuildChannelResolvable[]} [exemptChannels]
+   * The exempt channels of this auto moderation rule
+   * @param {string} [reason] The reason for changing the exempt channels of this auto moderation rule
+   * @returns {Promise<AutoModerationRule>}
+   */
+  setExemptChannels(exemptChannels, reason) {
+    return this.edit({ exemptChannels, reason });
+  }
+}
+
+module.exports = AutoModerationRule;

packages/discord.js/src/structures/Guild.js

@@ -12,6 +12,7 @@ const Integration = require('./Integration');
 const Webhook = require('./Webhook');
 const WelcomeScreen = require('./WelcomeScreen');
 const { DiscordjsError, DiscordjsTypeError, ErrorCodes } = require('../errors');
+const AutoModerationRuleManager = require('../managers/AutoModerationRuleManager');
 const GuildApplicationCommandManager = require('../managers/GuildApplicationCommandManager');
 const GuildBanManager = require('../managers/GuildBanManager');
 const GuildChannelManager = require('../managers/GuildChannelManager');
@@ -99,6 +100,12 @@ class Guild extends AnonymousGuild {
      */
     this.scheduledEvents = new GuildScheduledEventManager(this);
 
+    /**
+     * A manager of the auto moderation rules of this guild.
+     * @type {AutoModerationRuleManager}
+     */
+    this.autoModerationRules = new AutoModerationRuleManager(this);
+
     if (!data) return;
     if (data.unavailable) {
       /**

packages/discord.js/src/structures/GuildAuditLogs.js

@@ -61,6 +61,17 @@ class GuildAuditLogs {
       }
     }
 
+    /**
+     * Cached auto moderation rules.
+     * @type {Collection<Snowflake, AutoModerationRule>}
+     * @private
+     */
+    this.autoModerationRules = data.auto_moderation_rules.reduce(
+      (autoModerationRules, autoModerationRule) =>
+        autoModerationRules.set(autoModerationRule.id, guild.autoModerationRules._add(autoModerationRule)),
+      new Collection(),
+    );
+
     /**
      * The entries for this guild's audit logs
      * @type {Collection<Snowflake, GuildAuditLogsEntry>}

packages/discord.js/src/structures/GuildAuditLogsEntry.js

@@ -2,6 +2,7 @@
 
 const { DiscordSnowflake } = require('@sapphire/snowflake');
 const { AuditLogOptionsType, AuditLogEvent } = require('discord-api-types/v10');
+const AutoModerationRule = require('./AutoModerationRule');
 const { GuildScheduledEvent } = require('./GuildScheduledEvent');
 const Integration = require('./Integration');
 const Invite = require('./Invite');
@@ -27,6 +28,7 @@ const Targets = {
   Sticker: 'Sticker',
   Thread: 'Thread',
   ApplicationCommand: 'ApplicationCommand',
+  AutoModeration: 'AutoModeration',
   Unknown: 'Unknown',
 };
 
@@ -46,10 +48,11 @@ const Targets = {
  * * A guild scheduled event
  * * A thread
  * * An application command
+ * * An auto moderation rule
  * * An object with an id key if target was deleted or fake entity
  * * An object where the keys represent either the new value or the old value
  * @typedef {?(Object|Guild|BaseChannel|User|Role|Invite|Webhook|GuildEmoji|Message|Integration|StageInstance|Sticker|
- * GuildScheduledEvent|ApplicationCommand)} AuditLogEntryTarget
+ * GuildScheduledEvent|ApplicationCommand|AutoModerationRule)} AuditLogEntryTarget
  */
 
 /**
@@ -223,6 +226,15 @@ class GuildAuditLogsEntry {
         };
         break;
 
+      case AuditLogEvent.AutoModerationBlockMessage:
+      case AuditLogEvent.AutoModerationFlagToChannel:
+      case AuditLogEvent.AutoModerationUserCommunicationDisabled:
+        this.extra = {
+          autoModerationRuleName: data.options.auto_moderation_rule_name,
+          autoModerationRuleTriggerType: data.options.auto_moderation_rule_trigger_type,
+        };
+        break;
+
       default:
         break;
     }
@@ -352,6 +364,20 @@ class GuildAuditLogsEntry {
         );
     } else if (targetType === Targets.ApplicationCommand) {
       this.target = logs.applicationCommands.get(data.target_id) ?? { id: data.target_id };
+    } else if (targetType === Targets.AutoModeration) {
+      this.target =
+        guild.autoModerationRules.cache.get(data.target_id) ??
+        new AutoModerationRule(
+          guild.client,
+          this.changes.reduce(
+            (o, c) => {
+              o[c.key] = c.new ?? c.old;
+              return o;
+            },
+            { id: data.target_id, guild_id: guild.id },
+          ),
+          guild,
+        );
     } else if (data.target_id) {
       this.target = guild[`${targetType.toLowerCase()}s`]?.cache.get(data.target_id) ?? { id: data.target_id };
     }
@@ -377,6 +403,7 @@ class GuildAuditLogsEntry {
     if (target < 110) return Targets.GuildScheduledEvent;
     if (target < 120) return Targets.Thread;
     if (target < 130) return Targets.ApplicationCommand;
+    if (target >= 140 && target < 150) return Targets.AutoModeration;
     return Targets.Unknown;
   }
 
@@ -402,6 +429,8 @@ class GuildAuditLogsEntry {
         AuditLogEvent.StickerCreate,
         AuditLogEvent.GuildScheduledEventCreate,
         AuditLogEvent.ThreadCreate,
+        AuditLogEvent.AutoModerationRuleCreate,
+        AuditLogEvent.AutoModerationBlockMessage,
       ].includes(action)
     ) {
       return 'Create';
@@ -427,6 +456,7 @@ class GuildAuditLogsEntry {
         AuditLogEvent.StickerDelete,
         AuditLogEvent.GuildScheduledEventDelete,
         AuditLogEvent.ThreadDelete,
+        AuditLogEvent.AutoModerationRuleDelete,
       ].includes(action)
     ) {
       return 'Delete';
@@ -450,6 +480,7 @@ class GuildAuditLogsEntry {
         AuditLogEvent.GuildScheduledEventUpdate,
         AuditLogEvent.ThreadUpdate,
         AuditLogEvent.ApplicationCommandPermissionUpdate,
+        AuditLogEvent.AutoModerationRuleUpdate,
       ].includes(action)
     ) {
       return 'Update';

packages/discord.js/src/util/APITypes.js

@@ -168,6 +168,26 @@
  * @see {@link https://discord-api-types.dev/api/discord-api-types-v10/enum/ApplicationFlags}
  */
 
+/**
+ * @external AutoModerationActionType
+ * @see {@link https://discord-api-types.dev/api/discord-api-types-v10/enum/AutoModerationActionType}
+ */
+
+/**
+ * @external AutoModerationRuleEventType
+ * @see {@link https://discord-api-types.dev/api/discord-api-types-v10/enum/AutoModerationRuleEventType}
+ */
+
+/**
+ * @external AutoModerationRuleTriggerType
+ * @see {@link https://discord-api-types.dev/api/discord-api-types-v10/enum/AutoModerationRuleTriggerType}
+ */
+
+/**
+ * @external AutoModerationRuleKeywordPresetType
+ * @see {@link https://discord-api-types.dev/api/discord-api-types-v10/enum/AutoModerationRuleKeywordPresetType}
+ */
+
 /**
  * @external AuditLogEvent
  * @see {@link https://discord-api-types.dev/api/discord-api-types-v10/enum/AuditLogEvent}

packages/discord.js/src/util/Constants.js

@@ -10,6 +10,7 @@ exports.MaxBulkDeletableMessageAge = 1_209_600_000;
 
 /**
  * The name of an item to be swept in Sweepers
+ * * `autoModerationRules`
  * * `applicationCommands` - both global and guild commands
  * * `bans`
  * * `emojis`
@@ -27,6 +28,7 @@ exports.MaxBulkDeletableMessageAge = 1_209_600_000;
  * @typedef {string} SweeperKey
  */
 exports.SweeperKeys = [
+  'autoModerationRules',
   'applicationCommands',
   'bans',
   'emojis',

packages/discord.js/src/util/Events.js

@@ -79,6 +79,10 @@
  */
 module.exports = {
   ApplicationCommandPermissionsUpdate: 'applicationCommandPermissionsUpdate',
+  AutoModerationActionExecution: 'autoModerationActionExecution',
+  AutoModerationRuleCreate: 'autoModerationRuleCreate',
+  AutoModerationRuleDelete: 'autoModerationRuleDelete',
+  AutoModerationRuleUpdate: 'autoModerationRuleUpdate',
   CacheSweep: 'cacheSweep',
   ChannelCreate: 'channelCreate',
   ChannelDelete: 'channelDelete',

packages/discord.js/src/util/Sweepers.js

@@ -78,6 +78,16 @@ class Sweepers {
     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.