Feature: Threads

common/src/main/kotlin/entity/DiscordChannel.kt

@@ -65,7 +65,15 @@ data class DiscordChannel(
     val parentId: OptionalSnowflake? = OptionalSnowflake.Missing,
     @SerialName("last_pin_timestamp")
     val lastPinTimestamp: Optional<String?> = Optional.Missing(),
-    val permissions: Optional<Permissions> = Optional.Missing()
+    val permissions: Optional<Permissions> = Optional.Missing(),
+    @SerialName("message_count")
+    val messageCount: OptionalInt = OptionalInt.Missing,
+    @SerialName("member_count")
+    val memberCount: OptionalInt = OptionalInt.Missing,
+    val threadMetadata: Optional<DiscordThreadMetadata> = Optional.Missing(),
+    @SerialName("default_auto_archive_duration")
+    val defaultAutoArchiveDuration: Optional<ArchiveDuration> = Optional.Missing(),
+    val member: Optional<DiscordThreadMember> = Optional.Missing()
 )
 
 @Serializable(with = ChannelType.Serializer::class)
@@ -94,6 +102,12 @@ sealed class ChannelType(val value: Int) {
     /** A channel in which game developers can sell their game on Discord. */
     object GuildStore : ChannelType(6)
 
+    object PublicNewsThread : ChannelType(10)
+
+    object PrivateThread : ChannelType(11)
+
+    object PublicGuildThread : ChannelType(12)
+
     object GuildStageVoice : ChannelType(13)
 
     companion object;
@@ -110,6 +124,9 @@ sealed class ChannelType(val value: Int) {
             4 -> GuildCategory
             5 -> GuildNews
             6 -> GuildStore
+            10 -> PublicNewsThread
+            11 -> PrivateThread
+            12 -> PublicGuildThread
             13 -> GuildStageVoice
             else -> Unknown(code)
         }
@@ -154,3 +171,46 @@ sealed class OverwriteType(val value: Int) {
         }
     }
 }
+
+@Serializable
+class DiscordThreadMetadata(
+    val archived: Boolean,
+    @SerialName("archive_timestamp")
+    val archiveTimestamp: String,
+    @SerialName("auto_archive_duration")
+    val autoArchiveDuration: ArchiveDuration,
+    val locked: OptionalBoolean = OptionalBoolean.Missing
+)
+
+@Serializable(with = ArchiveDuration.Serializer::class)
+sealed class ArchiveDuration(val duration: Int) {
+    class Unknown(duration: Int) : ArchiveDuration(duration)
+    object Hour : ArchiveDuration(60)
+    object Day : ArchiveDuration(1440)
+    object ThreeDays : ArchiveDuration(4320)
+    object Week : ArchiveDuration(10080)
+
+    object Serializer : KSerializer<ArchiveDuration> {
+        override fun deserialize(decoder: Decoder): ArchiveDuration {
+            val value = decoder.decodeInt()
+            return values.firstOrNull { it.duration == value } ?: Unknown(value)
+        }
+
+        override val descriptor: SerialDescriptor
+            get() = PrimitiveSerialDescriptor("AutoArchieveDuration", PrimitiveKind.INT)
+
+        override fun serialize(encoder: Encoder, value: ArchiveDuration) {
+            encoder.encodeInt(value.duration)
+        }
+    }
+
+    companion object {
+        val values: Set<ArchiveDuration>
+            get() = setOf(
+                Hour,
+                Day,
+                ThreeDays,
+                Week,
+            )
+    }
+}

common/src/main/kotlin/entity/DiscordGuild.kt

@@ -128,6 +128,7 @@ data class DiscordGuild(
     val voiceStates: Optional<List<DiscordVoiceState>> = Optional.Missing(),
     val members: Optional<List<DiscordGuildMember>> = Optional.Missing(),
     val channels: Optional<List<DiscordChannel>> = Optional.Missing(),
+    val threads: Optional<List<DiscordChannel>> = Optional.Missing(),
     val presences: Optional<List<DiscordPresenceUpdate>> = Optional.Missing(),
     @SerialName("max_presences")
     val maxPresences: OptionalInt? = OptionalInt.Missing,

common/src/main/kotlin/entity/DiscordMessage.kt

@@ -109,7 +109,8 @@ data class DiscordMessage(
      * This is a list even though the docs say it's a component
      */
     val components: Optional<List<DiscordComponent>> = Optional.Missing(),
-    val interaction: Optional<DiscordMessageInteraction> = Optional.Missing()
+    val interaction: Optional<DiscordMessageInteraction> = Optional.Missing(),
+    val thread: Optional<DiscordChannel> = Optional.Missing()
 )
 
 /**
@@ -298,7 +299,11 @@ enum class MessageFlag(val code: Int) {
     /* This message came from the urgent message system. */
     Urgent(16),
 
-    Ephemeral(64);
+    HasThread(32),
+
+    Ephemeral(64),
+
+    Loading(128);
 }
 
 @Serializable(with = MessageFlags.Serializer::class)

