Feature: Threads

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

@@ -65,7 +65,16 @@ 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,
+    @SerialName("thread_metadata")
+    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 +103,14 @@ 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 PublicGuildThread : ChannelType(11)
+
+    object PrivateThread : ChannelType(12)
+
+
+
     object GuildStageVoice : ChannelType(13)
 
     companion object;
@@ -110,6 +127,9 @@ sealed class ChannelType(val value: Int) {
             4 -> GuildCategory
             5 -> GuildNews
             6 -> GuildStore
+            10 -> PublicNewsThread
+            11 -> PublicGuildThread
+            12 -> PrivateThread
             13 -> GuildStageVoice
             else -> Unknown(code)
         }
@@ -154,3 +174,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/Unsafe.kt

@@ -5,7 +5,9 @@ import dev.kord.common.annotation.KordUnsafe
 import dev.kord.common.entity.Snowflake
 import dev.kord.core.behavior.*
 import dev.kord.core.behavior.channel.*
+import dev.kord.core.behavior.channel.threads.ThreadChannelBehavior
 import dev.kord.core.behavior.interaction.ComponentInteractionBehavior
+import dev.kord.core.entity.channel.thread.NewsChannelThread
 import dev.kord.rest.service.InteractionService
 
 /**
@@ -50,6 +52,11 @@ class Unsafe(private val kord: Kord) {
     fun storeChannel(guildId: Snowflake, id: Snowflake): StoreChannelBehavior =
         StoreChannelBehavior(guildId = guildId, id = id, kord = kord)
 
+
+    fun thread(id: Snowflake): ThreadChannelBehavior =
+        ThreadChannelBehavior(id, kord)
+
+
     fun guild(id: Snowflake): GuildBehavior =
         GuildBehavior(id, kord)
 
@@ -62,6 +69,9 @@ class Unsafe(private val kord: Kord) {
     fun user(id: Snowflake): UserBehavior =
         UserBehavior(id, kord)
 
+    fun threadUser(id: Snowflake, threadId: Snowflake) =
+        ThreadUserBehavior(id, threadId, kord)
+
     fun member(guildId: Snowflake, id: Snowflake): MemberBehavior =
         MemberBehavior(guildId = guildId, id = id, kord = kord)
 

core/src/main/kotlin/Util.kt

@@ -3,16 +3,16 @@ package dev.kord.core
 import dev.kord.common.entity.Snowflake
 import dev.kord.core.entity.Entity
 import dev.kord.core.entity.KordEntity
+import dev.kord.core.entity.channel.thread.ThreadChannel
 import dev.kord.core.event.Event
-import dev.kord.core.event.user.PresenceUpdateEvent
-import dev.kord.core.event.user.VoiceStateUpdateEvent
-import dev.kord.core.event.guild.WebhookUpdateEvent
 import dev.kord.core.event.channel.*
 import dev.kord.core.event.guild.*
 import dev.kord.core.event.message.*
 import dev.kord.core.event.role.RoleCreateEvent
 import dev.kord.core.event.role.RoleDeleteEvent
 import dev.kord.core.event.role.RoleUpdateEvent
+import dev.kord.core.event.user.PresenceUpdateEvent
+import dev.kord.core.event.user.VoiceStateUpdateEvent
 import dev.kord.gateway.Intent.*
 import dev.kord.gateway.Intents
 import dev.kord.gateway.MessageDelete
@@ -21,6 +21,7 @@ import dev.kord.rest.json.JsonErrorCode
 import dev.kord.rest.request.RestRequestException
 import dev.kord.rest.route.Position
 import kotlinx.coroutines.flow.*
+import kotlinx.datetime.Clock
 import kotlinx.datetime.Instant
 import kotlin.contracts.ExperimentalContracts
 import kotlin.contracts.InvocationKind
@@ -231,6 +232,36 @@ internal fun <C : Collection<T>, T : KordEntity> paginateBackwards(
 ): Flow<T> =
     paginate(start, batchSize, { it.id }, oldestItem { it.id }, Position::Before, request)
 
+internal fun <C : Collection<T>, T> paginateByDate(
+    start: Instant = Clock.System.now(),
+    batchSize: Int,
+    instantSelector: (Collection<T>) -> Instant?,
+    request: suspend (Instant) -> C
+): Flow<T> = flow {
+
+    var currentTimestamp = start
+    while (true) {
+        val response = request(currentTimestamp)
+
+        for (item in response) emit(item)
+
+        currentTimestamp = instantSelector(response) ?: break
+        if (response.size < batchSize) break
+    }
+}
+
+internal fun paginateThreads(
+    batchSize: Int,
+    start: Instant = Clock.System.now(),
+    request: suspend (Instant) -> Collection<ThreadChannel>
+) =
+    paginateByDate(
+        start,
+        batchSize,
+        { threads -> threads.minOfOrNull { it.archiveTimeStamp } },
+        request
+    )
+
 inline fun <reified T : Event> Intents.IntentsBuilder.enableEvent() = enableEvent(T::class)
 
 fun Intents.IntentsBuilder.enableEvents(events: Iterable<KClass<out Event>>) = events.forEach { enableEvent(it) }

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,44 @@
+package dev.kord.core.behavior
+
+import dev.kord.common.entity.Snowflake
+import dev.kord.core.Kord
+import dev.kord.core.behavior.channel.threads.ThreadChannelBehavior
+import dev.kord.core.entity.channel.thread.ThreadChannel
+import dev.kord.core.supplier.EntitySupplier
+import dev.kord.core.supplier.EntitySupplyStrategy
+import dev.kord.core.supplier.getChannelOf
+import dev.kord.core.supplier.getChannelOfOrNull
+
+interface ThreadUserBehavior : UserBehavior {
+
+    val threadId: Snowflake
+
+    val thread: ThreadChannelBehavior get() = ThreadChannelBehavior(threadId, kord)
+
+    suspend fun getThread(): ThreadChannel = supplier.getChannelOf(threadId)
+
+    suspend fun getThreadOrNull(): ThreadChannel? = supplier.getChannelOfOrNull(threadId)
+
+    override fun withStrategy(strategy: EntitySupplyStrategy<*>): UserBehavior {
+        return ThreadUserBehavior(id, threadId, kord, strategy.supply(kord))
+
+    }
+}
+
+fun ThreadUserBehavior(
+    id: Snowflake,
+    threadId: Snowflake,
+    kord: Kord,
+    supplier: EntitySupplier = kord.defaultSupplier
+): ThreadUserBehavior {
+    return object : ThreadUserBehavior {
+        override val id: Snowflake
+            get() = id
+        override val threadId: Snowflake
+            get() = threadId
+        override val kord: Kord
+            get() = kord
+        override val supplier: EntitySupplier
+            get() = supplier
+    }
+}

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