discordrb 3.4.3 → 3.6.0

data/lib/discordrb/data/snapshot.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Discordrb
+  # A partial and immutable copy of a message that has been forwarded.
+  class Snapshot
+    # @return [Integer] the message type of the message snapshot.
+    attr_reader :type
+
+    # @return [String] the text content of the message snapshot.
+    attr_reader :content
+
+    # @return [Array<Embed>] the embeds attached to the message snapshot.
+    attr_reader :embeds
+
+    # @return [Array<Attachment>] the files attached to the message snapshot.
+    attr_reader :attachments
+
+    # @return [Time] the time at which the message snapshot was created.
+    attr_reader :created_at
+
+    # @return [Time, nil] the time at which the message snapshot was edited.
+    attr_reader :edited_at
+
+    # @return [Integer] the flags that have been set on the message snapshot.
+    attr_reader :flags
+
+    # @return [Array<User>] the users that were mentioned in the message snapshot.
+    attr_reader :mentions
+
+    # @return [Array<Component>] the interaction components associated with the message snapshot.
+    attr_reader :components
+
+    # @!visibility private
+    def initialize(data, bot)
+      @bot = bot
+      @type = data['type']
+      @flags = data['flags'] || 0
+      @content = data['content']
+      @mention_roles = data['mention_roles']&.map(&:resolve_id) || []
+      @embeds = data['embeds']&.map { |embed| Embed.new(embed, self) } || []
+      @attachments = data['attachments']&.map { |file| Attachment.new(file, self, bot) } || []
+      @created_at = data['timestamp'] ? Time.parse(data['timestamp']) : nil
+      @edited_at = data['edited_timestamp'] ? Time.parse(data['edited_timestamp']) : nil
+      @mentions = data['mentions']&.map { |mention| bot.ensure_user(mention) } || []
+      @components = data['components']&.map { |component| Components.from_data(component, bot) } || []
+    end
+
+    # Check whether the message snapshot has been edited.
+    # @return [true, false] whether the snapshot was edited or not.
+    def edited?
+      !@edited_at.nil?
+    end
+
+    # Check whether the message snapshot contains any custom emojis.
+    # @return [true, false]  whether or not any emoji were used in the snapshot.
+    def emojis?
+      emojis.any?
+    end
+
+    # Get the custom emojis that were used in the message snapshot.
+    # @return [Array<Emoji>] the emojis used in the message snapshot.
+    def emojis
+      return [] if @content.nil? || @content.empty?
+
+      @emojis ||= @bot.parse_mentions(@content).select { |parsed| parsed.is_a?(Emoji) }
+    end
+
+    # Get the roles that were mentioned in the message snapshot.
+    # @return [Array<Role>] the roles that were mentioned in the message snapshot.
+    # @note this can only resolve roles in servers that the bot has access to via {Bot#servers}.
+    def role_mentions
+      return [] if @mention_roles.empty?
+
+      return @role_mentions if @role_mentions
+
+      roles = @bot.servers.values.flat_map(&:roles)
+
+      @role_mentions = @mention_roles.filter_map { |id| roles.find { |r| r.id == id } }
+    end
+
+    # Get the buttons that were used in the message snapshot.
+    # @return [Array<Components::Button>] the button components used in the message snapshot.
+    def buttons
+      buttons = @components.flat_map do |component|
+        case component
+        when Components::Button
+          component
+        when Components::ActionRow
+          component.buttons
+        end
+      end
+
+      buttons.compact
+    end
+
+    # @see Discordrb::Message::FLAGS
+    Message::FLAGS.each do |name, value|
+      define_method("#{name}?") do
+        @flags.anybits?(value)
+      end
+    end
+
+    # @see Discordrb::Message::TYPES
+    Message::TYPES.each do |name, value|
+      define_method("#{name}?") do
+        @type == value
+      end
+    end
+  end
+end

data/lib/discordrb/data/user.rb

@@ -3,10 +3,33 @@
 module Discordrb
   # Mixin for the attributes users should have
   module UserAttributes
