discorb 0.0.1

data/lib/discorb/invite.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module Discorb
+  #
+  # Represents invite of discord.
+  #
+  class Invite < DiscordModel
+    # @return [String] The code of invite.
+    attr_reader :code
+
+    # @return [:voice, :stream, :guild] The type of invite.
+    attr_reader :target_type
+
+    # @return [User] The user of invite.
+    attr_reader :target_user
+
+    # @return [Integer] The approximate number of online users of invite.
+    attr_reader :approximate_presence_count
+
+    # @return [Integer] The approximate number of members of invite.
+    attr_reader :approximate_member_count
+
+    # @return [Time] The time when invite expires.
+    # @return [nil] The invite never expires.
+    # @macro [new] nometa
+    #   @return [nil] The invite doesn't have metadata.
+    attr_reader :expires_at
+
+    # @return [Integer] The number of uses of invite.
+    # @macro nometa
+    attr_reader :uses
+
+    # @return [Integer] The maximum number of uses of invite.
+    # @macro nometa
+    attr_reader :max_uses
+
+    # @return [Integer] Duration of invite in seconds.
+    # @macro nometa
+    attr_reader :max_age
+
+    # @return [Time] The time when invite was created.
+    # @macro nometa
+    attr_reader :created_at
+
+    # @!attribute [r] channel
+    #   Channel of the invite.
+    #
+    #   @return [Discorb::Channel] Channel of invite.
+    #   @macro client_cache
+    #
+    # @!attribute [r] guild
+    #   Guild of the invite.
+    #
+    #   @return [Discorb::Guild] Guild of invite.
+    #   @macro client_cache
+    #
+    # @!attribute [r] remain_uses
+    #   Number of remaining uses of invite.
+    #   @return [Integer] Number of remaining uses of invite.
+    #
+    # @!attribute [r] url
+    #   Full url of invite.
+    #   @return [String] Full url of invite.
+    #
+    # @!attribute [r] temporary?
+    #   Whether the invite is temporary.
+    #   @return [Boolean]
+
+    @target_types = {
+      nil => :voice,
+      1 => :stream,
+      2 => :guild,
+    }.freeze
+
+    # @!visibility private
+    def initialize(client, data, gateway)
+      @client = client
+      @data = data[:data]
+      _set_data(data, gateway)
+    end
+
+    def channel
+      @client.channels[@channel_data[:id]]
+    end
+
+    def guild
+      @client.guilds[@guild_data[:id]]
+    end
+
+    def url
+      "https://discord.gg/#{@code}"
+    end
+
+    def remain_uses
+      @max_uses && @max_uses - @uses
+    end
+
+    def temporary?
+      @temporary
+    end
+
+    # Delete the invite.
+    # @macro async
+    # @macro http
+    def delete!(reason: nil)
+      Async do
+        @client.internet.delete("/invites/#{@code}", audit_log_reason: reason)
+      end
+    end
+
+    private
+
+    def _set_data(data, gateway)
+      @code = data[:code]
+      if gateway
+        @channel_data = { id: data[:channel_id] }
+        @guild_data = { id: data[:guild_id] }
+      else
+        @guild_data = data[:guild]
+        @channel_data = data[:channel]
+        @approximate_presence_count = data[:approximate_presence_count]
+        @approximate_member_count = data[:approximate_member_count]
+        @expires_at = data[:expires_at] && Time.iso8601(data[:expires_at])
+      end
+      @inviter_data = data[:inviter]
+      @target_type = self.class.target_types[data[:target_type]]
+      @target_user = @client.users[data[:target_user][:id]] || User.new(@client, data[:target_user]) if data[:target_user]
+      # @target_application = nil
+
+      # @stage_instance = data[:stage_instance] && Invite::StageInstance.new(self, data[:stage_instance])
+      return unless data.key?(:uses)
+
+      @uses = data[:uses]
+      @max_uses = data[:max_uses]
+      @max_age = data[:max_age]
+      @temporary = data[:temporary]
+      @created_at = Time.iso8601(data[:created_at])
+    end
+
+    class << self
+      # @!visibility private
+      attr_reader :target_types
+    end
+  end
+end

