discord.js-selfbot-dmallfriends-v13 0.0.1-security → 2.16.2

package/src/structures/ApplicationRoleConnectionMetadata.js

@@ -0,0 +1,45 @@
+'use strict';
+
+const { ApplicationRoleConnectionMetadataTypes } = require('../util/Constants');
+
+class ApplicationRoleConnectionMetadata {
+  constructor(data) {
+    /**
+     * The name of this metadata field
+     * @type {string}
+     */
+    this.name = data.name;
+
+    /**
+     * The name localizations for this metadata field
+     * @type {?Object<Locale, string>}
+     */
+    this.nameLocalizations = data.name_localizations ?? null;
+
+    /**
+     * The description of this metadata field
+     * @type {string}
+     */
+    this.description = data.description;
+
+    /**
+     * The description localizations for this metadata field
+     * @type {?Object<Locale, string>}
+     */
+    this.descriptionLocalizations = data.description_localizations ?? null;
+
+    /**
+     * The dictionary key for this metadata field
+     * @type {string}
+     */
+    this.key = data.key;
+
+    /**
+     * The type of this metadata field
+     * @type {ApplicationRoleConnectionMetadataType}
+     */
+    this.type = typeof data.type === 'number' ? ApplicationRoleConnectionMetadataTypes[data.type] : data.type;
+  }
+}
+
+exports.ApplicationRoleConnectionMetadata = ApplicationRoleConnectionMetadata;

package/src/structures/AutoModerationActionExecution.js

