discorb 0.17.0 → 0.18.1

data/sig/discorb/channel/container.rbs

@@ -0,0 +1,29 @@
+module Discorb
+  #
+  # Module for container of channels.
+  module ChannelContainer
+    #
+    # Returns text channels.
+    #
+    # @return [Array<Discorb::TextChannel>] The text channels.
+    def text_channels: -> ::Array[Discorb::TextChannel]
+
+    #
+    # Returns voice channels.
+    #
+    # @return [Array<Discorb::VoiceChannel>] The voice channels.
+    def voice_channels: -> ::Array[Discorb::VoiceChannel]
+
+    #
+    # Returns news channels.
+    #
+    # @return [Array<Discorb::NewsChannel>] The news channels.
+    def news_channels: -> ::Array[Discorb::NewsChannel]
+
+    #
+    # Returns stage channels.
+    #
+    # @return [Array<Discorb::StageChannel>] The stage channels.
+    def stage_channels: -> ::Array[Discorb::StageChannel]
+  end
+end

data/sig/discorb/channel/dm.rbs

@@ -0,0 +1,14 @@
+module Discorb
+  #
+  # Represents a DM channel.
+  class DMChannel < Discorb::Channel
+    include Discorb::Messageable
+
+    #
+    # Returns the channel id to request.
+    # @private
+    #
+    # @return [Async::Task<Discorb::Snowflake>] A task that resolves to the channel id.
+    def channel_id: -> Async::Task[Discorb::Snowflake]
+  end
+end

data/sig/discorb/channel/news.rbs

@@ -0,0 +1,20 @@
+module Discorb
+  #
+  # Represents a news channel (announcement channel).
+  class NewsChannel < Discorb::TextChannel
+    DEFAULT_AUTO_ARCHIVE_DURATION: untyped
+
+    #
+    # Follow the existing announcement channel from self.
+    # @async
+    #
+    # @param [Discorb::TextChannel] target The channel to follow to.
+    # @param [String] reason The reason of following the channel.
+    #
+    # @return [Async::Task<void>] The task.
+    def follow_to: (
+      Discorb::TextChannel target,
+      ?reason: String?
+    ) -> Async::Task[void]
+  end
+end

data/sig/discorb/channel/stage.rbs

@@ -0,0 +1,77 @@
+module Discorb
+  #
+  # Represents a stage channel.
+  class StageChannel < Discorb::GuildChannel
+    include Discorb::Connectable
+
+    #
+    # Initialize a new stage channel.
+    # @private
+    def initialize: -> void
+
+    def stage_instance: -> untyped
+
+    #
+    # Edit the stage channel.
+    # @async
+    # @macro edit
+    #
+    # @param [String] name The name of the stage channel.
+    # @param [Integer] position The position of the stage channel.
+    # @param [Integer] bitrate The bitrate of the stage channel.
+    # @param [Symbol] rtc_region The region of the stage channel.
+    # @param [String] reason The reason of editing the stage channel.
+    #
+    # @return [Async::Task<self>] The edited stage channel.
+    def edit: (
+      ?name: String,
+      ?position: Integer,
+      ?bitrate: Integer,
+      ?rtc_region: Symbol,
+      ?reason: String?
+    ) -> Async::Task[self]
+
+    #
+    # Start a stage instance.
+    # @async
+    #
+    # @param [String] topic The topic of the stage instance.
+    # @param [Boolean] public Whether the stage instance is public or not.
+    # @param [String] reason The reason of starting the stage instance.
+    #
+    # @return [Async::Task<Discorb::StageInstance>] The started stage instance.
+    def start: (
+      String topic,
+      ?public: bool,
+      ?reason: String?
+    ) -> Async::Task[Discorb::StageInstance]
+
+    #
+    # Fetch a current stage instance.
+    # @async
+    #
+    # @return [Async::Task<StageInstance>] The current stage instance.
+    # @return [Async::Task<nil>] If there is no current stage instance.
+    def fetch_stage_instance: -> Async::Task[StageInstance]
+
+    def voice_states: -> Array[Discorb::VoiceState]
+
+    def members: -> Array[Discorb::Member]
+
+    def speakers: -> Array[Discorb::Member]
+
+    def audiences: -> Array[Discorb::Member]
+
+    # @return [Integer] The bitrate of the voice channel.
+    attr_reader bitrate: Integer
+
+    # @return [Integer] The user limit of the voice channel.
+    attr_reader user_limit: Integer
+
+    #
+    # @private
+    # @return [Discorb::Dictionary{Discorb::Snowflake => StageInstance}]
+    #   The stage instances associated with the stage channel.
+    attr_reader stage_instances: Discorb::Dictionary[Discorb::Snowflake, StageInstance]
+  end
+end