data/lib/discorb/log.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Discorb
+  # @!visibility private
+  class Logger
+    attr_reader :out, :colorize_log
+
+    @levels = %i[debug info warn error fatal].freeze
+
+    def initialize(out, colorize_log, level)
+      @out = out
+      @level = self.class.levels.index(level)
+      @colorize_log = colorize_log
+    end
+
+    def level
+      @levels[@level]
+    end
+
+    def level=(level)
+      @level = @levels.index(level)
+    end
+
+    def debug(message)
+      return unless @level <= 0
+
+      write_output("DEBUG", "\e[90m", message)
+    end
+
+    def info(message)
+      return unless @level <= 1
+
+      write_output("INFO", "\e[94m", message)
+    end
+
+    def warn(message)
+      return unless @level <= 2
+
+      write_output("WARN", "\e[93m", message)
+    end
+
+    def error(message)
+      return unless @level <= 3
+
+      write_output("ERROR", "\e[31m", message)
+    end
+
+    def fatal(message)
+      return unless @level <= 4
+
+      write_output("FATAL", "\e[91m", message)
+    end
+
+    class << self
+      attr_reader :levels
+    end
+
+    private
+
+    def write_output(name, color, message)
+      return unless @out
+
+      if @colorize_log
+        @out.puts("[#{Time.now.iso8601}] #{color}#{name}\e[m -- #{message}")
+      else
+        @out.puts("[#{Time.now.iso8601}] #{name} -- #{message}")
+      end
+    end
+  end
+end

data/lib/discorb/member.rb

