discorb 0.15.0 → 0.17.0

data/lib/discorb/app_command/handler.rb

@@ -1,9 +1,6 @@
 # frozen_string_literal: true
 
 module Discorb
-  #
-  # Handles application commands.
-  #
   module ApplicationCommand
     #
     # Module to handle application commands.
@@ -12,44 +9,83 @@ module Discorb
       #
       # Add new top-level command.
       #
-      # @param [String] command_name Command name.
-      # @param [String] description Command description.
-      # @param [Hash{String => Hash{:description => String, :optional => Boolean, :type => Object}}] options Command options.
+      # @param [String, Hash{Symbol => String}] command_name Command name.
+      #  If hash is passed, it must be a pair of Language code and Command name, and `:default` key is required.
+      #  You can use `_` instead of `-` in language code.
+      # @param [String, Hash{Symbol => String}] description Command description.
+      #   If hash is passed, it must be a pair of Language code and Command description, and `:default` key is required.
+      #  You can use `_` instead of `-` in language code.
+      # @param [Hash{String => Hash{:description => String, :optional => Boolean, :type => Object}}] options
+      #  Command options.
       #   The key is the option name, the value is a hash with the following keys:
       #
       #   | Key | Type | Description |
       #   | --- | --- | --- |
-      #   | `:description` | `String` | Description of the option. |
-      #   | `:required` | Whether the argument is required. `optional` will be used if not specified. |
-      #   | `:optional` | Whether the argument is optional. `required` will be used if not specified. |
+      #   | `:description` | `String` \| `Hash{Symbol => String}` |
+      #     Description of the option. If hash is passed, it must be a pair of Language code and description,
+      #     and `:default` key is required. You can use `_` instead of `-` in language code. |
+      #   | `:required` | Boolean(true | false) |
+      #     Whether the argument is required. `optional` will be used if not specified. |
+      #   | `:optional` | Boolean(true | false) |
+      #     Whether the argument is optional. `required` will be used if not specified. |
       #   | `:type` | `Object` | Type of the option. |
-      #   | `:choice` | `Hash{String => String, Integer, Float}` | Type of the option. |
+      #   | `:choices` | `Hash{String => String, Integer, Float}` | Type of the option. |
+      #   | `:choices_localizations` | `Hash{String => Hash{Symbol => String}}` |
+      #      Localization of the choice. Key must be the name of a choice. |
       #   | `:default` | `Object` | Default value of the option. |
       #   | `:channel_types` | `Array<Class<Discorb::Channel>>` | Type of the channel option. |
       #   | `:autocomplete` | `Proc` | Autocomplete function. |
       #   | `:range` | `Range` | Range of the option. Only valid for numeric options. (`:int`, `:float`) |
       #
-      # @param [Array<#to_s>, false, nil] guild_ids Guild IDs to set the command to. `false` to global command, `nil` to use default.
+      # @param [Array<#to_s>, false, nil] guild_ids
+      #  Guild IDs to set the command to. `false` to global command, `nil` to use default.
+      # @param [Boolean] dm_permission Whether the command is available in DM.
+      # @param [Discorb::Permission] default_permission The default permission of the command.
       # @param [Proc] block Command block.
       #
-      # @return [Discorb::ApplicationCommand::Command::SlashCommand] Command object.
+      # @return [Discorb::ApplicationCommand::Command::ChatInputCommand] Command object.
       #
       # @see file:docs/application_command.md#register-slash-command Application Comamnds: Register Slash Command
       # @see file:docs/cli/setup.md CLI: setup
       #
-      def slash(command_name, description, options = {}, guild_ids: nil, &block)
-        command = Discorb::ApplicationCommand::Command::SlashCommand.new(command_name, description, options, guild_ids, block, 1, "")
+      def slash(
+        command_name,
+        description,
+        options = {},
+        guild_ids: nil,
+        dm_permission: true,
+        default_permission: nil,
+        &block
+      )
+        command_name = { default: command_name } if command_name.is_a?(String)
+        description = { default: description } if description.is_a?(String)
+        command_name = ApplicationCommand.modify_localization_hash(command_name)
+        description = ApplicationCommand.modify_localization_hash(description)
+        command = Discorb::ApplicationCommand::Command::ChatInputCommand.new(
+          command_name,
+          description,
+          options,
+          guild_ids,
+          block,
+          1,
+          nil,
+          dm_permission,
+          default_permission
+        )
         @commands << command