+    # rubocop:disable Naming/VariableNumber
+    FLAGS = {
+      staff: 1 << 0,
+      partner: 1 << 1,
+      hypesquad: 1 << 2,
+      bug_hunter_level_1: 1 << 3,
+      hypesquad_online_house_1: 1 << 6,
+      hypesquad_online_house_2: 1 << 7,
+      hypesquad_online_house_3: 1 << 8,
+      premium_early_supporter: 1 << 9,
+      team_pseudo_user: 1 << 10,
+      bug_hunter_level_2: 1 << 14,
+      verified_bot: 1 << 16,
+      verified_developer: 1 << 17,
+      certified_moderator: 1 << 18,
+      bot_http_interactions: 1 << 19,
+      active_developer: 1 << 22
+    }.freeze
+    # rubocop:enable Naming/VariableNumber
+
     # @return [String] this user's username
     attr_reader :username
     alias_method :name, :username
 
+    # @return [String, nil] this user's global name
+    attr_reader :global_name
+
     # @return [String] this user's discriminator which is used internally to identify users with identical usernames.
     attr_reader :discriminator
     alias_method :discrim, :discriminator
@@ -17,10 +40,35 @@ module Discordrb
     attr_reader :bot_account
     alias_method :bot_account?, :bot_account
 
+    # @return [true, false] whether this is fake user for a webhook message
+    attr_reader :webhook_account
+    alias_method :webhook_account?, :webhook_account
+    alias_method :webhook?, :webhook_account
+
     # @return [String] the ID of this user's current avatar, can be used to generate an avatar URL.
     # @see #avatar_url
     attr_accessor :avatar_id
 
+    # @return [true, false] whether the user is an offical Discord System user (part of the urgent message system).
+    attr_reader :system_account
+    alias_method :system_account?, :system_account
+
+    # @return [AvatarDecoration, nil] the current user's avatar decoration, or nil if the user doesn't have one.
+    attr_reader :avatar_decoration
+
+    # @return [Collectibles] the collectibles that this user has collected.
+    attr_reader :collectibles
+
+    # @return [PrimaryServer, nil] the server tag the user has adopted, or nil if the user doesn't have one displayed.
+    attr_reader :primary_server
+    alias_method :server_tag, :primary_server
+
+    # Utility function to get Discord's display name of a user not in server
+    # @return [String] the name the user displays as (global_name if they have one, username otherwise)
+    def display_name
+      global_name || username
+    end
+
     # Utility function to mention users in messages
     # @return [String] the mention code in the form of <@id>
     def mention
@@ -29,18 +77,45 @@ module Discordrb
 
     # Utility function to get Discord's distinct representation of a user, i.e. username + discriminator
     # @return [String] distinct representation of user
+    # TODO: Maybe change this method again after discriminator removal ?
     def distinct
-      "#{@username}##{@discriminator}"
+      if @discriminator && @discriminator != '0'
+        "#{@username}##{@discriminator}"
+      else
+        @username.to_s
+      end
     end
 
     # Utility function to get a user's avatar URL.
     # @param format [String, nil] If `nil`, the URL will default to `webp` for static avatars, and will detect if the user has a `gif` avatar. You can otherwise specify one of `webp`, `jpg`, `png`, or `gif` to override this. Will always be PNG for default avatars.
     # @return [String] the URL to the avatar image.
+    # TODO: Maybe change this method again after discriminator removal ?
     def avatar_url(format = nil)
-      return API::User.default_avatar(@discriminator) unless @avatar_id
+      unless @avatar_id
+        return API::User.default_avatar(@discriminator, legacy: true) if @discriminator && @discriminator != '0'
+
+        return API::User.default_avatar(@id)
+      end
 
       API::User.avatar_url(@id, @avatar_id, format)
     end
+
+    # @return [Integer] the public flags on a user's account
+    attr_reader :public_flags
+
+    FLAGS.each do |name, value|
+      define_method("#{name}?") do
+        @public_flags.anybits?(value)
+      end
+    end
+
+    # Utility function to get a user's banner URL.
+    # @param format [String, nil] If `nil`, the URL will default to `png` for static banners and will detect if the user has a `gif` banner.
+    # You can otherwise specify one of `webp`, `jpg`, `png`, or `gif` to override this.
+    # @return [String, nil] the URL to the banner image or nil if the user doesn't have one.
+    def banner_url(format = nil)
+      API::User.banner_url(@id, banner_id, format) if banner_id
+    end
   end
 
   # User on Discord, including internal data like discriminators
@@ -63,17 +138,23 @@ module Discordrb
       @bot = bot
 
       @username = data['username']