common/src/main/kotlin/entity/Member.kt

@@ -2,6 +2,7 @@ package dev.kord.common.entity
 
 import dev.kord.common.entity.optional.Optional
 import dev.kord.common.entity.optional.OptionalBoolean
+import dev.kord.common.entity.optional.OptionalSnowflake
 import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
 
@@ -82,3 +83,13 @@ data class DiscordUpdatedGuildMember(
     val premiumSince: Optional<String?> = Optional.Missing(),
     val pending: OptionalBoolean = OptionalBoolean.Missing
 )
+
+@Serializable
+data class DiscordThreadMember(
+    val id: OptionalSnowflake = OptionalSnowflake.Missing,
+    @SerialName("user_id")
+    val userId: OptionalSnowflake = OptionalSnowflake.Missing,
+    @SerialName("join_timestamp")
+    val joinTimestamp: String,
+    val flags: Int
+)

common/src/main/kotlin/entity/Permission.kt

@@ -156,6 +156,9 @@ sealed class Permission(val code: DiscordBitSet) {
     object ManageEmojis : Permission(0x40000000)
     object UseSlashCommands : Permission(0x80000000)
     object RequestToSpeak : Permission(0x100000000)
+    object ManageThreads : Permission(0x0400000000)
+    object UsePublicThreads : Permission(0x0800000000)
+    object UsePrivateThreads : Permission(0x1000000000)
     object All : Permission(values.fold(EmptyBitSet()) { acc, value -> acc.add(value.code); acc })
 
     companion object {
@@ -192,7 +195,10 @@ sealed class Permission(val code: DiscordBitSet) {
                 ManageWebhooks,
                 ManageEmojis,
                 UseSlashCommands,
-                RequestToSpeak
+                RequestToSpeak,
+                ManageThreads,
+                UsePublicThreads,
+                UsePrivateThreads,
             )
     }
 }

core/src/main/kotlin/behavior/MessageBehavior.kt

@@ -1,15 +1,19 @@
 package dev.kord.core.behavior
 
 import dev.kord.common.annotation.KordPreview
+import dev.kord.common.entity.ArchiveDuration
 import dev.kord.common.entity.Permission
 import dev.kord.common.entity.Snowflake
 import dev.kord.common.exception.RequestException
 import dev.kord.core.Kord
 import dev.kord.core.behavior.channel.MessageChannelBehavior
 import dev.kord.core.behavior.channel.createMessage
+import dev.kord.core.cache.data.ChannelData
 import dev.kord.core.cache.data.MessageData
 import dev.kord.core.entity.*
+import dev.kord.core.entity.channel.Channel
 import dev.kord.core.entity.channel.MessageChannel
+import dev.kord.core.entity.channel.thread.ThreadChannel
 import dev.kord.core.exception.EntityNotFoundException
 import dev.kord.core.supplier.EntitySupplier
 import dev.kord.core.supplier.EntitySupplyStrategy
@@ -18,6 +22,7 @@ import dev.kord.core.supplier.getChannelOfOrNull
 import dev.kord.rest.builder.message.MessageCreateBuilder
 import dev.kord.rest.builder.message.MessageModifyBuilder
 import dev.kord.rest.builder.webhook.EditWebhookMessageBuilder
+import dev.kord.rest.json.request.StartThreadRequest
 import dev.kord.rest.request.RestRequestException
 import dev.kord.rest.service.RestClient
 import kotlinx.coroutines.flow.Flow

core/src/main/kotlin/behavior/ThreadUserBehavior.kt