-        @bottom_commands << command
+        @callable_commands << command
         command
       end
 
       #
       # Add new command with group.
       #
-      # @param [String] command_name Command name.
-      # @param [String] description Command description.
-      # @param [Array<#to_s>, false, nil] guild_ids Guild IDs to set the command to. `false` to global command, `nil` to use default.
+      # @param [String, Hash{Symbol => String}] command_name Command name.
+      # @param [String, Hash{Symbol => String}] description Command description.
+      # @param [Array<#to_s>, false, nil] guild_ids
+      #  Guild IDs to set the command to. `false` to global command, `nil` to use default.
+      # @param [Boolean] dm_permission Whether the command is available in DM.
+      # @param [Discorb::Permission] default_permission The default permission of the command.
       #
       # @yield Block to yield with the command.
       # @yieldparam [Discorb::ApplicationCommand::Command::GroupCommand] group Group command.
@@ -59,9 +95,14 @@ module Discorb
       # @see file:docs/application_command.md Application Commands
       # @see file:docs/cli/setup.md CLI: setup
       #
-      def slash_group(command_name, description, guild_ids: nil, &block)
-        command = Discorb::ApplicationCommand::Command::GroupCommand.new(command_name, description, guild_ids, nil, self)
-        command.yield_self(&block) if block_given?
+      def slash_group(command_name, description, guild_ids: nil, dm_permission: true, default_permission: nil, &block)
+        command_name = { default: command_name } if command_name.is_a?(String)
+        description = { default: description } if description.is_a?(String)
+        command_name = ApplicationCommand.modify_localization_hash(command_name)
+        description = ApplicationCommand.modify_localization_hash(description)
+        command = Discorb::ApplicationCommand::Command::GroupCommand.new(command_name, description, guild_ids, nil,
+                                                                         self, dm_permission, default_permission)
+        command.then(&block) if block_given?
         @commands << command
         command
       end
@@ -69,8 +110,11 @@ module Discorb
       #
       # Add message context menu command.
       #
-      # @param [String] command_name Command name.
-      # @param [Array<#to_s>, false, nil] guild_ids Guild IDs to set the command to. `false` to global command, `nil` to use default.
+      # @param [String, Hash{Symbol => String}] command_name Command name.
+      # @param [Array<#to_s>, false, nil] guild_ids
+      #  Guild IDs to set the command to. `false` to global command, `nil` to use default.
+      # @param [Boolean] dm_permission Whether the command is available in DM.
+      # @param [Discorb::Permission] default_permission The default permission of the command.
       # @param [Proc] block Command block.
       # @yield [interaction, message] Block to execute.
       # @yieldparam [Discorb::CommandInteraction::UserMenuCommand] interaction Interaction object.
@@ -78,8 +122,11 @@ module Discorb
       #
       # @return [Discorb::ApplicationCommand::Command] Command object.
       #
-      def message_command(command_name, guild_ids: nil, &block)
-        command = Discorb::ApplicationCommand::Command.new(command_name, guild_ids, block, 3)
+      def message_command(command_name, guild_ids: nil, dm_permission: true, default_permission: nil, &block)
+        command_name = { default: command_name } if command_name.is_a?(String)
+        command_name = ApplicationCommand.modify_localization_hash(command_name)
+        command = Discorb::ApplicationCommand::Command.new(command_name, guild_ids, block, 3, dm_permission,
+                                                           default_permission)
         @commands << command
         command
       end
@@ -87,8 +134,11 @@ module Discorb
       #
       # Add user context menu command.
       #
-      # @param [String] command_name Command name.
-      # @param [Array<#to_s>, false, nil] guild_ids Guild IDs to set the command to. `false` to global command, `nil` to use default.
+      # @param [String, Hash{Symbol => String}] command_name Command name.
+      # @param [Array<#to_s>, false, nil] guild_ids
+      #  Guild IDs to set the command to. `false` to global command, `nil` to use default.
+      # @param [Boolean] dm_permission Whether the command is available in DM.
+      # @param [Discorb::Permission] default_permission The default permission of the command.
       # @param [Proc] block Command block.
       # @yield [interaction, user] Block to execute.
       # @yieldparam [Discorb::CommandInteraction::UserMenuCommand] interaction Interaction object.