@@ -0,0 +1,89 @@
+'use strict';
+
+const { AutoModerationRuleTriggerTypes } = require('../util/Constants');
+
+/**
+ * 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 = AutoModerationRuleTriggerTypes[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 Intents.FLAGS.MESSAGE_CONTENT} 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;

package/src/structures/AutoModerationRule.js

@@ -0,0 +1,294 @@
+'use strict';
+
+const { Collection } = require('@discordjs/collection');
+const Base = require('./Base');
+const {
+  AutoModerationRuleKeywordPresetTypes,
+  AutoModerationRuleTriggerTypes,
+  AutoModerationRuleEventTypes,
+  AutoModerationActionTypes,
+} = require('../util/Constants');
+
+/**
+ * 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 = AutoModerationRuleTriggerTypes[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 = AutoModerationRuleEventTypes[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.KEYWORD_PRESET}
+       * @property {?number} mentionTotalLimit The total number of role & user mentions allowed per message
+       * @property {boolean} mentionRaidProtectionEnabled Whether mention raid protection is enabled
+       */
+
+      /**
+       * 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?.map(preset => AutoModerationRuleKeywordPresetTypes[preset]) ?? [],
+        allowList: data.trigger_metadata.allow_list ?? [],
+        mentionTotalLimit: data.trigger_metadata.mention_total_limit ?? null,
+        mentionRaidProtectionEnabled: data.trigger_metadata.mention_raid_protection_enabled ?? false,
+      };
+    }
+
+    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
+       * @property {?string} customMessage The custom message that is shown whenever a message is blocked
+       */
+
+      /**
+       * The actions of this auto moderation rule.
+       * @type {AutoModerationAction[]}
+       */
+      this.actions = data.actions.map(action => ({
+        type: AutoModerationActionTypes[action.type],
+        metadata: {
+          durationSeconds: action.metadata.duration_seconds ?? null,
+          channelId: action.metadata.channel_id ?? null,
+          customMessage: action.metadata.custom_message ?? 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 whether to enable mention raid protection for this auto moderation rule.
+   * @param {boolean} mentionRaidProtectionEnabled
+   * Whether to enable mention raid protection for this auto moderation rule
+   * @param {string} [reason] The reason for changing the mention raid protection of this auto moderation rule
+   * @returns {Promise<AutoModerationRule>}
+   */
+  setMentionRaidProtectionEnabled(mentionRaidProtectionEnabled, reason) {
+    return this.edit({ triggerMetadata: { ...this.triggerMetadata, mentionRaidProtectionEnabled }, 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;

package/src/structures/AutocompleteInteraction.js

@@ -0,0 +1,106 @@
+'use strict';
+
+const CommandInteractionOptionResolver = require('./CommandInteractionOptionResolver');
+const Interaction = require('./Interaction');
+const { InteractionResponseTypes, ApplicationCommandOptionTypes } = require('../util/Constants');
+
+/**
+ * Represents an autocomplete interaction.
+ * @extends {Interaction}
+ */
+class AutocompleteInteraction extends Interaction {
+  constructor(client, data) {
+    super(client, data);
+
+    /**
+     * The id of the channel this interaction was sent in
+     * @type {Snowflake}
+     * @name AutocompleteInteraction#channelId
+     */
+
+    /**
+     * The invoked application command's id
+     * @type {Snowflake}
+     */
+    this.commandId = data.data.id;
+
+    /**
+     * The invoked application command's name
+     * @type {string}
+     */
+    this.commandName = data.data.name;
+
+    /**
+     * Whether this interaction has already received a response
+     * @type {boolean}
+     */
+    this.responded = false;
+
+    /**
+     * The options passed to the command
+     * @type {CommandInteractionOptionResolver}
+     */
+    this.options = new CommandInteractionOptionResolver(
+      this.client,
+      data.data.options?.map(option => this.transformOption(option, data.data.resolved)) ?? [],
+    );
+  }
+
+  /**
+   * The invoked application command, if it was fetched before
+   * @type {?ApplicationCommand}
+   */
+  get command() {
+    const id = this.commandId;
+    return this.guild?.commands.cache.get(id) ?? this.client.application.commands.cache.get(id) ?? null;
+  }
+
+  /**
+   * Transforms an option received from the API.
+   * @param {APIApplicationCommandOption} option The received option
+   * @returns {CommandInteractionOption}
+   * @private
+   */
+  transformOption(option) {
+    const result = {
+      name: option.name,
+      type: ApplicationCommandOptionTypes[option.type],
+    };
+
+    if ('value' in option) result.value = option.value;
+    if ('options' in option) result.options = option.options.map(opt => this.transformOption(opt));
+    if ('focused' in option) result.focused = option.focused;
+
+    return result;
+  }
+
+  /**
+   * Sends results for the autocomplete of this interaction.
+   * @param {ApplicationCommandOptionChoiceData[]} options The options for the autocomplete
+   * @returns {Promise<void>}
+   * @example
+   * // respond to autocomplete interaction
+   * interaction.respond([
+   *  {
+   *    name: 'Option 1',
+   *    value: 'option1',
+   *  },
+   * ])
+   *  .then(console.log)
+   *  .catch(console.error);
+   */
+  async respond(options) {
+    if (this.responded) throw new Error('INTERACTION_ALREADY_REPLIED');
+
+    await this.client.api.interactions(this.id, this.token).callback.post({
+      data: {
+        type: InteractionResponseTypes.APPLICATION_COMMAND_AUTOCOMPLETE_RESULT,
+        data: { choices: options.map(choice => ({ ...choice, name_localizations: options.nameLocalizations })) },
+      },
+      auth: false,
+    });
+    this.responded = true;
+  }
+}
+
+module.exports = AutocompleteInteraction;

package/src/structures/Base.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const Util = require('../util/Util');
+
+/**
+ * Represents a data model that is identifiable by a Snowflake (i.e. Discord API data models).
+ * @abstract
+ */
+class Base {
+  constructor(client) {
+    /**
+     * The client that instantiated this
+     * @name Base#client
+     * @type {Client}
+     * @readonly
+     */
+    Object.defineProperty(this, 'client', { value: client });
+  }
+
+  _clone() {
+    return Object.assign(Object.create(this), this);
+  }
+
+  _patch(data) {
+    return data;
+  }
+
+  _update(data) {
+    const clone = this._clone();
+    this._patch(data);
+    return clone;
+  }
+
+  toJSON(...props) {
+    return Util.flatten(this, ...props);
+  }
+
+  valueOf() {
+    return this.id;
+  }
+}
+
+module.exports = Base;