data/sig/discorb/channel/text.rbs

@@ -0,0 +1,158 @@
+module Discorb
+  #
+  # Represents a text channel.
+  class TextChannel < Discorb::GuildChannel
+    include Discorb::Messageable
+
+    #
+    # Edits the channel.
+    # @async
+    # @macro edit
+    #
+    # @param [String] name The name of the channel.
+    # @param [Integer] position The position of the channel.
+    # @param [Discorb::CategoryChannel, nil] category The parent of channel. Specify `nil` to remove the parent.
+    # @param [Discorb::CategoryChannel, nil] parent Alias of `category`.
+    # @param [String] topic The topic of the channel.
+    # @param [Boolean] nsfw Whether the channel is nsfw.
+    # @param [Boolean] announce Whether the channel is announce channel.
+    # @param [Integer] rate_limit_per_user The rate limit per user (Slowmode) in the channel.
+    # @param [Integer] slowmode Alias of `rate_limit_per_user`.
+    # @param [Integer] default_auto_archive_duration The default auto archive duration of the channel.
+    # @param [Integer] archive_in Alias of `default_auto_archive_duration`.
+    # @param [String] reason The reason of editing the channel.
+    #
+    # @return [Async::Task<self>] The edited channel.
+    def edit: (
+      ?name: String,
+      ?position: Integer,
+      ?category: Discorb::CategoryChannel?,
+      ?parent: Discorb::CategoryChannel?,
+      ?topic: String,
+      ?nsfw: bool,
+      ?announce: bool,
+      ?rate_limit_per_user: Integer,
+      ?slowmode: Integer,
+      ?default_auto_archive_duration: 60 | 1440 | 4320 | 10080,
+      ?archive_in: Integer,
+      ?reason: String?
+    ) -> Async::Task[self]
+
+    #
+    # Create webhook in the channel.
+    # @async
+    #
+    # @param [String] name The name of the webhook.
+    # @param [Discorb::Image] avatar The avatar of the webhook.
+    #
+    # @return [Async::Task<Discorb::Webhook::IncomingWebhook>] The created webhook.
+    def create_webhook: (
+      String name,
+      ?avatar: Discorb::Image?
+    ) -> Async::Task[Discorb::Webhook::IncomingWebhook]
+
+    #
+    # Fetch webhooks in the channel.
+    # @async
+    #
+    # @return [Async::Task<Array<Discorb::Webhook>>] The webhooks in the channel.
+    def fetch_webhooks: -> Async::Task[::Array[Discorb::Webhook]]
+
+    #
+    # Bulk delete messages in the channel.
+    # @async
+    #
+    # @param [Discorb::Message] messages The messages to delete.
+    # @param [Boolean] force Whether to ignore the validation for message (14 days limit).
+    #
+    # @return [Async::Task<void>] The task.
+    def delete_messages!:
+      (*Discorb::Message messages, ?force: bool) -> Async::Task[void]
+      | (*Array[Discorb::Message] messages, ?force: bool) -> Async::Task[void]
+
+    #
+    # Follow the existing announcement channel.
+    # @async
+    #
+    # @param [Discorb::NewsChannel] target The channel to follow.
+    # @param [String] reason The reason of following the channel.
+    #
+    # @return [Async::Task<void>] The task.
+    def follow_from: (
+      Discorb::NewsChannel target,
+      ?reason: String?
+    ) -> Async::Task[void]
+
+    #
+    # Start thread in the channel.
+    # @async
+    #
+    # @param [String] name The name of the thread.
+    # @param [Discorb::Message] message The message to start the thread.
+    # @param [:hour, :day, :three_days, :week] auto_archive_duration The duration of auto-archiving.
+    # @param [Boolean] public Whether the thread is public.
+    # @param [Integer] rate_limit_per_user The rate limit per user.
+    # @param [Integer] slowmode Alias of `rate_limit_per_user`.
+    # @param [String] reason The reason of starting the thread.
+    #
+    # @return [Async::Task<Discorb::ThreadChannel>] The started thread.
+    def start_thread: (
+      String name,
+      ?message: Discorb::Message?,
+      ?auto_archive_duration: Symbol?,
+      ?public: bool,
+      ?rate_limit_per_user: Integer?,
+      ?slowmode: Integer?,
+      ?reason: String?
+    ) -> Async::Task[Discorb::ThreadChannel]
+
+    #
+    # Fetch archived threads in the channel.
+    # @async
+    #
+    # @return [Async::Task<Array<Discorb::ThreadChannel>>] The archived threads in the channel.
+    def fetch_archived_public_threads: -> Async::Task[::Array[Discorb::ThreadChannel]]
+
+    #
+    # Fetch archived private threads in the channel.
+    # @async
+    #
+    # @return [Async::Task<Array<Discorb::ThreadChannel>>] The archived private threads in the channel.
+    def fetch_archived_private_threads: -> Async::Task[::Array[Discorb::ThreadChannel]]
+
+    #
+    # Fetch joined archived private threads in the channel.
+    # @async
+    #
+    # @param [Integer] limit The limit of threads to fetch.
+    # @param [Time] before <description>
+    #
+    # @return [Async::Task<Array<Discorb::ThreadChannel>>] The joined archived private threads in the channel.
+    def fetch_joined_archived_private_threads: (
+      ?limit: Integer?,
+      ?before: Time?
+    ) -> Async::Task[::Array[Discorb::ThreadChannel]]
+
+    # @return [String] The topic of the channel.
+    attr_reader topic: String
+
+    # @return [Boolean] Whether the channel is nsfw.
+    attr_reader nsfw: bool
+
+    # @return [Discorb::Snowflake] The id of the last message.
+    attr_reader last_message_id: Discorb::Snowflake
+
+    # @return [Integer] The rate limit per user (Slowmode) in the channel.
+    attr_reader rate_limit_per_user: Integer
+
+    # @return [Time] The time when the last pinned message was pinned.
+    attr_reader last_pin_timestamp: Time
+
+    # @return [Integer] The default value of duration of auto archive.
+    attr_reader default_auto_archive_duration: 60 | 1440 | 4320 | 10080
+
+    # @!attribute [r] threads
+    #   @return [Array<Discorb::ThreadChannel>] The threads in the channel.
+    attr_reader threads: untyped
+  end
+end