@@ -96,8 +146,11 @@ module Discorb
       #
       # @return [Discorb::ApplicationCommand::Command] Command object.
       #
-      def user_command(command_name, guild_ids: nil, &block)
-        command = Discorb::ApplicationCommand::Command.new(command_name, guild_ids, block, 2)
+      def user_command(command_name, guild_ids: nil, dm_permission: true, default_permission: nil, &block)
+        command_name = { default: command_name } if command_name.is_a?(String)
+        command_name = ApplicationCommand.modify_localization_hash(command_name)
+        command = Discorb::ApplicationCommand::Command.new(command_name, guild_ids, block, 2, dm_permission,
+                                                           default_permission)
         @commands << command
         command
       end
@@ -108,7 +161,8 @@ module Discorb
       # @see Client#initialize
       #
       # @param [String] token Bot token.
-      # @param [Array<#to_s>, false, nil] guild_ids Guild IDs to use as default. If `false` is given, it will be global command.
+      # @param [Array<#to_s>, false, nil] guild_ids
+      #  Guild IDs to use as default. If `false` is given, it will be global command.
       #
       # @note `token` parameter only required if you don't run client.
       #
@@ -139,10 +193,10 @@ module Discorb
               global_commands.map(&:to_hash)
             ).wait
           end
-          if ENV["DISCORB_CLI_FLAG"] == "setup"
+          if ENV.fetch("DISCORB_CLI_FLAG", nil) == "setup"
             sputs "Registered commands for global:"
             global_commands.each do |command|
-              iputs "- #{command.name}"
+              iputs "- #{command.name["default"]}"
             end
           end
           unless final_guild_ids.empty?
@@ -156,11 +210,39 @@ module Discorb
               ).wait
               sputs "Registered commands for #{guild_id}:"
               commands.each do |command|
-                iputs "- #{command.name}"
+                iputs "- #{command.name["default"]}"
               end
             end
           end
-          @log.info "Successfully setup commands"
+          @logger.info "Successfully setup commands"
+        end
+      end
+
+      #
+      # Claer commands in specified guilds.
+      # @async
+      # @see Client#initialize
+      #
+      # @param [String] token Bot token.
+      # @param [Array<#to_s>, false, nil] guild_ids Guild IDs to clear.
+      #
+      # @note `token` parameter only required if you don't run client.
+      #
+      def clear_commands(token, guild_ids)
+        Async do
+          @token ||= token
+          @http = HTTP.new(self)
+          app_info = fetch_application.wait
+
+          guild_ids.each do |guild_id|
+            @http.request(
+              Route.new("/applications/#{app_info.id}/guilds/#{guild_id}/commands",
+                        "//applications/:application_id/guilds/:guild_id/commands",
+                        :put),
+              []
+            ).wait
+          end
+          sputs "Cleared commands for #{guild_ids.length} guilds." if ENV.fetch("DISCORB_CLI_FLAG", nil) == "setup"
         end
       end
     end

data/lib/discorb/app_command.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
-%w[command handler].each do |file|
+
+%w[common command handler].each do |file|
   require_relative "app_command/#{file}.rb"
 end

data/lib/discorb/application.rb

@@ -29,7 +29,14 @@ module Discorb
     alias bot_require_code_grant? bot_require_code_grant
     # @return [Discorb::Application::Flag] The application's flags.
     attr_reader :flags
+
+    #
+    # Initializes a new instance of the Application class.
     # @private
+    #
+    # @param [Discorb::Client] client The client that instantiated the object.
+    # @param [Hash] data The data of the object.
+    #
     def initialize(client, data)
       @client = client
       @data = data
@@ -97,7 +104,13 @@ module Discorb
       # @return [Discorb::Application::Team::Member] The team's member.
       attr_reader :members
 
+      #
+      # Initializes a new instance of the Team class.
       # @private
+      #
+      # @param [Discorb::Client] client The client that instantiated the object.
+      # @param [Hash] data The data of the object.
+      #
       def initialize(client, data)
         @client = client
         @id = Snowflake.new(data[:id])
@@ -142,7 +155,9 @@ module Discorb
         # @!attribute [r] owner?
         #   @return [Boolean] Whether the member is the team's owner.
 