+      @global_name = data['global_name']
       @id = data['id'].to_i
       @discriminator = data['discriminator']
       @avatar_id = data['avatar']
-      @roles = {}
       @activities = Discordrb::ActivitySet.new
-
-      @bot_account = false
-      @bot_account = true if data['bot']
+      @public_flags = data['public_flags'] || 0
+      @bot_account = data['bot'] || false
+      @webhook_account = data['_webhook'] || false
 
       @status = :offline
       @client_status = process_client_status(data['client_status'])
+      @banner_id = data['banner']
+      @system_account = data['system'] || false
+      @avatar_decoration = process_avatar_decoration(data['avatar_decoration_data'])
+      @collectibles = Collectibles.new(data['collectibles'] || {}, bot)
+
+      @primary_server = process_primary_server(data['primary_guild'] || {})
     end
 
     # Get a user's PM channel or send them a PM
@@ -109,13 +190,47 @@ module Discordrb
       pm.send_file(file, caption: caption, filename: filename, spoiler: spoiler)
     end
 
-    # Set the user's name
+    # @return [String, nil] the ID of this user's current banner, can be used to generate a banner URL.
+    # @see #banner_url
+    def banner_id
+      @banner_id ||= JSON.parse(API::User.resolve(@bot.token, @id))['banner']
+    end
+
+    # Set the user's username
     # @note for internal use only
     # @!visibility private
     def update_username(username)
       @username = username
     end
 
+    # Set the user's global_name
+    # @note For internal use only.
+    # @!visibility private
+    def update_global_name(global_name)
+      @global_name = global_name
+    end
+
+    # Set the user's avatar_decoration
+    # @note For internal use only.
+    # @!visibility private
+    def update_avatar_decoration(decoration)
+      @avatar_decoration = process_avatar_decoration(decoration)
+    end
+
+    # Set the user's collectibles
+    # @note For internal use only.
+    # @!visibility private
+    def update_collectibles(collectibles)
+      @collectibles = Collectibles.new(collectibles || {}, @bot)
+    end
+
+    # Set the user's primary server
+    # @note For internal use only.
+    # @!visibility private
+    def update_primary_server(server)
+      @primary_server = process_primary_server(server || {})
+    end
+
     # Set the user's presence data
     # @note for internal use only
     # @!visibility private
@@ -154,14 +269,19 @@ module Discordrb
       @bot.profile.id == @id
     end
 
-    # @return [true, false] whether this user is a fake user for a webhook message
-    def webhook?
-      @discriminator == Message::ZERO_DISCRIM
+    # @!visibility private
+    def process_client_status(client_status)
+      (client_status || {}).to_h { |k, v| [k.to_sym, v.to_sym] }
+    end
+
+    # @!visibility private
+    def process_avatar_decoration(decoration)
+      decoration ? AvatarDecoration.new(decoration, @bot) : nil
     end
 
     # @!visibility private
-    def process_client_status(client_status)
-      (client_status || {}).map { |k, v| [k.to_sym, v.to_sym] }.to_h
+    def process_primary_server(server)
+      PrimaryServer.new(server, @bot) if server['identity_enabled']
     end
 
     # @!method offline?

data/lib/discordrb/data/voice_region.rb

@@ -28,6 +28,7 @@ module Discordrb
     # @return [true, false] whether this is a custom voice region (used for events/etc)
     attr_reader :custom
 
+    # @!visibility private
     def initialize(data)
       @id = data['id']
 

data/lib/discordrb/data/webhook.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require 'discordrb/webhooks/builder'
+require 'discordrb/webhooks/view'
+
 module Discordrb
   # A webhook on a server channel
   class Webhook
@@ -28,6 +31,7 @@ module Discordrb
     # @return [Member, User, nil] the user object of the owner or nil if the webhook was requested using the token.
     attr_reader :owner
 
+    # @!visibility private
     def initialize(data, bot)
       @bot = bot
 
@@ -81,13 +85,13 @@ module Discordrb
     def update(data)
       # Only pass a value for avatar if the key is defined as sending nil will delete the
       data[:avatar] = avatarise(data[:avatar]) if data.key?(:avatar)
-      data[:channel_id] = data[:channel].resolve_id
+      data[:channel_id] = data[:channel]&.resolve_id
       data.delete(:channel)
-      update_webhook(data)
+      update_webhook(**data)
     end
 
     # Deletes the webhook.