data/sig/discorb/channel/thread.rbs

@@ -0,0 +1,185 @@
+module Discorb
+  #
+  # Represents a thread.
+  # @abstract
+  class ThreadChannel < Discorb::Channel
+    include Discorb::Messageable
+
+    #
+    # Initialize a new thread channel.
+    # @private
+    #
+    # @param [Discorb::Client] client The client.
+    # @param [Hash] data The data of the thread channel.
+    # @param [Boolean] no_cache Whether to disable the cache.
+    def initialize: (
+      Discorb::Client client,
+      Discorb::json data,
+      ?no_cache: bool
+    ) -> void
+
+    #
+    # Edit the thread.
+    # @async
+    # @macro edit
+    #
+    # @param [String] name The name of the thread.
+    # @param [Boolean] archived Whether the thread is archived or not.
+    # @param [Integer] auto_archive_duration The auto archive duration in seconds.
+    # @param [Integer] archive_in Alias of `auto_archive_duration`.
+    # @param [Boolean] locked Whether the thread is locked or not.
+    # @param [String] reason The reason of editing the thread.
+    #
+    # @return [Async::Task<self>] The edited thread.
+    #
+    # @see #archive
+    # @see #lock
+    # @see #unarchive
+    # @see #unlock
+    def edit: (
+      ?name: String,
+      ?archived: bool,
+      ?auto_archive_duration: Integer,
+      ?archive_in: Integer,
+      ?locked: bool,
+      ?reason: String?
+    ) -> Async::Task[self]
+
+    #
+    # Helper method to archive the thread.
+    #
+    # @param [String] reason The reason of archiving the thread.
+    #
+    # @return [Async::Task<self>] The archived thread.
+    def archive: (?reason: String?) -> Async::Task[self]
+
+    #
+    # Helper method to lock the thread.
+    #
+    # @param [String] reason The reason of locking the thread.
+    #
+    # @return [Async::Task<self>] The locked thread.
+    def lock: (?reason: String?) -> Async::Task[self]
+
+    #
+    # Helper method to unarchive the thread.
+    #
+    # @param [String] reason The reason of unarchiving the thread.
+    #
+    # @return [Async::Task<self>] The unarchived thread.
+    def unarchive: (?reason: String?) -> Async::Task[self]
+
+    #
+    # Helper method to unlock the thread.
+    #
+    # @param [String] reason The reason of unlocking the thread.
+    #
+    # @return [Async::Task<self>] The unlocked thread.
+    #
+    # @note This method won't unarchive the thread. Use {#unarchive} instead.
+    def unlock: (?reason: String?) -> Async::Task[self]
+
+    def parent: -> untyped
+
+    def me: -> untyped
+
+    def joined?: -> bool
+
+    def guild: -> untyped
+
+    def owner: -> untyped
+
+    def inspect: -> String
+
+    #
+    # Add a member to the thread.
+    #
+    # @param [Discorb::Member, :me] member The member to add. If `:me` is given, the bot will be added.
+    #
+    # @return [Async::Task<void>] The task.
+    def add_member: (?Discorb::Member | Symbol member) -> Async::Task[void]
+
+    #
+    # Remove a member from the thread.
+    #
+    # @param [Discorb::Member, :me] member The member to remove. If `:me` is given, the bot will be removed.
+    #
+    # @return [Async::Task<void>] The task.
+    def remove_member: (?Discorb::Member | Symbol member) -> Async::Task[void]
+
+    #
+    # Fetch members in the thread.
+    #
+    # @return [Array<Discorb::ThreadChannel::Member>] The members in the thread.
+    def fetch_members: -> ::Array[Discorb::ThreadChannel::Member]
+
+    # @return [Discorb::Snowflake] The ID of the channel.
+    # @note This ID is same as the starter message's ID
+    attr_reader id: Discorb::Snowflake
+
+    # @return [String] The name of the thread.
+    attr_reader name: String
+
+    # @return [Integer] The number of messages in the thread.
+    # @note This will stop counting at 50.
+    attr_reader message_count: Integer
+
+    # @return [Integer] The number of recipients in the thread.
+    # @note This will stop counting at 50.
+    attr_reader member_count: Integer
+
+    # @return [Integer] The rate limit per user (slowmode) in the thread.
+    attr_reader rate_limit_per_user: Integer
+
+    # @return [Array<Discorb::ThreadChannel::Member>] The members of the thread.
+    attr_reader members: ::Array[Discorb::ThreadChannel::Member]
+
+    # @return [Time] The time the thread was archived.
+    # @return [nil] If the thread is not archived.
+    attr_reader archived_timestamp: Time?
+
+    # @return [Integer] Auto archive duration in seconds.
+    attr_reader auto_archive_duration: Integer
+
+    # @return [Boolean] Whether the thread is archived or not.
+    attr_reader archived: bool
+
+    #
+    # Represents a thread in news channel(aka announcement channel).
+    class News < Discorb::ThreadChannel
+    end
+
+    #
+    # Represents a public thread in text channel.
+    class Public < Discorb::ThreadChannel
+    end
+
+    #
+    # Represents a private thread in text channel.
+    class Private < Discorb::ThreadChannel
+    end
+
+    #
+    # Represents a member in a thread.
+    class Member < Discorb::DiscordModel
+      def initialize: (
+        Discorb::Client client,
+        Discorb::json data,
+        _ToS guild_id
+      ) -> void
+
+      def thread: -> Discorb::ThreadChannel
+
+      def member: -> Discorb::Member
+
+      def id: -> Discorb::Snowflake
+
+      def user: -> Discorb::User
+
+      def inspect: -> String
+
+      # Returns the value of attribute joined_at.
+      attr_reader joined_at: Time
+    end
+  end
+end