-        @membership_state = {
+        # @private
+        # @return [{Integer => Symbol}] The permission map.
+        MEMBERSHIP_STATE = {
           1 => :invited,
           2 => :accepted,
         }.freeze
@@ -153,7 +168,7 @@ module Discorb
           @team = team
           @user = client.users[data[:user][:id]] || User.new(client, data[:user])
           @team_id = Snowflake.new(data[:team_id])
-          @membership_state = self.class.membership_state[data[:membership_state]]
+          @membership_state = MEMBERSHIP_STATE[data[:membership_state]]
           @permissions = data[:permissions].map(&:to_sym)
         end
 
@@ -176,11 +191,6 @@ module Discorb
         def ==(other)
           super || @user == other
         end
-
-        class << self
-          # @private
-          attr_reader :membership_state
-        end
       end
     end
   end

data/lib/discorb/asset.rb

@@ -11,7 +11,13 @@ module Discorb
     # @!attribute [r] animated?
     #   @return [Boolean] Whether the asset is animated.
 
+    #
+    # Initialize a new instance of the Asset class.
     # @private
+    #
+    # @param [Discorb::Client] client The client that instantiated the object.
+    # @param [Hash] data The data of the object.
+    #
     def initialize(target, hash, path: nil)
       @hash = hash
       @target = target
@@ -45,7 +51,7 @@ module Discorb
       case @target
       when User, Member, Webhook
         "avatars"
-      when Guild, IncomingWebhook::Guild
+      when Guild, Webhook::FollowerWebhook::Guild
         "icons"
       when Application, Integration::Application
         "app-icons"
@@ -59,11 +65,13 @@ module Discorb
   # Represents a default avatar.
   #
   class DefaultAvatar < DiscordModel
-
     # @!attribute [r] animated?
     #   @return [false] For compatibility with {Asset}, always `false`.
 
+    #
+    # Initialize a new instance of the DefaultAvatar class.
     # @private
+    #
     def initialize(discriminator)
       @discriminator = discriminator.to_s.rjust(4, "0")
     end

data/lib/discorb/attachment.rb

@@ -33,6 +33,7 @@ module Discorb
     # @return [:client, :discord] The attachment was created by.
     attr_reader :created_by
     # @private
+    # @return [Boolean] Whether the attachment will be closed after it is sent.
     attr_reader :will_close
 
     # @!attribute [r] image?
@@ -62,11 +63,14 @@ module Discorb
       @created_by = :client
     end
 
+    #
+    # Initializes the object from a hash.
     # @private
+    #
     def initialize_hash(data)
       @id = Snowflake.new(data[:id])
       @filename = data[:filename]
-      @content_type = data[:content_type]
+      @content_type = data[:content_type] || "application/octet-stream"
       @size = data[:size]
       @url = data[:url]
       @proxy_url = data[:proxy_url]
@@ -79,7 +83,18 @@ module Discorb
       @content_type.start_with? "image/"
     end
 
+    def inspect
+      if @created_by == :discord
+        "<#{self.class} #{@id}: #{@filename}>"
+      else
+        "<#{self.class} #{io.fileno}: #{@filename}>"
+      end
+    end
+
+    #
+    # Creates a new file from a hash.
     # @private
+    #
     def self.from_hash(data)
       inst = allocate
       inst.initialize_hash(data)
@@ -93,7 +108,7 @@ module Discorb
     # @param [String] filename The filename of the file. object_id of the string is used if not set.
     # @param [String] content_type The content type of the file. If not set, it is guessed from the filename.
     #
-    # @return [File] The new file.
+    # @return [Discorb::Attachment] The new file.
     #
     def self.from_string(string, filename = nil, content_type: nil, description: nil)
       io = StringIO.new(string)

data/lib/discorb/audit_logs.rb

@@ -14,16 +14,25 @@ module Discorb
     # @return [Array<Discorb::AuditLog::Entry>] The entries in this audit log.
     attr_reader :entries
 
+    #
+    # Initializes a new instance of the AuditLog class.
     # @private
+    #
     def initialize(client, data, guild)
       @client = client
       @guild = guild
-      @webhooks = data[:webhooks].map { |webhook| Webhook.new([@client, webhook]) }
+      @webhooks = data[:webhooks].map { |webhook| Webhook.from_data(@client, webhook) }
       @users = data[:users].map { |user| client.users[user[:id]] || User.new(@client, user) }
-      @threads = data[:threads].map { |thread| client.channels[thread[:id]] || Channel.make_channel(@client, thread, no_cache: true) }
+      @threads = data[:threads].map do |thread|
+        client.channels[thread[:id]] || Channel.make_channel(@client, thread, no_cache: true)
+      end
       @entries = data[:audit_log_entries].map { |entry| AuditLog::Entry.new(@client, entry, guild.id) }
     end
 
+    def inspect
+      "<#{self.class} #{@entries.length} entries>"
+    end
+
     #
     # Gets an entry from entries.
     #
@@ -99,7 +108,8 @@ module Discorb
       attr_reader :type
       # @return [Discorb::AuditLog::Entry::Changes] The changes in this entry.
       attr_reader :changes
-      # @return [Discorb::Channel, Discorb::Role, Discorb::Member, Discorb::Guild, Discorb::Message] The target of the entry.
+      # @return [Discorb::Channel, Discorb::Role, Discorb::Member, Discorb::Guild, Discorb::Message]
+      #   The target of the entry.
       attr_reader :target
       # @return [Hash{Symbol => Object}] The optional data for this entry.
       # @note You can use dot notation to access the data.
@@ -108,8 +118,11 @@ module Discorb
       # @!attribute [r] user
       #   @return [Discorb::User] The user who performed the action.
 
+      #
+      # @return [{Integer => Symbol}] The map of events to their respective changes.
       # @private
-      @events = {
+      #
+      EVENTS = {
         1 => :guild_update,
         10 => :channel_create,
         11 => :channel_update,
@@ -159,25 +172,31 @@ module Discorb
         112 => :thread_delete,
       }.freeze
 
+      #
+      # The converter for the change.
       # @private
-      @converts = {
+      #
+      CONVERTERS = {
         channel: ->(client, id, _guild_id) { client.channels[id] },
         thread: ->(client, id, _guild_id) { client.channels[id] },
         role: ->(client, id, guild_id) { client.guilds[guild_id]&.roles&.[](id) },
         member: ->(client, id, guild_id) { client.guilds[guild_id]&.members&.[](id) },
         guild: ->(client, id, _guild_id) { client.guilds[id] },
         message: ->(client, id, _guild_id) { client.messages[id] },
-      }
+      }.freeze
 
+      #
+      # Initializes a new AuditLog entry.
       # @private
+      #
       def initialize(client, data, guild_id)
         @client = client
         @guild_id = Snowflake.new(guild_id)
         @id = Snowflake.new(data[:id])
         @user_id = Snowflake.new(data[:user_id])
         @target_id = Snowflake.new(data[:target_id])
-        @type = self.class.events[data[:action_type]]
-        @target = self.class.converts[@type.to_s.split("_")[0].to_sym]&.call(client, @target_id, @gui)
+        @type = EVENTS[data[:action_type]]
+        @target = CONVERTERS[@type.to_s.split("_")[0].to_sym]&.call(client, @target_id, @gui)
         @target ||= Snowflake.new(data[:target_id])
         @changes = data[:changes] && Changes.new(data[:changes])
         @reason = data[:reason]
@@ -185,7 +204,7 @@ module Discorb
           define_singleton_method(option) { value }
           if option.end_with?("_id")
             define_singleton_method(option.to_s.sub("_id", "")) do
-              self.class.converts[option.to_s.split("_")[0].to_sym]&.call(client, value, @guild_id)
+              CONVERTERS[option.to_s.split("_")[0].to_sym]&.call(client, value, @guild_id)
             end
           end
         end
@@ -223,8 +242,11 @@ module Discorb
         attr_reader :data
 
         #
+        # Initializes a new changes object.
         # @private
         #
+        # @param [Hash] data The data to initialize with.
+        #
         def initialize(data)
           @data = data.to_h { |d| [d[:key].to_sym, d] }
           @data.each do |k, v|
@@ -232,6 +254,9 @@ module Discorb
           end
         end
 
+        #
+        # Formats the changes into a string.
+        #
         def inspect
           "#<#{self.class} #{@data.length} changes>"
         end
@@ -270,7 +295,10 @@ module Discorb
         # @return [Object] The new value of the change.
         attr_reader :new_value
 
+        #
+        # Initializes a new change object.
         # @private
+        #
         def initialize(data)
           @key = data[:key].to_sym
           method = case @key.to_s
@@ -279,11 +307,11 @@ module Discorb
             when "permissions"
               ->(v) { Discorb::Permission.new(v.to_i) }
             when "status"
-              ->(v) { Discorb::ScheduledEvent.status[v] }
+              ->(v) { Discorb::ScheduledEvent::STATUS[v] }
             when "entity_type"
-              ->(v) { Discorb::ScheduledEvent.entity_type[v] }
+              ->(v) { Discorb::ScheduledEvent::ENTITY_TYPE[v] }
             when "privacy_level"
-              ->(v) { Discorb::StageInstance.privacy_level[v] || Discorb::ScheduledEvent.privacy_level[v] }
+              ->(v) { Discorb::StageInstance::PRIVACY_LEVEL[v] || Discorb::ScheduledEvent::PRIVACY_LEVEL[v] }
             else
               ->(v) { v }
             end
@@ -298,10 +326,20 @@ module Discorb
           @new_value.__send__(method, ...)
         end
 
+        #
+        # Format the change into a string.
+        #
+        # @return [String] The string representation of the change.
+        #
         def inspect
           "#<#{self.class} #{@key.inspect} #{@old_value.inspect} -> #{@new_value.inspect}>"
         end
 
+        #
+        # Whether the change responds to the given method.
+        #
+        # @return [Boolean] Whether the change responds to the given method.
+        #
         def respond_to_missing?(method, include_private = false)
           @new_value.respond_to?(method, include_private)
         end
@@ -321,7 +359,10 @@ module Discorb
       # @return [Discorb::Integration::Account] The account of the integration.
       attr_reader :account
 
+      #
+      # Initializes a new integration object.
       # @private
+      #
       def initialize(data)
         @id = Snowflake.new(data[:id])
         @type = data[:type].to_sym

data/lib/discorb/channel/base.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Discorb
+  #
+  # Represents a channel of Discord.
+  # @abstract
+  #
+  class Channel < DiscordModel
+    # @return [Discorb::Snowflake] The ID of the channel.
+    attr_reader :id
+    # @return [String] The name of the channel.
+    attr_reader :name
+
+    # @!attribute [r] type
+    #   @return [Integer] The type of the channel as integer.
+
+    @channel_type = nil
+    @subclasses = []
+
+    #
+    # Initializes a new instance of the Channel class.
+    # @private
+    #
+    def initialize(client, data, no_cache: false)
+      @client = client
+      @data = {}
+      @no_cache = no_cache
+      _set_data(data)
+    end
+
+    #
+    # Checks if the channel is other channel.
+    #
+    # @param [Discorb::Channel] other The channel to check.
+    #
+    # @return [Boolean] True if the channel is other channel.
+    #
+    def ==(other)
+      return false unless other.respond_to?(:id)
+
+      @id == other.id
+    end
+
+    def inspect
+      "#<#{self.class} \"##{@name}\" id=#{@id}>"
+    end
+
+    #
+    # Returns the descendants of the Channel class.
+    # @private
+    #
+    def self.descendants
+      ObjectSpace.each_object(Class).select { |klass| klass < self }
+    end
+
+    #
+    # Creates a new instance of the Channel class or instance of its descendants.
+    # @private
+    #
+    # @param [Discorb::Client] client The client that instantiated the object.
+    # @param [Hash] data The data of the object.
+    # @param [Boolean] no_cache Whether to disable cache the object.
+    #
+    def self.make_channel(client, data, no_cache: false)
+      descendants.each do |klass|
+        if !klass.channel_type.nil? && klass.channel_type == data[:type]
+          return klass.new(client, data,
+                           no_cache: no_cache)
+        end
+      end
+      client.logger.warn("Unknown channel type #{data[:type]}, initialized GuildChannel")
+      GuildChannel.new(client, data)
+    end
+
+    class << self
+      #
+      # @private
+      # @return [Integer] The type of the channel.
+      #
+      attr_reader :channel_type
+    end
+
+    def type
+      self.class.channel_type
+    end
+
+    #
+    # Returns the channel id to request.
+    # @private
+    #
+    # @return [Async::Task<Discorb::Snowflake>] A task that resolves to the channel id.
+    #
+    def channel_id
+      Async do
+        @id
+      end
+    end
+
+    private
+
+    def _set_data(data)
+      @id = Snowflake.new(data[:id])
+      @name = data[:name]
+      @client.channels[@id] = self if !@no_cache && !(data[:no_cache])
+      @data.update(data)
+    end
+  end
+end