-    # @param reason [String] The reason the invite is being deleted.
+    # @param reason [String] The reason the webhook is being deleted.
     def delete(reason = nil)
       if token?
         API::Webhook.token_delete_webhook(@token, @id, reason)
@@ -96,10 +100,100 @@ module Discordrb
       end
     end
 
+    # Execute a webhook.
+    # @param content [String] The content of the message. May be 2000 characters long at most.
+    # @param username [String] The username the webhook will display as. If this is not set, the default username set in the webhook's settings.
+    # @param avatar_url [String] The URL of an image file to be used as an avatar. If this is not set, the default avatar from the webhook's
+    # @param tts [true, false] Whether this message should use TTS or not. By default, it doesn't.
+    # @param file [File] File to be sent together with the message. Mutually exclusive with embeds; a webhook message can contain
+    #   either a file to be sent or embeds.
+    # @param embeds [Array<Webhooks::Embed, Hash>] Embeds to attach to this message.
+    # @param allowed_mentions [AllowedMentions, Hash] Mentions that are allowed to ping in the `content`.
+    # @param wait [true, false] Whether Discord should wait for the message to be successfully received by clients, or
+    #   whether it should return immediately after sending the message. If `true` a {Message} object will be returned.
+    # @yield [builder] Gives the builder to the block to add additional steps, or to do the entire building process.
+    # @yieldparam builder [Builder] The builder given as a parameter which is used as the initial step to start from.
+    # @example Execute the webhook with kwargs
+    #   client.execute(
+    #     content: 'Testing',
+    #     username: 'discordrb',
+    #     embeds: [
+    #       { timestamp: Time.now.iso8601, title: 'testing', image: { url: 'https://i.imgur.com/PcMltU7.jpg' } }
+    #     ])
+    # @example Execute the webhook with an already existing builder
+    #   builder = Discordrb::Webhooks::Builder.new # ...
+    #   client.execute(builder)
+    # @example Execute the webhook by building a new message
+    #   client.execute do |builder|
+    #     builder.content = 'Testing'
+    #     builder.username = 'discordrb'
+    #     builder.add_embed do |embed|
+    #       embed.timestamp = Time.now
+    #       embed.title = 'Testing'
+    #       embed.image = Discordrb::Webhooks::EmbedImage.new(url: 'https://i.imgur.com/PcMltU7.jpg')
+    #     end
+    #   end
+    # @return [Message, nil] If `wait` is `true`, a {Message} will be returned. Otherwise this method will return `nil`.
+    # @note This is only available to webhooks with publically exposed tokens. This excludes channel follow webhooks and webhooks retrieved
+    #   via the audit log.
+    def execute(content: nil, username: nil, avatar_url: nil, tts: nil, file: nil, embeds: nil, allowed_mentions: nil, wait: true, builder: nil, components: nil)
+      raise Discordrb::Errors::UnauthorizedWebhook unless @token
+
+      params = { content: content, username: username, avatar_url: avatar_url, tts: tts, file: file, embeds: embeds, allowed_mentions: allowed_mentions }
+
+      builder ||= Webhooks::Builder.new
+      view = Webhooks::View.new
+
+      yield(builder, view) if block_given?
+
+      data = builder.to_json_hash.merge(params.compact)
+      components ||= view
+
+      resp = API::Webhook.token_execute_webhook(@token, @id, wait, data[:content], data[:username], data[:avatar_url], data[:tts], data[:file], data[:embeds], data[:allowed_mentions], nil, components.to_a)
+
+      Message.new(JSON.parse(resp), @bot) if wait
+    end
+
+    # Delete a message created by this webhook.
+    # @param message [Message, String, Integer] The ID of the message to delete.
+    def delete_message(message)
+      raise Discordrb::Errors::UnauthorizedWebhook unless @token
+
+      API::Webhook.token_delete_message(@token, @id, message.resolve_id)
+    end
+
+    # Edit a message created by this webhook.
+    # @param message [Message, String, Integer] The ID of the message to edit.
+    # @param content [String] The content of the message. May be 2000 characters long at most.
+    # @param embeds [Array<Webhooks::Embed, Hash>] Embeds to be attached to the message.
+    # @param allowed_mentions [AllowedMentions, Hash] Mentions that are allowed to ping in the `content`.
+    # @param builder [Builder, nil] The builder to start out with, or nil if one should be created anew.
+    # @yield [builder] Gives the builder to the block to add additional steps, or to do the entire building process.
+    # @yieldparam builder [Webhooks::Builder] The builder given as a parameter which is used as the initial step to start from.
+    # @return [Message] The updated message.
+    # @param components [View, Array<Hash>] Interaction components to associate with this message.
+    # @note When editing `allowed_mentions`, it will update visually in the client but not alert the user with a notification.
+    def edit_message(message, content: nil, embeds: nil, allowed_mentions: nil, builder: nil, components: nil)
+      raise Discordrb::Errors::UnauthorizedWebhook unless @token
+
+      params = { content: content, embeds: embeds, allowed_mentions: allowed_mentions }.compact
+
+      builder ||= Webhooks::Builder.new
+      view ||= Webhooks::View.new
+
+      yield(builder, view) if block_given?
+
+      data = builder.to_json_hash.merge(params.compact)
+      components ||= view
+
+      resp = API::Webhook.token_edit_message(@token, @id, message.resolve_id, data[:content], data[:embeds], data[:allowed_mentions], components.to_a)
+      Message.new(JSON.parse(resp), @bot)
+    end
+
     # Utility function to get a webhook's avatar URL.
     # @return [String] the URL to the avatar image
     def avatar_url