@@ -0,0 +1,24 @@
+package dev.kord.core.behavior
+
+import dev.kord.common.entity.Snowflake
+import dev.kord.core.behavior.channel.threads.ChannelThreadBehavior
+import dev.kord.core.entity.channel.Channel
+import dev.kord.core.entity.channel.thread.ThreadChannel
+import dev.kord.core.supplier.getChannelOf
+import dev.kord.core.supplier.getChannelOfOrNull
+
+interface ThreadUserBehavior : UserBehavior {
+
+    val threadId: Snowflake
+
+    val thread: ChannelThreadBehavior get() = ChannelThreadBehavior(threadId, kord)
+
+    suspend fun getThread(): ThreadChannel {
+        return supplier.getChannelOf(threadId)
+    }
+
+
+    suspend fun getThreadOrNull(): ThreadChannel? {
+        return supplier.getChannelOfOrNull(threadId)
+    }
+}

core/src/main/kotlin/behavior/channel/MessageChannelBehavior.kt

@@ -6,6 +6,7 @@ import dev.kord.core.Kord
 import dev.kord.core.cache.data.MessageData
 import dev.kord.core.entity.Message
 import dev.kord.core.entity.Strategizable
+import dev.kord.core.entity.channel.GuildChannel
 import dev.kord.core.entity.channel.MessageChannel
 import dev.kord.core.exception.EntityNotFoundException
 import dev.kord.core.supplier.EntitySupplier

core/src/main/kotlin/behavior/channel/NewsChannelBehavior.kt

@@ -1,13 +1,19 @@
 package dev.kord.core.behavior.channel
 
 import dev.kord.common.annotation.KordPreview
+import dev.kord.common.entity.ArchiveDuration
+import dev.kord.common.entity.ChannelType
 import dev.kord.common.entity.Permission
 import dev.kord.common.entity.Snowflake
 import dev.kord.common.exception.RequestException
 import dev.kord.core.Kord
+import dev.kord.core.behavior.channel.threads.ThreadParentChannelBehavior
+import dev.kord.core.behavior.channel.threads.startThread
 import dev.kord.core.cache.data.ChannelData
 import dev.kord.core.entity.channel.Channel
 import dev.kord.core.entity.channel.NewsChannel
+import dev.kord.core.entity.channel.thread.NewsChannelThread
+import dev.kord.core.entity.channel.thread.ThreadChannel
 import dev.kord.core.exception.EntityNotFoundException
 import dev.kord.core.supplier.EntitySupplier
 import dev.kord.core.supplier.EntitySupplyStrategy
@@ -23,7 +29,7 @@ import kotlin.contracts.contract
 /**
  * The behavior of a Discord News Channel associated to a guild.
  */