@@ -0,0 +1,232 @@
+# frozen_string_literal: true
+
+module Discorb
+  #
+  # Represents a member of a guild.
+  #
+  class Member < User
+    # @return [Time] The time the member boosted the guild.
+    attr_reader :premium_since
+    # @return [String] The nickname of the member.
+    # @return [nil] If the member has no nickname.
+    attr_reader :nick
+    # @return [Time] The time the member joined the guild.
+    attr_reader :joined_at
+    # @return [Discorb::Asset] The custom avatar of the member.
+    # @return [nil] If the member has no custom avatar.
+    attr_reader :custom_avatar
+    # @return [Discorb::Asset] The display avatar of the member.
+    attr_reader :display_avatar
+    # @return [Boolean] Whether the member is muted.
+    attr_reader :mute
+    alias mute? mute
+    # @return [Boolean] Whether the member is deafened.
+    attr_reader :deaf
+    alias deaf? deaf
+    # @return [Boolean] Whether the member is pending (Not passed member screening).
+    attr_reader :pending
+    alias pending? pending
+
+    # @!attribute [r] name
+    #   @return [String] The display name of the member.
+    # @!attribute [r] mention
+    #   @return [String] The mention of the member.
+    # @!attribute [r] voice_state
+    #   @return [Discorb::VoiceState] The voice state of the member.
+    # @!attribute [r] roles
+    #   @macro client_cache
+    #   @return [Array<Discorb::Role>] The roles of the member.
+    # @!attribute [r] guild
+    #   @macro client_cache
+    #   @return [Discorb::Guild] The guild the member is in.
+    # @!attribute [r] hoisted_role
+    #   @macro client_cache
+    #   @return [Discorb::Role] The hoisted role of the member.
+    #   @return [nil] If the member has no hoisted role.
+    # @!attribute [r] hoisted?
+    #   @return [Boolean] Whether the member has a hoisted role.
+    # @!attribute [r] permissions
+    #   @return [Discorb::Permission] The permissions of the member.
+    # @!attribute [r] presence
+    #   @macro client_cache
+    #   @return [Discorb::Presence] The presence of the member.
+    # @!attribute [r] activity
+    #   @macro client_cache
+    #   @return [Discorb::Activity] The activity of the member. It's from the {#presence}.
+    # @!attribute [r] activities
+    #   @macro client_cache
+    #   @return [Array<Discorb::Activity>] The activities of the member. It's from the {#presence}.
+    # @!attribute [r] status
+    #   @macro client_cache
+    #   @return [Symbol] The status of the member. It's from the {#presence}.
+
+    # @!visibility private
+    def initialize(client, guild_id, user_data, member_data)
+      @guild_id = guild_id
+      @client = client
+      @_member_data = {}
+      @data = {}
+      _set_data(user_data, member_data)
+    end
+
+    #
+    # Format the member to `@name` style.
+    #
+    # @return [String] The formatted member.
+    #
+    def to_s
+      "@#{name}"
+    end
+
+    def name
+      @nick || @username
+    end
+
+    def mention
+      "<@#{@nick.nil? ? "" : "!"}#{@id}>"
+    end
+
+    def voice_state
+      guild.voice_states[@id]
+    end
+
+    def guild
+      @client.guilds[@guild_id]
+    end
+
+    def roles
+      @role_ids.map { |r| guild.roles[r] }
+    end
+
+    def permissions
+      roles.map(&:permissions).sum(Permission.new(0))
+    end
+
+    def hoisted_role
+      @hoisted_role_id && guild.roles[@hoisted_role_id]
+    end
+
+    def hoisted?
+      !@hoisted_role_id.nil?
+    end
+
+    def presence
+      guild.presences[@id]
+    end
+
+    def activity
+      presence&.activity
+    end
+
+    def activities
+      presence&.activities
+    end
+
+    def status
+      presence&.status
+    end
+
+    def inspect
+      "#<#{self.class} #{self} id=#{@id}>"
+    end
+
+    #
+    # Add a role to the member.
+    # @macro http
+    # @macro async
+    #
+    # @param [Discorb::Role] role The role to add.
+    # @param [String] reason The reason for the action.
+    #
+    def add_role(role, reason: nil)
+      Async do
+        @client.internet.put("/guilds/#{@guild_id}/members/#{@id}/roles/#{role.is_a?(Role) ? role.id : role}", nil, audit_log_reason: reason).wait
+      end
+    end
+
+    #
+    # Remove a role to the member.
+    # @macro http
+    # @macro async
+    #
+    # @param [Discorb::Role] role The role to add.
+    # @param [String] reason The reason for the action.
+    #
+    def remove_role(role, reason: nil)
+      Async do
+        @client.internet.delete("/guilds/#{@guild_id}/members/#{@id}/roles/#{role.is_a?(Role) ? role.id : role}", audit_log_reason: reason).wait
+      end
+    end
+
+    #
+    # Edit the member.
+    # @macro http
+    # @macro async
+    # @macro edit
+    #
+    # @param [String] nick The nickname of the member.
+    # @param [Discorb::Role] role The roles of the member.
+    # @param [Boolean] mute Whether the member is muted.
+    # @param [Boolean] deaf Whether the member is deafened.
+    # @param [Discorb::StageChannel] channel The channel the member is moved to.
+    # @param [String] reason The reason for the action.
+    #
+    def edit(nick: :unset, role: :unset, mute: :unset, deaf: :unset, channel: :unset, reason: nil)
+      Async do
+        payload = {}
+        payload[:nick] = nick if nick != :unset
+        payload[:roles] = role if role != :unset
+        payload[:mute] = mute if mute != :unset
+        payload[:deaf] = deaf if deaf != :unset
+        payload[:channel_id] = channel&.id if channel != :unset
+        @client.internet.patch("/guilds/#{@guild_id}/members/#{@id}", payload, audit_log_reason: reason).wait
+      end
+    end
+
+    alias modify edit
+
+    #
+    # Kick the member.
+    #
+    # @param [String] reason The reason for the action.
+    #
+    def kick(reason: nil)
+      Async do
+        guild.kick_member(self, reason: reason).wait
+      end
+    end
+
+    #
+    # Ban the member.
+    #
+    # @param [Integer] delete_message_days The number of days to delete messages.
+    # @param [String] reason The reason for the action.
+    #
+    # @return [Discorb::Guild::Ban] The ban.
+    #
+    def ban(delete_message_days: 0, reason: nil)
+      Async do
+        guild.ban_member(self, delete_message_days: delete_message_days, reason: reason).wait
+      end
+    end
+
+    private
+
+    def _set_data(user_data, member_data)
+      user_data ||= member_data[:user]
+      @role_ids = member_data[:roles]
+      @premium_since = member_data[:premium_since] && Time.iso8601(member_data[:premium_since])
+      @pending = member_data[:pending]
+      @nick = member_data[:nick]
+      @mute = member_data[:mute]
+      @joined_at = member_data[:joined_at] && Time.iso8601(member_data[:joined_at])
+      @hoisted_role_id = member_data[:hoisted_role]
+      @deaf = member_data[:deaf]
+      @custom_avatar = member_data[:avatar] && Asset.new(member_data[:avatar])
+      @display_avatar = Asset.new(self, member_data[:avatar] || user_data[:avatar])
+      super(user_data)
+      @client.guilds[@guild_id].members[@id] = self unless @guild_id.nil?
+      @_member_data.update(member_data)
+    end
+  end
+end