-      return API::User.default_avatar unless @avatar
+      return API::User.default_avatar(@id) unless @avatar
 
       API::User.avatar_url(@id, @avatar)
     end
@@ -118,11 +212,7 @@ module Discordrb
     private
 
     def avatarise(avatar)
-      if avatar.respond_to? :read
-        "data:image/jpg;base64,#{Base64.strict_encode64(avatar.read)}"
-      else
-        avatar
-      end
+      avatar.respond_to?(:read) ? Discordrb.encode64(avatar) : avatar
     end
 
     def update_internal(data)

data/lib/discordrb/data.rb

@@ -12,6 +12,7 @@ require 'discordrb/api/invite'
 require 'discordrb/api/user'
 require 'discordrb/api/webhook'
 require 'discordrb/webhooks/embeds'
+require 'discordrb/webhooks/view'
 require 'discordrb/paginator'
 require 'time'
 require 'base64'
@@ -37,3 +38,11 @@ require 'discordrb/data/integration'
 require 'discordrb/data/server'
 require 'discordrb/data/webhook'
 require 'discordrb/data/audit_logs'
+require 'discordrb/data/interaction'
+require 'discordrb/data/component'
+require 'discordrb/data/avatar_decoration'
+require 'discordrb/data/collectibles'
+require 'discordrb/data/primary_server'
+require 'discordrb/data/server_preview'
+require 'discordrb/data/call'
+require 'discordrb/data/snapshot'

data/lib/discordrb/errors.rb

@@ -20,6 +20,9 @@ module Discordrb
     # Raised when the bot gets a HTTP 502 error, which is usually caused by Cloudflare.
     class CloudflareError < RuntimeError; end
 
+    # Raised when using a webhook method without an associated token.
+    class UnauthorizedWebhook < RuntimeError; end
+
     # Generic class for errors denoted by API error codes
     class CodeError < RuntimeError
       class << self
@@ -29,8 +32,11 @@ module Discordrb
 
       # Create a new error with a particular message (the code should be defined by the class instance variable)
       # @param message [String] the message to use
-      def initialize(message)
+      # @param errors [Hash] API errors
+      def initialize(message, errors = nil)
         @message = message
+
+        @errors = errors ? flatten_errors(errors) : []
       end
 
       # @return [Integer] The error code represented by this error.
@@ -38,15 +44,50 @@ module Discordrb
         self.class.code
       end
 
+      # @return [String] A message including the message and flattened errors.
+      def full_message(*)
+        error_list = @errors.collect { |err| "\t- #{err}" }
+
+        "#{@message}\n#{error_list.join("\n")}"
+      end
+
       # @return [String] This error's represented message
       attr_reader :message