-interface NewsChannelBehavior : GuildMessageChannelBehavior {
+interface NewsChannelBehavior : ThreadParentChannelBehavior {
 
     /**
      * Requests to get the this behavior as a [NewsChannel].
@@ -55,6 +61,20 @@ interface NewsChannelBehavior : GuildMessageChannelBehavior {
         kord.rest.channel.followNewsChannel(id, ChannelFollowRequest(webhookChannelId = target.asString))
     }
 
+
+    override suspend fun startPublicThread(name: String, archiveDuration: ArchiveDuration): NewsChannelThread {
+        return startThread(name, archiveDuration, ChannelType.PublicNewsThread) as NewsChannelThread
+    }
+
+    override suspend fun startPublicThreadWithMessage(
+        messageId: Snowflake,
+        name: String,
+        archiveDuration: ArchiveDuration
+    ): NewsChannelThread {
+        return super.startPublicThreadWithMessage(messageId, name, archiveDuration) as NewsChannelThread
+    }
+
+
     /**
      * Returns a new [NewsChannelBehavior] with the given [strategy].
      */

core/src/main/kotlin/behavior/channel/TextChannelBehavior.kt

@@ -1,11 +1,17 @@
 package dev.kord.core.behavior.channel
 
+import dev.kord.common.entity.ArchiveDuration
+import dev.kord.common.entity.ChannelType
 import dev.kord.common.entity.Snowflake
 import dev.kord.common.exception.RequestException
 import dev.kord.core.Kord
+import dev.kord.core.behavior.channel.threads.PrivateThreadParentChannelBehavior
+import dev.kord.core.behavior.channel.threads.startThread
 import dev.kord.core.cache.data.ChannelData
 import dev.kord.core.entity.channel.Channel
 import dev.kord.core.entity.channel.TextChannel
+import dev.kord.core.entity.channel.thread.TextChannelThread
+import dev.kord.core.entity.channel.thread.ThreadChannel
 import dev.kord.core.exception.EntityNotFoundException
 import dev.kord.core.supplier.EntitySupplier
 import dev.kord.core.supplier.EntitySupplyStrategy
@@ -17,7 +23,7 @@ import kotlin.contracts.ExperimentalContracts
 import kotlin.contracts.InvocationKind
 import kotlin.contracts.contract
 
-interface TextChannelBehavior : GuildMessageChannelBehavior {
+interface TextChannelBehavior : PrivateThreadParentChannelBehavior {
 
     /**
      * Requests to get the this behavior as a [TextChannel].
@@ -36,6 +42,21 @@ interface TextChannelBehavior : GuildMessageChannelBehavior {
      */
     override suspend fun asChannelOrNull(): TextChannel? = super.asChannelOrNull() as? TextChannel
 
+    override suspend fun startPublicThread(name: String, archiveDuration: ArchiveDuration): TextChannelThread {
+        return startThread(name, archiveDuration, ChannelType.PublicGuildThread) as TextChannelThread
+    }
+
+    override suspend fun startPrivateThread(name: String, archiveDuration: ArchiveDuration): TextChannelThread {
+        return startThread(name, archiveDuration, ChannelType.PrivateThread) as TextChannelThread
+    }
+
+    override suspend fun startPublicThreadWithMessage(
+        messageId: Snowflake,
+        name: String,
+        archiveDuration: ArchiveDuration
+    ): TextChannelThread {
+        return super.startPublicThreadWithMessage(messageId, name, archiveDuration) as TextChannelThread
+    }
 
     /**
      * Returns a new [TextChannelBehavior] with the given [strategy].

core/src/main/kotlin/behavior/channel/threads/ChannelThreadBehavior.kt

@@ -0,0 +1,60 @@
+package dev.kord.core.behavior.channel.threads
+
+import dev.kord.common.entity.Snowflake
+import dev.kord.core.Kord
+import dev.kord.core.behavior.channel.MessageChannelBehavior
+import dev.kord.core.cache.data.toData
+import dev.kord.core.entity.channel.Channel
+import dev.kord.core.entity.channel.thread.ThreadChannel
+import dev.kord.core.entity.channel.thread.ThreadUser
+import dev.kord.core.supplier.EntitySupplier
+import dev.kord.rest.builder.channel.thread.ThreadModifyBuilder
+import kotlinx.coroutines.flow.Flow
+import kotlin.contracts.ExperimentalContracts
+import kotlin.contracts.InvocationKind
+import kotlin.contracts.contract
+
+interface ChannelThreadBehavior :  MessageChannelBehavior {
+
+    val members: Flow<ThreadUser>
+        get() = supplier.getThreadMembers(id)
+
+
+    suspend fun removeUser(userId: Snowflake) {
+        kord.rest.channel.removeUserFromThread(id, userId)
+    }
+
+    suspend fun addUser(userId: Snowflake) {
+        kord.rest.channel.addUserToThread(id, userId)
+    }
+
+    suspend fun join() {
+        kord.rest.channel.joinThread(id)
+    }
+
+    suspend fun leave() {
+        kord.rest.channel.leaveThread(id)
+    }
+
+
+}
+
+@OptIn(ExperimentalContracts::class)
+suspend inline fun ChannelThreadBehavior.edit(builder: ThreadModifyBuilder.() -> Unit): ThreadChannel {
+    contract { callsInPlace(builder, InvocationKind.EXACTLY_ONCE) }
+    val appliedBuilder = ThreadModifyBuilder().apply(builder)
+    val patchedChannel = kord.rest.channel.patchThread(id, appliedBuilder.toRequest(), appliedBuilder.reason)
+    return Channel.from(patchedChannel.toData(), kord) as ThreadChannel
+}
+
+fun ChannelThreadBehavior(id: Snowflake, kord: Kord, supplier: EntitySupplier = kord.defaultSupplier): ChannelThreadBehavior {
+    return object: ChannelThreadBehavior {
+        override val kord: Kord
+            get() = kord
+        override val id: Snowflake
+            get() = id
+        override val supplier: EntitySupplier
+            get() = supplier
+
+    }
+}