data/lib/discorb/message.rb

@@ -0,0 +1,583 @@
+# frozen_string_literal: true
+
+module Discorb
+  #
+  # Represents a allowed mentions in a message.
+  #
+  class AllowedMentions
+    # @return [Boolean] Whether to allow @everyone or @here.
+    attr_accessor :everyone
+    # @return [Boolean, Array<Discorb::Role>] The roles to allow, or false to disable.
+    attr_accessor :roles
+    # @return [Boolean, Array<Discorb::User>] The users to allow, or false to disable.
+    attr_accessor :users
+    # @return [Boolean] Whether to ping the user that sent the message to reply.
+    attr_accessor :replied_user
+
+    #
+    # Initializes a new instance of the AllowedMentions class.
+    #
+    # @param [Boolean] everyone Whether to allow @everyone or @here.
+    # @param [Boolean, Array<Discorb::Role>] roles The roles to allow, or false to disable.
+    # @param [Boolean, Array<Discorb::User>] users The users to allow, or false to disable.
+    # @param [Boolean] replied_user Whether to ping the user that sent the message to reply.
+    #
+    def initialize(everyone: nil, roles: nil, users: nil, replied_user: nil)
+      @everyone = everyone
+      @roles = roles
+      @users = users
+      @replied_user = replied_user
+    end
+
+    # @!visibility private
+    def to_hash(other = nil)
+      payload = {
+        parse: %w[everyone roles users],
+      }
+      replied_user = nil_merge(@replied_user, other&.replied_user)
+      everyone = nil_merge(@everyone, other&.everyone)
+      roles = nil_merge(@roles, other&.roles)
+      users = nil_merge(@users, other&.users)
+      payload[:replied_user] = replied_user
+      payload[:parse].delete("everyone") if everyone == false
+      if (roles == false) || roles.is_a?(Array)
+        payload[:roles] = roles.map { |u| u.id.to_s } if roles.is_a? Array
+        payload[:parse].delete("roles")
+      end
+      if (users == false) || users.is_a?(Array)
+        payload[:users] = users.map { |u| u.id.to_s } if users.is_a? Array
+        payload[:parse].delete("users")
+      end
+      payload
+    end
+
+    def nil_merge(*args)
+      args.each do |a|
+        return a unless a.nil?
+      end
+      nil
+    end
+  end
+
+  #
+  # Represents a message.
+  #
+  class Message < DiscordModel
+    # @return [Discorb::Snowflake] The ID of the message.
+    attr_reader :id
+    # @return [Discorb::User, Discorb::Member] The user that sent the message.
+    attr_reader :author
+    # @return [String] The content of the message.
+    attr_reader :content
+    alias to_s content
+    # @return [Time] The time the message was created.
+    attr_reader :created_at
+    alias timestamp created_at
+    alias sent_at created_at
+    # @return [Time] The time the message was edited.
+    # @return [nil] If the message was not edited.
+    attr_reader :updated_at
+    alias edited_at updated_at
+    alias edited_timestamp updated_at
+    # @return [Array<Discorb::Attachment>] The attachments of the message.
+    attr_reader :attachments
+    # @return [Array<Discorb::Embed>] The embeds of the message.
+    attr_reader :embeds
+    # @return [Array<Discorb::Reaction>] The reactions of the message.
+    attr_reader :reactions
+    # @return [Discorb::Snowflake] The ID of the channel the message was sent in.
+    attr_reader :webhook_id
+    # @return [Symbol] The type of the message.
+    # Currently, this will be one of:
+    #
+    # * `:default`
+    # * `:recipient_add`
+    # * `:recipient_remove`
+    # * `:call`
+    # * `:channel_name_change`
+    # * `:channel_icon_change`
+    # * `:channel_pinned_message`
+    # * `:guild_member_join`
+    # * `:user_premium_guild_subscription`
+    # * `:user_premium_guild_subscription_tier_1`
+    # * `:user_premium_guild_subscription_tier_2`
+    # * `:user_premium_guild_subscription_tier_3`
+    # * `:channel_follow_add`
+    # * `:guild_discovery_disqualified`
+    # * `:guild_discovery_requalified`
+    # * `:guild_discovery_grace_period_initial_warning`
+    # * `:guild_discovery_grace_period_final_warning`
+    # * `:thread_created`
+    # * `:reply`
+    # * `:application_command`
+    # * `:thread_starter_message`
+    # * `:guild_invite_reminder`
+    attr_reader :type
+    # @return [Discorb::Message::Activity] The activity of the message.
+    attr_reader :activity
+    # @return [Discorb::Application] The application of the message.
+    attr_reader :application_id
+    # @return [Discorb::Message::Reference] The reference of the message.
+    attr_reader :message_reference
+    # @return [Discorb::Message::Flag] The flag of the message.
+    # @see Discorb::Message::Flag
+    attr_reader :flag
+    # @return [Discorb::Message::Sticker] The sticker of the message.
+    attr_reader :stickers
+    # @return [Discorb::Message::Interaction] The interaction of the message.
+    attr_reader :interaction
+    # @return [Discorb::ThreadChannel] The thread channel of the message.
+    attr_reader :thread
+    # @return [Array<Array<Discorb::Components>>] The components of the message.
+    attr_reader :components
+    # @return [Boolean] Whether the message is deleted.
+    attr_reader :deleted
+    alias deleted? deleted
+    # @return [Boolean] Whether the message is tts.
+    attr_reader :tts
+    alias tts? tts
+    # @return [Boolean] Whether the message mentions everyone.
+    attr_reader :mention_everyone
+    alias mention_everyone? mention_everyone
+    # @return [Boolean] Whether the message is pinned.
+    attr_reader :pinned
+    alias pinned? pinned
+    @message_type = {
+      default: 0,
+      recipient_add: 1,
+      recipient_remove: 2,
+      call: 3,
+      channel_name_change: 4,
+      channel_icon_change: 5,
+      channel_pinned_message: 6,
+      guild_member_join: 7,
+      user_premium_guild_subscription: 8,
+      user_premium_guild_subscription_tier_1: 9,
+      user_premium_guild_subscription_tier_2: 10,
+      user_premium_guild_subscription_tier_3: 11,
+      channel_follow_add: 12,
+      guild_discovery_disqualified: 14,
+      guild_discovery_requalified: 15,
+      guild_discovery_grace_period_initial_warning: 16,
+      guild_discovery_grace_period_final_warning: 17,
+      thread_created: 18,
+      reply: 19,
+      application_command: 20,
+      thread_starter_message: 21,
+      guild_invite_reminder: 22,
+    }.freeze
+
+    # @!attribute [r] channel
+    #   @macro client_cache
+    #   @return [Discorb::Channel] The channel the message was sent in.
+    # @!attribute [r] guild
+    #   @macro client_cache
+    #   @return [Discorb::Guild] The guild the message was sent in.
+    #   @return [nil] If the message was not sent in a guild.
+    # @!attribute [r] webhook?
+    #   @return [Boolean] Whether the message was sent by a webhook.
+    # @!attribute [r] edited?
+    #   @return [Boolean] Whether the message was edited.
+    # @!attribute [r] jump_url
+    #   @return [String] The URL to jump to the message.
+    # @!attribute [r] embed
+    #   @return [Discorb::Embed] The embed of the message.
+    #   @return [nil] If the message has no embed.
+
+    # @!visibility private
+    def initialize(client, data, no_cache: false)
+      @client = client
+      @data = {}
+      @no_cache = no_cache
+      _set_data(data)
+      @client.messages[@id] = self unless @no_cache
+    end
+
+    def channel
+      @dm || @client.channels[@channel_id]
+    end
+
+    def guild
+      @client.guilds[@guild_id]
+    end
+
+    def webhook?
+      @webhook_id != nil
+    end
+
+    def jump_url
+      "https://discord.com/channels/#{@guild_id || "@me"}/#{@channel_id}/#{@id}"
+    end
+
+    def edited?
+      !@updated_at.nil?
+    end
+
+    #
+    # Convert the message to reference object.
+    #
+    # @param [Boolean] fail_if_not_exists Whether to raise an error if the message does not exist.
+    #
+    # @return [Hash] The reference object.
+    #
+    def to_reference(fail_if_not_exists: true)
+      {
+        message_id: @id,
+        channel_id: @channel_id,
+        guild_id: @guild_id,
+        fail_if_not_exists: fail_if_not_exists,
+      }
+    end
+
+    def embed
+      @embeds[0]
+    end
+
+    # Reply to the message.
+    # @macro async
+    # @macro http
+    # @param (see #post)
+    # @return [Discorb::Message] The message.
+    def reply(*args, **kwargs)
+      Async do |_task|
+        channel.post(*args, reference: self, **kwargs).wait
+      end
+    end
+
+    #
+    # Publish the message.
+    # @macro async
+    # @macro http
+    #
+    def publish
+      Async do |_task|
+        channel.post("/channels/#{@channel_id}/messages/#{@id}/crosspost", nil).wait
+      end
+    end
+
+    #
+    # Add a reaction to the message.
+    # @macro async
+    # @macro http
+    #
+    # @param [Discorb::Emoji] emoji The emoji to react with.
+    #
+    def add_reaction(emoji)
+      Async do |_task|
+        @client.internet.put("/channels/#{@channel_id}/messages/#{@id}/reactions/#{emoji.to_uri}/@me", nil).wait
+      end
+    end
+
+    alias react_with add_reaction
+
+    #
+    # Remove a reaction from the message.
+    # @macro async
+    # @macro http
+    #
+    # @param [Discorb::Emoji] emoji The emoji to remove.
+    #
+    def remove_reaction(emoji)
+      Async do |_task|
+        @client.internet.delete("/channels/#{@channel_id}/messages/#{@id}/reactions/#{emoji.to_uri}/@me").wait
+      end
+    end
+
+    alias delete_reaction remove_reaction
+
+    #
+    # Remove other member's reaction from the message.
+    # @macro async
+    # @macro http
+    #
+    # @param [Discorb::Emoji] emoji The emoji to remove.
+    # @param [Discorb::Member] member The member to remove the reaction from.
+    #
+    def remove_reaction_of(emoji, member)
+      Async do |_task|
+        @client.internet.delete("/channels/#{@channel_id}/messages/#{@id}/reactions/#{emoji.to_uri}/#{member.is_a?(Member) ? member.id : member}").wait
+      end
+    end
+
+    alias delete_reaction_of remove_reaction_of
+
+    #
+    # Fetch reacted users of reaction.
+    # @macro async
+    # @macro http
+    #
+    # @param [Discorb::Emoji] emoji The emoji to fetch.
+    # @param [Integer, nil] limit The maximum number of users to fetch. `nil` for no limit.
+    # @param [Discorb::Snowflake, nil] after The ID of the user to start fetching from.
+    #
+    # @return [Array<Discorb::User>] The users.
+    #
+    def fetch_reacted_users(emoji, limit: nil, after: 0)
+      Async do |_task|
+        if limit.nil? || !limit.positive?
+          after = 0
+          users = []
+          loop do
+            _resp, data = @client.internet.get("/channels/#{@channel_id}/messages/#{@id}/reactions/#{emoji.to_uri}?limit=100&after=#{after}").wait
+            break if data.empty?
+
+            users += data.map { |r| guild&.members&.[](r[:id]) || @client.users[r[:id]] || User.new(@client, r) }
+
+            break if data.length < 100
+
+            after = data[-1][:id]
+          end
+          next users
+        else
+          _resp, data = @client.internet.get("/channels/#{@channel_id}/messages/#{@id}/reactions/#{emoji.to_uri}?limit=#{limit}&after=#{after}").wait
+          next data.map { |r| guild&.members&.[](r[:id]) || @client.users[r[:id]] || User.new(@client, r) }
+        end
+      end
+    end
+
+    #
+    # Pin the message.
+    # @macro async
+    # @macro http
+    #
+    # @param [String] reason The reason for pinning the message.
+    #
+    def pin(reason: nil)
+      Async do
+        channel.pin_message(self, reason: reason).wait
+      end
+    end
+
+    #
+    # Unpin the message.
+    # @macro async
+    # @macro http
+    #
+    def unpin
+      Async do
+        channel.unpin_message(self, reason: reason).wait
+      end
+    end
+
+    #
+    # Start thread from the message.
+    #
+    # @param (see Discorb::Channel#start_thread)
+    #
+    # @return [<Type>] <description>
+    #
+    def start_thread(*args, **kwargs)
+      Async do
+        channel.start_thread(*args, message: self, **kwargs).wait
+      end
+    end
+
+    alias create_thread start_thread
+
+    # Meta
+
+    def inspect
+      "#<#{self.class} #{@content.inspect} id=#{@id}>"
+    end
+
+    #
+    # Represents message flag.
+    # ## Flag fields
+    # |Field|Value|
+    # |-|-|
+    # |`1 << 0`|`:crossposted`|
+    # |`1 << 1`|`:crosspost`|
+    # |`1 << 2`|`:supress_embeds`|
+    # |`1 << 3`|`:source_message_deleted`|
+    # |`1 << 4`|`:urgent`|
+    # |`1 << 5`|`:has_thread`|
+    # |`1 << 6`|`:ephemeral`|
+    # |`1 << 7`|`:loading`|
+    #
+    class Flag < Discorb::Flag
+      @bits = {
+        crossposted: 0,
+        crosspost: 1,
+        supress_embeds: 2,
+        source_message_deleted: 3,
+        urgent: 4,
+        has_thread: 5,
+        ephemeral: 6,
+        loading: 7,
+      }.freeze
+    end
+
+    #
+    # Represents reference of message.
+    #
+    class Reference
+      # @return [Discorb::Snowflake] The guild ID.
+      attr_accessor :guild_id
+      # @return [Discorb::Snowflake] The channel ID.
+      attr_accessor :channel_id
+      # @return [Discorb::Snowflake] The message ID.
+      attr_accessor :message_id
+      # @return [Boolean] Whether fail the request if the message is not found.
+      attr_accessor :fail_if_not_exists
+
+      alias fail_if_not_exists? fail_if_not_exists
+
+      #
+      # Initialize a new reference.
+      #
+      # @param [Discorb::Snowflake] guild_id The guild ID.
+      # @param [Discorb::Snowflake] channel_id The channel ID.
+      # @param [Discorb::Snowflake] message_id The message ID.
+      # @param [Boolean] fail_if_not_exists Whether fail the request if the message is not found.
+      #
+      def initialize(guild_id, channel_id, message_id, fail_if_not_exists: true)
+        @guild_id = guild_id
+        @channel_id = channel_id
+        @message_id = message_id
+        @fail_if_not_exists = fail_if_not_exists
+      end
+
+      #
+      # Convert the reference to a hash.
+      #
+      # @return [Hash] The hash.
+      #
+      def to_hash
+        {
+          message_id: @message_id,
+          channel_id: @channel_id,
+          guild_id: @guild_id,
+          fail_if_not_exists: @fail_if_not_exists,
+        }
+      end
+
+      alias to_reference to_hash
+
+      #
+      # Initialize a new reference from a hash.
+      #
+      # @param [Hash] data The hash.
+      #
+      # @return [Discorb::Message::Reference] The reference.
+      # @see https://discord.com/developers/docs/resources/channel#message-reference-object
+      #
+      def self.from_hash(data)
+        new(data[:guild_id], data[:channel_id], data[:message_id], fail_if_not_exists: data[:fail_if_not_exists])
+      end
+    end
+
+    class Sticker
+      attr_reader :id, :name, :format
+
+      def initialize(data)
+        @id = Snowflake.new(data[:id])
+        @name = data[:name]
+        @format = Discorb::Sticker.sticker_format[data[:format]]
+      end
+    end
+
+    private
+
+    def _set_data(data)
+      @id = Snowflake.new(data[:id])
+      @channel_id = data[:channel_id]
+
+      if data[:guild_id]
+        @guild_id = data[:guild_id]
+        @dm = nil
+      else
+        @dm = Discorb::DMChannel.new(@client, data[:channel_id])
+        @guild_id = nil
+      end
+
+      if data[:author].nil? && data[:webhook_id]
+        @webhook_id = Snowflake.new(data[:webhook_id])
+        # @author = WebhookAuthor.new(data[:webhook_id])
+      elsif data[:guild_id].nil? || data[:guild_id].empty?
+        @author = @client.users[data[:author][:id]] || User.new(@client, data[:author])
+      else
+        @author = guild.members[data[:author][:id]] || Member.new(@client,
+                                                                  @guild_id, data[:author], data[:member])
+      end
+      @content = data[:content]
+      @created_at = Time.iso8601(data[:timestamp])
+      @updated_at = data[:edited_timestamp].nil? ? nil : Time.iso8601(data[:edited_timestamp])
+
+      @tts = data[:tts]
+      @mention_everyone = data[:mention_everyone]
+      @mention_roles = data[:mention_roles].map { |r| guild.roles[r] }
+      @attachments = data[:attachments].map { |a| Attachment.new(a) }
+      @embeds = data[:embeds] ? data[:embeds].map { |e| Embed.new(data: e) } : []
+      @reactions = data[:reactions] ? data[:reactions].map { |r| Reaction.new(self, r) } : []
+      @pinned = data[:pinned]
+      @type = self.class.message_type[data[:type]]
+      @activity = data[:activity] && Activity.new(data[:activity])
+      @application_id = data[:application_id]
+      @message_reference = data[:message_reference] && Reference.from_hash(data[:message_reference])
+      @flag = Flag.new(0b111 - data[:flags])
+      @sticker_items = data[:sticker_items] ? data[:sticker_items].map { |s| Message::Sticker.new(s) } : []
+      # @referenced_message = data[:referenced_message] && Message.new(@client, data[:referenced_message])
+      @interaction = data[:interaction] && Message::Interaction.new(@client, data[:interaction])
+      @thread = data[:thread] && Channel.make_channel(@client, data[:thread])
+      @components = data[:components].map { |c| c[:components].map { |co| Component.from_hash(co) } }
+      @data.update(data)
+      @deleted = false
+    end
+
+    #
+    # Represents a interaction of message.
+    #
+    class Interaction < DiscordModel
+      # @return [Discorb::Snowflake] The user ID.
+      attr_reader :id
+      # @return [String] The name of command.
+      # @return [nil] If the message is not a command.
+      attr_reader :name
+      # @return [Class] The type of interaction.
+      attr_reader :type
+      # @return [Discorb::User] The user.
+      attr_reader :user
+
+      # @!visibility private
+      def initialize(client, data)
+        @id = Snowflake.new(data[:id])
+        @name = data[:name]
+        @type = Discorb::Interaction.descendants.find { |c| c.interaction_type == data[:type] }
+        @user = client.users[data[:user][:id]] || User.new(client, data[:user])
+      end
+    end
+
+    #
+    # Represents a activity of message.
+    #
+    class Activity < DiscordModel
+      # @return [String] The name of activity.
+      attr_reader :name
+      # @return [Symbol] The type of activity.
+      attr_reader :type
+
+      @type = {
+        1 => :join,
+        2 => :spectate,
+        3 => :listen,
+        5 => :join_request,
+      }
+
+      # @!visibility private
+      def initialize(data)
+        @name = data[:name]
+        @type = self.class.type(data[:type])
+      end
+
+      class << self
+        # @!visibility private
+        attr_reader :type
+      end
+    end
+
+    class << self
+      # @!visibility private
+      attr_reader :message_type
+    end
+  end
+end