+
+      # @return [Hash] More precise errors
+      attr_reader :errors
+
+      private
+
+      # @!visibility hidden
+      # Flattens errors into a more easily read format.
+      # @example Flattening errors of a bad field
+      #   flatten_errors(data['errors'])
+      #   # => ["embed.fields[0].name: This field is required", "embed.fields[0].value: This field is required"]
+      def flatten_errors(err, prev_key = nil)
+        err.collect do |key, sub_err|
+          if prev_key
+            key = /\A\d+\Z/.match?(key) ? "#{prev_key}[#{key}]" : "#{prev_key}.#{key}"
+          end
+
+          if (errs = sub_err['_errors'])
+            "#{key}: #{errs.map { |e| e['message'] }.join(' ')}"
+          elsif sub_err['message'] || sub_err['code']
+            "#{"#{sub_err['code']}: " if sub_err['code']}#{err_msg}"
+          elsif sub_err.is_a? String
+            sub_err
+          else
+            flatten_errors(sub_err, key)
+          end
+        end.flatten
+      end
     end
 
     # Create a new code error class
     # rubocop:disable Naming/MethodName
     def self.Code(code)
       classy = Class.new(CodeError)
-      classy.instance_variable_set('@code', code)
+      classy.instance_variable_set(:@code, code)
 
       @code_classes ||= {}
       @code_classes[code] = classy
@@ -58,7 +99,7 @@ module Discordrb
     # @param code [Integer] The code to check
     # @return [Class] the error class for the given code
     def self.error_class_for(code)
-      @code_classes[code]
+      @code_classes[code] || Code(code)
     end
 
     # Used when Discord doesn't provide a more specific code
@@ -133,6 +174,9 @@ module Discordrb
     # Unauthorized
     Unauthorized = Unauthorised = Code(40_001)
 
+    # Unable to bulk ban any users
+    UnableToBulkBanUsers = Code(500_000)
+
     # Missing Access
     MissingAccess = Code(50_001)
 

data/lib/discordrb/events/await.rb

@@ -25,7 +25,7 @@ module Discordrb::Events
     #   @see Await#attributes
     delegate :key, :type, :attributes, to: :await
 
-    # For internal use only
+    # @!visibility private
     def initialize(await, event, bot)
       @await = await
       @event = event

data/lib/discordrb/events/channels.rb

@@ -29,9 +29,10 @@ module Discordrb::Events
     #   @see Channel#server
     delegate :name, :server, :type, :owner_id, :recipients, :topic, :user_limit, :position, :permission_overwrites, to: :channel
 
+    # @!visibility private
     def initialize(data, bot)
       @bot = bot
-      @channel = bot.channel(data['id'].to_i)
+      @channel = data.is_a?(Discordrb::Channel) ? data : bot.channel(data['id'].to_i)
     end
   end
 
@@ -83,6 +84,7 @@ module Discordrb::Events
     # @return [Integer, nil] the channel's owner ID if this is a group channel
     attr_reader :owner_id
 
+    # @!visibility private
     def initialize(data, bot)
       @bot = bot
 
@@ -134,6 +136,7 @@ module Discordrb::Events
 
     delegate :id, to: :recipient
 
+    # @!visibility private
     def initialize(data, bot)
       @bot = bot
 
@@ -168,6 +171,40 @@ module Discordrb::Events
     end
   end
 
+  # Raised when a message is pinned or unpinned.
+  class ChannelPinsUpdateEvent < Event
+    # @return [Time, nil] Time at which the most recent pinned message was pinned.
+    attr_reader :last_pin_timestamp
+
+    # @return [Channel] The channel this event originates from.
+    attr_reader :channel
+
+    # @return [Server, nil] The server this event originates from.
+    attr_reader :server
+
+    # @!visibility private
+    def initialize(data, bot)
+      @bot = bot
+
+      @server = bot.server(data['guild_id']) if data['guild_id']
+      @channel = bot.channel(data['channel_id'])
+      @last_pin_timestamp = Time.iso8601(data['last_pin_timestamp']) if data['last_pin_timestamp']
+    end
+  end
+
+  # Event handler for ChannelPinsUpdateEvent.
+  class ChannelPinsUpdateEventHandler < EventHandler
+    def matches?(event)
+      # Check for the proper event type.
+      return false unless event.is_a? ChannelPinsUpdateEvent
+
+      [
+        matches_all(@attributes[:server], event.server) { |a, e| a.resolve_id == e&.id },
+        matches_all(@attributes[:channel], event.channel) { |a, e| a.resolve_id == e.id }
+      ].reduce(true, &:&)
+    end
+  end
+
   # Raised when a user is added to a private channel
   class ChannelRecipientAddEvent < ChannelRecipientEvent; end