data/sig/discorb/channel/voice.rbs

@@ -0,0 +1,41 @@
+module Discorb
+  #
+  # Represents a voice channel.
+  class VoiceChannel < Discorb::GuildChannel
+    include Discorb::Connectable
+    include Discorb::Messageable
+
+    #
+    # Edit the voice channel.
+    # @async
+    # @macro edit
+    #
+    # @param [String] name The name of the voice channel.
+    # @param [Integer] position The position of the voice channel.
+    # @param [Integer] bitrate The bitrate of the voice channel.
+    # @param [Integer] user_limit The user limit of the voice channel.
+    # @param [Symbol] rtc_region The region of the voice channel.
+    # @param [String] reason The reason of editing the voice channel.
+    #
+    # @return [Async::Task<self>] The edited voice channel.
+    def edit: (
+      ?name: String,
+      ?position: Integer,
+      ?bitrate: Integer,
+      ?user_limit: Integer,
+      ?rtc_region: Symbol,
+      ?reason: String?
+    ) -> Async::Task[self]
+
+    def voice_states: -> Array[Discorb::VoiceState]
+
+    def members: -> Array[Discorb::Member]
+
+    # @return [Integer] The bitrate of the voice channel.
+    attr_reader bitrate: Integer
+
+    # @return [Integer] The user limit of the voice channel.
+    # @return [nil] If the user limit is not set.
+    attr_reader user_limit: Integer?
+  end
+end