From 4975ced38cbda41dcc948d4b1ebc4e0207718ab0 Mon Sep 17 00:00:00 2001
From: BartArys <mysterybtdn@gmail.com>
Date: Sat, 8 May 2021 19:39:27 +0200
Subject: [PATCH 01/22] Make slash command creation eager

createGuildApplicationCommands and createGlobalApplicationCommands should eagerly create new commands to be more in line with the rest of the API
---
 core/src/main/kotlin/SlashCommands.kt | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/core/src/main/kotlin/SlashCommands.kt b/core/src/main/kotlin/SlashCommands.kt
index 142a6daf55d..c4e022fa155 100644
--- a/core/src/main/kotlin/SlashCommands.kt
+++ b/core/src/main/kotlin/SlashCommands.kt
@@ -49,10 +49,10 @@ class SlashCommands(
 
         contract { callsInPlace(builder, InvocationKind.EXACTLY_ONCE) }
         val request = ApplicationCommandsCreateBuilder().apply(builder).toRequest()
-
+        val commands = service.createGlobalApplicationCommands(applicationId, request)
         return flow {
-            for (command in service.createGlobalApplicationCommands(applicationId, request)) {
-                val data = ApplicationCommandData.from(command)
+            commands.forEach {
+                val data = ApplicationCommandData.from(it)
                 emit(GlobalApplicationCommand(data, service))
             }
         }
@@ -88,9 +88,10 @@ class SlashCommands(
         contract { callsInPlace(builder, InvocationKind.EXACTLY_ONCE) }
         val request = ApplicationCommandsCreateBuilder().apply(builder).toRequest()
 
+        val commands = service.createGuildApplicationCommands(applicationId, guildId, request)
         return flow {
-            for (command in service.createGuildApplicationCommands(applicationId, guildId, request)) {
-                val data = ApplicationCommandData.from(command)
+            commands.forEach {
+                val data = ApplicationCommandData.from(it)
                 emit(GuildApplicationCommand(data, service, guildId))
             }
         }

From 07739072a6d1589ade57e637509fbedcad9ac4dd Mon Sep 17 00:00:00 2001
From: BartArys <mysterybtdn@gmail.com>
Date: Sat, 8 May 2021 19:41:29 +0200
Subject: [PATCH 02/22] Fix typo in InteractionBehavior

ackowledgePublic -> acknowledgePublic
---
 .../src/main/kotlin/behavior/interaction/InteractionBehavior.kt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/core/src/main/kotlin/behavior/interaction/InteractionBehavior.kt b/core/src/main/kotlin/behavior/interaction/InteractionBehavior.kt
index d9d2c75b647..7ddd9f8dd89 100644
--- a/core/src/main/kotlin/behavior/interaction/InteractionBehavior.kt
+++ b/core/src/main/kotlin/behavior/interaction/InteractionBehavior.kt
@@ -50,7 +50,7 @@ interface InteractionBehavior : KordEntity, Strategizable {
      *
      * @return [PublicInteractionResponseBehavior] public acknowledgement of an interaction.
      */
-    suspend fun ackowledgePublic(): PublicInteractionResponseBehavior {
+    suspend fun acknowledgePublic(): PublicInteractionResponseBehavior {
         val request = PublicInteractionResponseCreateBuilder().toRequest()
         kord.rest.interaction.createInteractionResponse(id, token, request)
         return PublicInteractionResponseBehavior(applicationId, token, kord)

From 90290f10d1ed9a1465b1ed24ec7ab37ac7137f1d Mon Sep 17 00:00:00 2001
From: BartArys <mysterybtdn@gmail.com>
Date: Sun, 9 May 2021 09:59:45 +0200
Subject: [PATCH 03/22] Don't compute supplier in InteractionBehavior

It's a waste of resources, and might result in unexpected behavior for non-Kord suppliers.
---
 .../main/kotlin/behavior/interaction/InteractionBehavior.kt    | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/core/src/main/kotlin/behavior/interaction/InteractionBehavior.kt b/core/src/main/kotlin/behavior/interaction/InteractionBehavior.kt
index 7ddd9f8dd89..98d808cd72d 100644
--- a/core/src/main/kotlin/behavior/interaction/InteractionBehavior.kt
+++ b/core/src/main/kotlin/behavior/interaction/InteractionBehavior.kt
@@ -93,8 +93,7 @@ fun InteractionBehavior(
         get() = channelId
 
 
-    override val supplier: EntitySupplier
-        get() = strategy.supply(kord)
+    override val supplier: EntitySupplier = strategy.supply(kord)
 
 }
 

From f791645e56d7ed03e15c4da92d8a49fb3cb2a4d4 Mon Sep 17 00:00:00 2001
From: BartArys <mysterybtdn@gmail.com>
Date: Sun, 9 May 2021 10:07:02 +0200
Subject: [PATCH 04/22] Specify withStrategy for Interactions

Return types are important!
---
 core/src/main/kotlin/entity/interaction/Interaction.kt | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/core/src/main/kotlin/entity/interaction/Interaction.kt b/core/src/main/kotlin/entity/interaction/Interaction.kt
index 714acf4dcc9..1bef7fffd6b 100644
--- a/core/src/main/kotlin/entity/interaction/Interaction.kt
+++ b/core/src/main/kotlin/entity/interaction/Interaction.kt
@@ -66,6 +66,8 @@ sealed class Interaction : InteractionBehavior {
      */
     val version: Int get() = data.version
 
+    abstract override fun withStrategy(strategy: EntitySupplyStrategy<*>): Interaction
+
     companion object {
         fun from(
             data: InteractionData,
@@ -291,6 +293,9 @@ class DmInteraction(
      * The user who invoked the interaction.
      */
     override val user get() = User(data.user.value!!, kord)
+
+    override fun withStrategy(strategy: EntitySupplyStrategy<*>): DmInteraction =
+        DmInteraction(data, applicationId, kord, strategy.supply(kord))
 }
 
 @KordPreview
@@ -325,6 +330,8 @@ class GuildInteraction(
     override val user: UserBehavior
         get() = UserBehavior(member.id, kord)
 
+    override fun withStrategy(strategy: EntitySupplyStrategy<*>): GuildInteraction =
+        GuildInteraction(data, applicationId, kord, supplier)
 
 }
 

From 05bad6a43dd7f0a758fb447e258c5fcd62f36908 Mon Sep 17 00:00:00 2001
From: BartArys <mysterybtdn@gmail.com>
Date: Mon, 10 May 2021 14:05:21 +0200
Subject: [PATCH 05/22] Introduce type to command options

Also add Mentionable.

Seems like Discord consistently tells us what kind of option an object is via the type field, this allows us to more clearly represent the json data in the lower level APIs.

I ended up deleting DiscordOptionValue and replacing it with a more fleshed out CommandArgument.
---
 common/src/main/kotlin/entity/Interactions.kt | 320 ++++++++++++++----
 .../src/test/kotlin/json/InteractionTest.kt   |  16 +-
 .../json/interaction/groupsubcommand.json     |   3 +
 .../json/interaction/rootcommand.json         |   2 +
 .../json/interaction/subcommand.json          |   2 +
 .../main/kotlin/cache/data/InteractionData.kt |   7 +-
 .../kotlin/entity/interaction/Interaction.kt  | 108 +++---
 .../kotlin/interaction/CommandTypesTest.kt    |   5 +
 8 files changed, 338 insertions(+), 125 deletions(-)

diff --git a/common/src/main/kotlin/entity/Interactions.kt b/common/src/main/kotlin/entity/Interactions.kt
index 80f4130d371..4cd693c2cc9 100644
--- a/common/src/main/kotlin/entity/Interactions.kt
+++ b/common/src/main/kotlin/entity/Interactions.kt
@@ -5,10 +5,8 @@ import dev.kord.common.annotation.KordPreview
 import dev.kord.common.entity.optional.Optional
 import dev.kord.common.entity.optional.OptionalBoolean
 import dev.kord.common.entity.optional.OptionalSnowflake
-import kotlinx.serialization.KSerializer
-import kotlinx.serialization.SerialName
-import kotlinx.serialization.Serializable
-import kotlinx.serialization.SerializationException
+import kotlinx.serialization.*
+import kotlinx.serialization.builtins.ListSerializer
 import kotlinx.serialization.builtins.serializer
 import kotlinx.serialization.descriptors.*
 import kotlinx.serialization.encoding.*
@@ -73,6 +71,7 @@ sealed class ApplicationCommandOptionType(val type: Int) {
     object User : ApplicationCommandOptionType(6)
     object Channel : ApplicationCommandOptionType(7)
     object Role : ApplicationCommandOptionType(8)
+    object Mentionable : ApplicationCommandOptionType(9)
     class Unknown(type: Int) : ApplicationCommandOptionType(type)
 
     companion object;
@@ -220,6 +219,7 @@ data class DiscordApplicationCommandInteractionData(
 @KordPreview
 sealed class Option {
     abstract val name: String
+    abstract val type: ApplicationCommandOptionType
 
     internal object Serializer : KSerializer<Option> {
 
@@ -227,6 +227,7 @@ sealed class Option {
             element("name", String.serializer().descriptor, isOptional = false)
             element("value", JsonElement.serializer().descriptor, isOptional = true)
             element("options", JsonArray.serializer().descriptor, isOptional = true)
+            element("type", ApplicationCommandOptionType.serializer().descriptor, isOptional = false)
         }
 
         override fun deserialize(decoder: Decoder): Option {
@@ -234,14 +235,17 @@ sealed class Option {
             val json = decoder.json
 
             var name = ""
-            var jsonValue: JsonPrimitive? = null
+            var jsonValue: JsonElement? = null
             var jsonOptions: JsonArray? = null
+            var type: ApplicationCommandOptionType? = null
             decoder.decodeStructure(descriptor) {
                 while (true) {
                     when (val index = decodeElementIndex(descriptor)) {
                         0 -> name = decodeStringElement(descriptor, index)
-                        1 -> jsonValue = decodeSerializableElement(descriptor, index, JsonPrimitive.serializer())
+                        1 -> jsonValue = decodeSerializableElement(descriptor, index, JsonElement.serializer())
                         2 -> jsonOptions = decodeSerializableElement(descriptor, index, JsonArray.serializer())
+                        3 -> type =
+                            decodeSerializableElement(descriptor, index, ApplicationCommandOptionType.serializer())
 
                         CompositeDecoder.DECODE_DONE -> return@decodeStructure
                         else -> throw SerializationException("unknown index: $index")
@@ -249,33 +253,67 @@ sealed class Option {
                 }
             }
 
-            jsonValue?.let { value -> // name + value == command option, i.e. an argument
-                return CommandArgument(name, DiscordOptionValue(value))
-            }
-
-            if (jsonOptions == null) { // name -value -options == can only be sub command
-                return SubCommand(name, Optional.Missing())
-            }
-
-            //options are present, either a subcommand or a group, we'll have to look at its children
-            val nestedOptions = jsonOptions?.map { json.decodeFromJsonElement(serializer(), it) } ?: emptyList()
+            requireNotNull(type) { "'type' expected for $name but was absent" }
 
-            if (nestedOptions.isEmpty()) { //only subcommands can have no children
-                return SubCommand(name, Optional(emptyList()))
-            }
+            return when (type) {
+                ApplicationCommandOptionType.SubCommand -> {
+                    val options = if (jsonOptions == null) Optional.Missing()
+                    else Optional.Value(jsonOptions!!.map {
+                        json.decodeFromJsonElement(serializer(), it) as CommandArgument<*>
+                    })
 
-            val onlyArguments =
-                nestedOptions.all { it is CommandArgument } //only subcommand can have options at this point
-            if (onlyArguments) return SubCommand(name, Optional(nestedOptions.filterIsInstance<CommandArgument>()))
+                    SubCommand(name, options)
+                }
 
-            val onlySubCommands = nestedOptions.all { it is SubCommand } //only groups can have options at this point
-            if (onlySubCommands) return CommandGroup(name, Optional(nestedOptions.filterIsInstance<SubCommand>()))
+                ApplicationCommandOptionType.SubCommandGroup -> {
+                    val options = if (jsonOptions == null) Optional.Missing()
+                    else Optional.Value(jsonOptions!!.map {
+                        json.decodeFromJsonElement(serializer(), it) as SubCommand
+                    })
 
-            error("option mixed option arguments and option subcommands: $jsonOptions")
+                    CommandGroup(name, options)
+                }
+                ApplicationCommandOptionType.Boolean,
+                ApplicationCommandOptionType.Channel,
+                ApplicationCommandOptionType.Integer,
+                ApplicationCommandOptionType.Mentionable,
+                ApplicationCommandOptionType.Role,
+                ApplicationCommandOptionType.String,
+                ApplicationCommandOptionType.User -> CommandArgument.Serializer.deserialize(
+                    json, jsonValue!!, name, type!!
+                )
+                else -> error("unknown ApplicationCommandOptionType $type")
+            }
         }
 
         override fun serialize(encoder: Encoder, value: Option) {
-            TODO("Not yet implemented")
+            when(value){
+                is CommandArgument<*> -> CommandArgument.Serializer.serialize(encoder, value)
+                is CommandGroup -> encoder.encodeStructure(descriptor) {
+                    encodeSerializableElement(
+                        descriptor, 0, String.serializer(), value.name
+                    )
+                    encodeSerializableElement(
+                        descriptor, 2, Optional.serializer(ListSerializer(Serializer)), value.options
+                    )
+
+                    encodeSerializableElement(
+                        descriptor, 3, ApplicationCommandOptionType.serializer(), value.type
+                    )
+                }
+                is SubCommand -> encoder.encodeStructure(descriptor) {
+                    encodeSerializableElement(
+                        descriptor, 0, String.serializer(), value.name
+                    )
+                    encodeSerializableElement(
+                        descriptor, 2, Optional.serializer(ListSerializer(Serializer)), value.options
+                    )
+
+                    encodeSerializableElement(
+                        descriptor, 3, ApplicationCommandOptionType.serializer(), value.type
+                    )
+                }
+            }
         }
     }
 }
@@ -284,86 +322,220 @@ sealed class Option {
 @KordPreview
 data class SubCommand(
     override val name: String,
-    val options: Optional<List<CommandArgument>> = Optional.Missing()
-) : Option()
+    val options: Optional<List<CommandArgument<@Contextual Any?>>> = Optional.Missing()
+) : Option() {
+    override val type: ApplicationCommandOptionType
+        get() = ApplicationCommandOptionType.SubCommand
+}
 
-@Serializable
 @KordPreview
-data class CommandArgument(
-    override val name: String,
-    @OptIn(KordExperimental::class)
-    val value: DiscordOptionValue<@Serializable(NotSerializable::class) Any?>,
-) : Option()
+@Serializable(with = CommandArgument.Serializer::class)
+sealed class CommandArgument<out T> : Option() {
 
-@Serializable
-@KordPreview
-data class CommandGroup(
-    override val name: String,
-    val options: Optional<List<SubCommand>> = Optional.Missing(),
-) : Option()
+    abstract val value: T
 
-@Serializable(DiscordOptionValue.OptionValueSerializer::class)
-@KordPreview
-sealed class DiscordOptionValue<out T>(val value: T) {
-    class IntValue(value: Int) : DiscordOptionValue<Int>(value)
-    class StringValue(value: String) : DiscordOptionValue<String>(value)
-    class BooleanValue(value: Boolean) : DiscordOptionValue<Boolean>(value)
+    class StringArgument(
+        override val name: String,
+        override val value: String
+    ) : CommandArgument<String>() {
+        override val type: ApplicationCommandOptionType
+            get() = ApplicationCommandOptionType.String
 
-    override fun toString(): String = when (this) {
-        is IntValue -> "OptionValue.IntValue($value)"
-        is StringValue -> "OptionValue.StringValue($value)"
-        is BooleanValue -> "OptionValue.BooleanValue($value)"
+        override fun toString(): String = "StringArgument(name=$name, value=$value)"
     }
 
-    internal class OptionValueSerializer<T>(serializer: KSerializer<T>) : KSerializer<DiscordOptionValue<*>> {
-        override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("OptionValue", PrimitiveKind.STRING)
+    class IntegerArgument(
+        override val name: String,
+        override val value: Int
+    ) : CommandArgument<Int>() {
+        override val type: ApplicationCommandOptionType
+            get() = ApplicationCommandOptionType.Integer
+
+        override fun toString(): String = "IntegerArgument(name=$name, value=$value)"
+    }
+
+    class BooleanArgument(
+        override val name: String,
+        override val value: Boolean
+    ) : CommandArgument<Boolean>() {
+        override val type: ApplicationCommandOptionType
+            get() = ApplicationCommandOptionType.Boolean
+
+        override fun toString(): String = "BooleanArgument(name=$name, value=$value)"
+    }
+
+    class UserArgument(
+        override val name: String,
+        override val value: Snowflake
+    ) : CommandArgument<Snowflake>() {
+        override val type: ApplicationCommandOptionType
+            get() = ApplicationCommandOptionType.User
+
+        override fun toString(): String = "UserArgument(name=$name, value=$value)"
+    }
 
-        override fun deserialize(decoder: Decoder): DiscordOptionValue<*> {
-            val value = (decoder as JsonDecoder).decodeJsonElement().jsonPrimitive
-            return when {
-                value.isString -> StringValue(value.toString())
-                value.booleanOrNull != null -> BooleanValue(value.boolean)
-                else -> IntValue(value.int)
+    class ChannelArgument(
+        override val name: String,
+        override val value: Snowflake
+    ) : CommandArgument<Snowflake>() {
+        override val type: ApplicationCommandOptionType
+            get() = ApplicationCommandOptionType.Channel
+
+        override fun toString(): String = "ChannelArgument(name=$name, value=$value)"
+    }
+
+    class RoleArgument(
+        override val name: String,
+        override val value: Snowflake
+    ) : CommandArgument<Snowflake>() {
+        override val type: ApplicationCommandOptionType
+            get() = ApplicationCommandOptionType.Role
+
+        override fun toString(): String = "RoleArgument(name=$name, value=$value)"
+    }
+
+    class MentionableArgument(
+        override val name: String,
+        override val value: Snowflake
+    ) : CommandArgument<Snowflake>() {
+        override val type: ApplicationCommandOptionType
+            get() = ApplicationCommandOptionType.Mentionable
+
+        override fun toString(): String = "MentionableArgument(name=$name, value=$value)"
+    }
+
+    internal object Serializer : KSerializer<CommandArgument<*>> {
+
+        override val descriptor: SerialDescriptor = buildClassSerialDescriptor("kord.CommandArgument") {
+            element("name", String.serializer().descriptor)
+            element("value", JsonElement.serializer().descriptor)
+            element("type", ApplicationCommandOptionType.serializer().descriptor)
+        }
+
+        override fun serialize(encoder: Encoder, value: CommandArgument<*>) {
+            encoder.encodeStructure(descriptor) {
+                encodeStringElement(descriptor, 0, value.name)
+                encodeSerializableElement(descriptor, 1, ApplicationCommandOptionType.serializer(), value.type)
+                when (value) {
+                    is BooleanArgument -> encodeBooleanElement(descriptor, 3, value.value)
+                    is ChannelArgument -> encodeSerializableElement(
+                        descriptor,
+                        3,
+                        Snowflake.serializer(),
+                        value.value
+                    )
+                    is RoleArgument -> encodeSerializableElement(
+                        descriptor,
+                        3,
+                        Snowflake.serializer(),
+                        value.value
+                    )
+                    is MentionableArgument -> encodeSerializableElement(
+                        descriptor,
+                        3,
+                        Snowflake.serializer(),
+                        value.value
+                    )
+                    is UserArgument -> encodeSerializableElement(
+                        descriptor,
+                        3,
+                        Snowflake.serializer(),
+                        value.value
+                    )
+                    is IntegerArgument -> encodeIntElement(descriptor, 3, value.value)
+                    is StringArgument -> encodeStringElement(descriptor, 3, value.value)
+                }
             }
         }
 
-        override fun serialize(encoder: Encoder, value: DiscordOptionValue<*>) {
-            when (value) {
-                is IntValue -> encoder.encodeInt(value.value)
-                is StringValue -> encoder.encodeString(value.value)
-                is BooleanValue -> encoder.encodeBoolean(value.value)
+        fun deserialize(
+            json: Json,
+            element: JsonElement,
+            name: String,
+            type: ApplicationCommandOptionType
+        ): CommandArgument<*> = when (type) {
+            ApplicationCommandOptionType.Boolean -> BooleanArgument(
+                name, json.decodeFromJsonElement(Boolean.serializer(), element)
+            )
+            ApplicationCommandOptionType.String -> StringArgument(
+                name, json.decodeFromJsonElement(String.serializer(), element)
+            )
+            ApplicationCommandOptionType.Integer -> IntegerArgument(
+                name, json.decodeFromJsonElement(Int.serializer(), element)
+            )
+            ApplicationCommandOptionType.Channel -> ChannelArgument(
+                name, json.decodeFromJsonElement(Snowflake.serializer(), element)
+            )
+            ApplicationCommandOptionType.Mentionable -> MentionableArgument(
+                name, json.decodeFromJsonElement(Snowflake.serializer(), element)
+            )
+            ApplicationCommandOptionType.Role -> RoleArgument(
+                name, json.decodeFromJsonElement(Snowflake.serializer(), element)
+            )
+            ApplicationCommandOptionType.User -> UserArgument(
+                name, json.decodeFromJsonElement(Snowflake.serializer(), element)
+            )
+            ApplicationCommandOptionType.SubCommand,
+            ApplicationCommandOptionType.SubCommandGroup,
+            is ApplicationCommandOptionType.Unknown -> error("unknown CommandArgument type ${type.type}")
+        }
+
+        override fun deserialize(decoder: Decoder): CommandArgument<*> {
+            decoder.decodeStructure(descriptor) {
+                this as JsonDecoder
+
+                var name = ""
+                var element: JsonElement? = null
+                var type: ApplicationCommandOptionType? = null
+                while (true) {
+                    when (val index = decodeElementIndex(Option.Serializer.descriptor)) {
+                        0 -> name = decodeSerializableElement(descriptor, index, String.serializer())
+                        1 -> element = decodeSerializableElement(descriptor, index, JsonElement.serializer())
+                        2 -> type = decodeSerializableElement(
+                            descriptor,
+                            index,
+                            ApplicationCommandOptionType.serializer()
+                        )
+
+                        CompositeDecoder.DECODE_DONE -> break
+                        else -> error("unknown index: $index")
+                    }
+                }
+
+                requireNotNull(element)
+                requireNotNull(type)
+                return deserialize(json, element, name, type)
             }
         }
     }
 }
 
 @KordPreview
-fun DiscordOptionValue(value: JsonPrimitive): DiscordOptionValue<Any> = when {
-    value.isString -> DiscordOptionValue.StringValue(value.content)
-    value.booleanOrNull != null -> DiscordOptionValue.BooleanValue(value.boolean)
-    value.intOrNull != null -> DiscordOptionValue.IntValue(value.int)
-    else -> throw SerializationException("unknown value type for option")
+data class CommandGroup(
+    override val name: String,
+    val options: Optional<List<SubCommand>> = Optional.Missing(),
+) : Option() {
+    override val type: ApplicationCommandOptionType
+        get() = ApplicationCommandOptionType.SubCommandGroup
 }
 
-
 @KordPreview
-fun DiscordOptionValue<*>.int(): Int {
+fun CommandArgument<*>.int(): Int {
     return value as? Int ?: error("$value wasn't an Int.")
 }
 
-
 @KordPreview
-fun DiscordOptionValue<*>.string(): String {
+fun CommandArgument<*>.string(): String {
     return value.toString()
 }
 
 @KordPreview
-fun DiscordOptionValue<*>.boolean(): Boolean {
+fun CommandArgument<*>.boolean(): Boolean {
     return value as? Boolean ?: error("$value wasn't a Boolean.")
 }
 
 @KordPreview
-fun DiscordOptionValue<*>.snowflake(): Snowflake {
+fun CommandArgument<*>.snowflake(): Snowflake {
     val id = string().toLongOrNull() ?: error("$value wasn't a Snowflake")
     return Snowflake(id)
 }
diff --git a/common/src/test/kotlin/json/InteractionTest.kt b/common/src/test/kotlin/json/InteractionTest.kt
index 441cadda716..1fad5365c8b 100644
--- a/common/src/test/kotlin/json/InteractionTest.kt
+++ b/common/src/test/kotlin/json/InteractionTest.kt
@@ -45,8 +45,8 @@ class InteractionTest {
             subCommand.name shouldBe "groupsubcommand"
             val arg = subCommand.options.orEmpty().first()
             arg.name shouldBe "testint"
-            arg.value.int() shouldBe 1
-            arg.value.string() shouldBe "1"
+            arg.int() shouldBe 1
+            arg.string() shouldBe "1"
         }
     }
 
@@ -70,8 +70,8 @@ class InteractionTest {
             subCommand.name shouldBe "subcommand"
             val arg = subCommand.options.orEmpty().first()
             arg.name shouldBe "testint"
-            arg.value.int() shouldBe 1
-            arg.value.string() shouldBe "1"
+            arg.int() shouldBe 1
+            arg.string() shouldBe "1"
         }
     }
 
@@ -91,11 +91,11 @@ class InteractionTest {
             data.name shouldBe "testsubcommands"
             data.id shouldBe "792107855418490901"
             val arg = data.options.orEmpty().first()
-            assert(arg is CommandArgument)
-            arg as CommandArgument
+            assert(arg is CommandArgument<*>)
+            arg as CommandArgument<*>
             arg.name shouldBe "testint"
-            arg.value.int() shouldBe 1
-            arg.value.string() shouldBe "1"
+            arg.int() shouldBe 1
+            arg.string() shouldBe "1"
         }
     }
 
diff --git a/common/src/test/resources/json/interaction/groupsubcommand.json b/common/src/test/resources/json/interaction/groupsubcommand.json
index b43e6477074..a3234490c49 100644
--- a/common/src/test/resources/json/interaction/groupsubcommand.json
+++ b/common/src/test/resources/json/interaction/groupsubcommand.json
@@ -27,10 +27,13 @@
   "data": {
     "options": [
       {
+        "type": 2,
         "options": [
           {
+            "type": "1",
             "options": [
               {
+                "type": 4,
                 "value": 1,
                 "name": "testint"
               }
diff --git a/common/src/test/resources/json/interaction/rootcommand.json b/common/src/test/resources/json/interaction/rootcommand.json
index ab52e9c29b4..a68a56892da 100644
--- a/common/src/test/resources/json/interaction/rootcommand.json
+++ b/common/src/test/resources/json/interaction/rootcommand.json
@@ -25,8 +25,10 @@
   "id": "793442788670832640",
   "guild_id": "556525343595298817",
   "data": {
+    "type": 1,
     "options": [
       {
+        "type": 4,
         "value": 1,
         "name": "testint"
       }
diff --git a/common/src/test/resources/json/interaction/subcommand.json b/common/src/test/resources/json/interaction/subcommand.json
index 8ae1d55ccea..979655eb828 100644
--- a/common/src/test/resources/json/interaction/subcommand.json
+++ b/common/src/test/resources/json/interaction/subcommand.json
@@ -27,8 +27,10 @@
   "data": {
     "options": [
       {
+        "type": "1",
         "options": [
           {
+                "type": 4,
                 "value": 1,
                 "name": "testint"
               }
diff --git a/core/src/main/kotlin/cache/data/InteractionData.kt b/core/src/main/kotlin/cache/data/InteractionData.kt
index 18a0b562298..031552e97bc 100644
--- a/core/src/main/kotlin/cache/data/InteractionData.kt
+++ b/core/src/main/kotlin/cache/data/InteractionData.kt
@@ -6,6 +6,7 @@ import dev.kord.common.entity.*
 import dev.kord.common.entity.NotSerializable
 import dev.kord.common.entity.optional.*
 import dev.kord.gateway.InteractionCreate
+import kotlinx.serialization.Contextual
 import kotlinx.serialization.KSerializer
 import kotlinx.serialization.Serializable
 import kotlinx.serialization.builtins.serializer
@@ -100,15 +101,15 @@ data class ApplicationCommandInteractionData(
 data class OptionData(
     val name: String,
     @OptIn(KordExperimental::class)
-    val value: Optional<DiscordOptionValue<@Serializable(NotSerializable::class) Any?>> = Optional.Missing(),
-    val values: Optional<List<CommandArgument>> = Optional.Missing(),
+    val value: Optional<CommandArgument<@Serializable(NotSerializable::class) Any?>> = Optional.Missing(),
+    val values: Optional<List<CommandArgument<@Serializable(NotSerializable::class) Any?>>> = Optional.Missing(),
     val subCommands: Optional<List<SubCommand>> = Optional.Missing()
 ) {
     companion object {
         fun from(data: Option): OptionData = with(data) {
             when (data) {
                 is SubCommand -> OptionData(name, values = data.options)
-                is CommandArgument -> OptionData(name, value = Optional(data.value))
+                is CommandArgument<*> -> OptionData(name, value = Optional(data))
                 is CommandGroup -> OptionData(name, subCommands = data.options)
             }
         }
diff --git a/core/src/main/kotlin/entity/interaction/Interaction.kt b/core/src/main/kotlin/entity/interaction/Interaction.kt
index 1bef7fffd6b..9c1e6bad2d6 100644
--- a/core/src/main/kotlin/entity/interaction/Interaction.kt
+++ b/core/src/main/kotlin/entity/interaction/Interaction.kt
@@ -1,8 +1,7 @@
 package dev.kord.core.entity.interaction
 
-import dev.kord.core.behavior.interaction.InteractionBehavior
 import dev.kord.common.annotation.KordPreview
-import dev.kord.common.entity.DiscordOptionValue
+import dev.kord.common.entity.CommandArgument
 import dev.kord.common.entity.InteractionType
 import dev.kord.common.entity.Permissions
 import dev.kord.common.entity.Snowflake
@@ -14,10 +13,11 @@ import dev.kord.core.behavior.GuildInteractionBehavior
 import dev.kord.core.behavior.MemberBehavior
 import dev.kord.core.behavior.UserBehavior
 import dev.kord.core.behavior.channel.GuildMessageChannelBehavior
-import dev.kord.core.behavior.channel.MessageChannelBehavior
+import dev.kord.core.behavior.interaction.InteractionBehavior
 import dev.kord.core.cache.data.ApplicationCommandInteractionData
 import dev.kord.core.cache.data.InteractionData
 import dev.kord.core.cache.data.ResolvedObjectsData
+import dev.kord.core.entity.Entity
 import dev.kord.core.entity.Member
 import dev.kord.core.entity.Role
 import dev.kord.core.entity.User
@@ -25,7 +25,6 @@ import dev.kord.core.entity.channel.DmChannel
 import dev.kord.core.entity.channel.ResolvedChannel
 import dev.kord.core.supplier.EntitySupplier
 import dev.kord.core.supplier.EntitySupplyStrategy
-import dev.kord.core.toSnowflakeOrNull
 
 /**
  * An instance of [Interaction] (https://discord.com/developers/docs/interactions/slash-commands#interaction)
@@ -172,7 +171,7 @@ class SubCommand(
 
     override val options: Map<String, OptionValue<*>>
         get() = subCommandData.values.orEmpty()
-            .associate { it.name to OptionValue(it.value, resolved) }
+            .associate { it.name to OptionValue(it, resolved) }
 
 
     override val resolved: ResolvedObjects?
@@ -210,7 +209,7 @@ class GroupCommand(
 
     override val options: Map<String, OptionValue<*>>
         get() = subCommandData.options.orEmpty()
-            .associate { it.name to OptionValue(it.value, resolved) }
+            .associate { it.name to OptionValue(it, resolved) }
 
 
     override val resolved: ResolvedObjects?
@@ -231,49 +230,78 @@ class ResolvedObjects(
     val users: Map<Snowflake, User>? get() = data.users.mapValues { User(it.value, kord) }.value
     val members: Map<Snowflake, Member>?
         get() = data.members.mapValues {
-            Member(
-                it.value,
-                users!!.get(it.key)!!.data,
-                kord
-            )
+            Member(it.value,users!![it.key]!!.data, kord)
         }.value
 
 }
 
 @KordPreview
-sealed class OptionValue<T>(val value: T) {
-
-    class RoleOptionValue(value: Role) : OptionValue<Role>(value)
-    open class UserOptionValue(value: User) : OptionValue<User>(value)
-    class MemberOptionValue(value: Member) : UserOptionValue(value)
-    class ChannelOptionValue(value: ResolvedChannel) : OptionValue<ResolvedChannel>(value)
-    class IntOptionValue(value: Int) : OptionValue<Int>(value)
-    class StringOptionValue(value: String) : OptionValue<String>(value)
-    class BooleanOptionValue(value: Boolean) : OptionValue<Boolean>(value)
+sealed class OptionValue<out T>(val value: T) {
+
+    class RoleOptionValue(value: Role) : OptionValue<Role>(value) {
+        override fun toString(): String = "RoleOptionValue(value=$value)"
+    }
+    open class UserOptionValue(value: User) : OptionValue<User>(value) {
+        override fun toString(): String = "UserOptionValue(value=$value)"
+    }
+    class MemberOptionValue(value: Member) : UserOptionValue(value) {
+        override fun toString(): String = "MemberOptionValue(value=$value)"
+    }
+    class ChannelOptionValue(value: ResolvedChannel) : OptionValue<ResolvedChannel>(value) {
+        override fun toString(): String = "ChannelOptionValue(value=$value)"
+    }
+    class IntOptionValue(value: Int) : OptionValue<Int>(value) {
+        override fun toString(): String = "IntOptionValue(value=$value)"
+    }
+    class StringOptionValue(value: String) : OptionValue<String>(value) {
+        override fun toString(): String = "StringOptionValue(value=$value)"
+    }
+    class BooleanOptionValue(value: Boolean) : OptionValue<Boolean>(value) {
+        override fun toString(): String = "BooleanOptionValue(value=$value)"
+    }
+    class MentionableOptionValue(value: Entity) : OptionValue<Entity>(value) {
+        override fun toString(): String = "MentionableOptionValue(value=$value)"
+    }
 }
 
 @KordPreview
-fun OptionValue(value: DiscordOptionValue<*>, resolvedObjects: ResolvedObjects?): OptionValue<*> {
+fun OptionValue(value: CommandArgument<*>, resolvedObjects: ResolvedObjects?): OptionValue<*> {
     return when (value) {
-        is DiscordOptionValue.BooleanValue -> OptionValue.BooleanOptionValue(value.value)
-        is DiscordOptionValue.IntValue -> OptionValue.IntOptionValue(value.value)
-        is DiscordOptionValue.StringValue -> {
-            if (resolvedObjects == null) return OptionValue.StringOptionValue(value.value)
-
-            val string = value.value
-            val snowflake = string.toLongOrNull().toSnowflakeOrNull() ?: return OptionValue.StringOptionValue(string)
-
-            when {
-                resolvedObjects.members?.get(snowflake) != null ->
-                    OptionValue.MemberOptionValue(resolvedObjects.members?.get(snowflake)!!)
-                resolvedObjects.users?.get(snowflake) != null ->
-                    OptionValue.UserOptionValue(resolvedObjects.users?.get(snowflake)!!)
-                resolvedObjects.channels?.get(snowflake) != null ->
-                    OptionValue.ChannelOptionValue(resolvedObjects.channels?.get(snowflake)!!)
-                resolvedObjects.roles?.get(snowflake) != null ->
-                    OptionValue.RoleOptionValue(resolvedObjects.roles?.get(snowflake)!!)
-                else -> OptionValue.StringOptionValue(string)
-            }
+        is CommandArgument.BooleanArgument -> OptionValue.BooleanOptionValue(value.value)
+        is CommandArgument.IntegerArgument -> OptionValue.IntOptionValue(value.value)
+        is CommandArgument.StringArgument -> OptionValue.StringOptionValue(value.value)
+        is CommandArgument.ChannelArgument -> {
+            val channel = resolvedObjects?.channels.orEmpty()[value.value]
+            requireNotNull(channel) { "channel expected for $value but was missing" }
+
+            OptionValue.ChannelOptionValue(channel)
+        }
+
+        is CommandArgument.MentionableArgument -> {
+            val channel = resolvedObjects?.channels.orEmpty()[value.value]
+            val user = resolvedObjects?.channels.orEmpty()[value.value]
+            val member = resolvedObjects?.members.orEmpty()[value.value]
+            val role = resolvedObjects?.members.orEmpty()[value.value]
+
+            OptionValue.MentionableOptionValue((channel ?: user ?: member ?: role)!!)
+        }
+
+        is CommandArgument.RoleArgument -> {
+            val role = resolvedObjects?.roles.orEmpty()[value.value]
+            requireNotNull(role) { "role expected for $value but was missing" }
+
+            OptionValue.RoleOptionValue(role)
+        }
+
+        is CommandArgument.UserArgument -> {
+            val member = resolvedObjects?.members.orEmpty()[value.value]
+
+            if (member != null) return OptionValue.MemberOptionValue(member)
+
+            val user = resolvedObjects?.users.orEmpty()[value.value]
+            requireNotNull(user) { "user expected for $value but was missing" }
+
+            OptionValue.UserOptionValue(user)
         }
     }
 }
diff --git a/core/src/test/kotlin/interaction/CommandTypesTest.kt b/core/src/test/kotlin/interaction/CommandTypesTest.kt
index b9af24e79d8..f785894176e 100644
--- a/core/src/test/kotlin/interaction/CommandTypesTest.kt
+++ b/core/src/test/kotlin/interaction/CommandTypesTest.kt
@@ -1,6 +1,7 @@
 package interaction
 
 import dev.kord.common.annotation.KordPreview
+import dev.kord.common.entity.ApplicationCommandOptionType
 import dev.kord.common.entity.DiscordApplicationCommandInteractionData
 import dev.kord.core.cache.data.ApplicationCommandInteractionData
 import dev.kord.core.entity.interaction.*
@@ -12,6 +13,7 @@ import kotlin.test.assertEquals
 @KordPreview
 class CommandsTypeTests {
     val arg = buildJsonObject {
+        put("type", ApplicationCommandOptionType.Integer.type)
         put("name", "argument")
         put("value", 1)
     }
@@ -21,6 +23,7 @@ class CommandsTypeTests {
         putJsonArray("options") { add(arg) }
     }
     val partialSubCommand = buildJsonObject {
+        put("type", ApplicationCommandOptionType.SubCommand.type)
         put("name", "subCommand")
         putJsonArray("options") { add(arg) }
     }
@@ -32,8 +35,10 @@ class CommandsTypeTests {
         }
 
     val group = buildJsonObject {
+
         putJsonArray("options") {
             addJsonObject {
+                put("type", ApplicationCommandOptionType.SubCommandGroup.type)
                 put("name", "group")
                 putJsonArray("options") { add(partialSubCommand) }
             }

From f2aab317c1525ef065b25eedb103e31cd6e61667 Mon Sep 17 00:00:00 2001
From: BartArys <mysterybtdn@gmail.com>
Date: Mon, 10 May 2021 17:46:49 +0200
Subject: [PATCH 06/22] Add KordDsl to builders

---
 .../interaction/ApplicationCommandBuilders.kt        |  2 ++
 .../interaction/EphemeralInteractionBuilders.kt      |  4 +++-
 .../kotlin/builder/interaction/OptionsBuilder.kt     | 12 ++++++++++++
 3 files changed, 17 insertions(+), 1 deletion(-)

diff --git a/rest/src/main/kotlin/builder/interaction/ApplicationCommandBuilders.kt b/rest/src/main/kotlin/builder/interaction/ApplicationCommandBuilders.kt
index 35532e1bd52..faabf826fab 100644
--- a/rest/src/main/kotlin/builder/interaction/ApplicationCommandBuilders.kt
+++ b/rest/src/main/kotlin/builder/interaction/ApplicationCommandBuilders.kt
@@ -159,6 +159,7 @@ class ApplicationCommandModifyBuilder : BaseApplicationBuilder(),
 }
 
 
+@KordDsl
 @KordPreview
 class ApplicationCommandPermissionsBulkModifyBuilder :
         RequestBuilder<List<PartialDiscordGuildApplicationCommandPermissions>> {
@@ -187,6 +188,7 @@ class ApplicationCommandPermissionsBulkModifyBuilder :
     }
 }
 
+@KordDsl
 @KordPreview
 class ApplicationCommandPermissionsModifyBuilder :
         RequestBuilder<ApplicationCommandPermissionsEditRequest> {
diff --git a/rest/src/main/kotlin/builder/interaction/EphemeralInteractionBuilders.kt b/rest/src/main/kotlin/builder/interaction/EphemeralInteractionBuilders.kt
index 4b06c7b946e..7774f8d3005 100644
--- a/rest/src/main/kotlin/builder/interaction/EphemeralInteractionBuilders.kt
+++ b/rest/src/main/kotlin/builder/interaction/EphemeralInteractionBuilders.kt
@@ -1,5 +1,6 @@
 package dev.kord.rest.builder.interaction
 
+import dev.kord.common.annotation.KordDsl
 import dev.kord.common.annotation.KordPreview
 import dev.kord.common.entity.AllowedMentions
 import dev.kord.common.entity.InteractionResponseType
@@ -17,6 +18,7 @@ import kotlin.contracts.ExperimentalContracts
 import kotlin.contracts.InvocationKind
 import kotlin.contracts.contract
 
+@KordDsl
 @KordPreview
 class EphemeralInteractionResponseModifyBuilder : RequestBuilder<InteractionResponseModifyRequest> {
     private var _content: Optional<String> = Optional.Missing()
@@ -40,7 +42,7 @@ class EphemeralInteractionResponseModifyBuilder : RequestBuilder<InteractionResp
     }
 }
 
-
+@KordDsl
 @KordPreview
 class EphemeralInteractionResponseCreateBuilder : RequestBuilder<InteractionResponseCreateRequest> {
     private var _content: Optional<String> = Optional.Missing()
diff --git a/rest/src/main/kotlin/builder/interaction/OptionsBuilder.kt b/rest/src/main/kotlin/builder/interaction/OptionsBuilder.kt
index 0336c5202e6..dc4ca128297 100644
--- a/rest/src/main/kotlin/builder/interaction/OptionsBuilder.kt
+++ b/rest/src/main/kotlin/builder/interaction/OptionsBuilder.kt
@@ -1,5 +1,6 @@
 package dev.kord.rest.builder.interaction
 
+import dev.kord.common.annotation.KordDsl
 import dev.kord.common.annotation.KordPreview
 import dev.kord.common.entity.ApplicationCommandOption
 import dev.kord.common.entity.ApplicationCommandOptionType
@@ -13,6 +14,7 @@ import kotlin.contracts.ExperimentalContracts
 import kotlin.contracts.InvocationKind
 import kotlin.contracts.contract
 
+@KordDsl
 @KordPreview
 sealed class OptionsBuilder(
     var name: String,
@@ -31,6 +33,7 @@ sealed class OptionsBuilder(
     }
 }
 
+@KordDsl
 @KordPreview
 sealed class BaseChoiceBuilder<T>(
     name: String,
@@ -56,6 +59,7 @@ sealed class BaseChoiceBuilder<T>(
 
 }
 
+@KordDsl
 @KordPreview
 class IntChoiceBuilder(name: String, description: String) :
     BaseChoiceBuilder<Int>(name, description, ApplicationCommandOptionType.Integer) {
@@ -66,6 +70,7 @@ class IntChoiceBuilder(name: String, description: String) :
     }
 }
 
+@KordDsl
 @KordPreview
 class StringChoiceBuilder(name: String, description: String) :
     BaseChoiceBuilder<String>(name, description, ApplicationCommandOptionType.String) {
@@ -76,22 +81,27 @@ class StringChoiceBuilder(name: String, description: String) :
     }
 }
 
+@KordDsl
 @KordPreview
 class BooleanBuilder(name: String, description: String) :
     OptionsBuilder(name, description, ApplicationCommandOptionType.Boolean)
 
+@KordDsl
 @KordPreview
 class UserBuilder(name: String, description: String) :
     OptionsBuilder(name, description, ApplicationCommandOptionType.User)
 
+@KordDsl
 @KordPreview
 class RoleBuilder(name: String, description: String) :
     OptionsBuilder(name, description, ApplicationCommandOptionType.Role)
 
+@KordDsl
 @KordPreview
 class ChannelBuilder(name: String, description: String) :
     OptionsBuilder(name, description, ApplicationCommandOptionType.Channel)
 
+@KordDsl
 @KordPreview
 sealed class BaseCommandOptionBuilder(
     name: String,
@@ -110,6 +120,7 @@ sealed class BaseCommandOptionBuilder(
     }
 }
 
+@KordDsl
 @KordPreview
 class SubCommandBuilder(name: String, description: String) :
     BaseCommandOptionBuilder(name, description, ApplicationCommandOptionType.SubCommand) {
@@ -160,6 +171,7 @@ class SubCommandBuilder(name: String, description: String) :
     }
 }
 
+@KordDsl
 @KordPreview
 class GroupCommandBuilder(name: String, description: String) :
     BaseCommandOptionBuilder(name, description, ApplicationCommandOptionType.SubCommandGroup) {

From 62b05610f02ce9b4b930afbd5452ffa8558b4fec Mon Sep 17 00:00:00 2001
From: BartArys <mysterybtdn@gmail.com>
Date: Fri, 14 May 2021 22:50:22 +0200
Subject: [PATCH 07/22] Add allowedMentions builder functions

---
 .../interaction/FollowupMessageBuilders.kt    | 34 +++++++++++++++----
 1 file changed, 28 insertions(+), 6 deletions(-)

diff --git a/rest/src/main/kotlin/builder/interaction/FollowupMessageBuilders.kt b/rest/src/main/kotlin/builder/interaction/FollowupMessageBuilders.kt
index 98253461e42..ace68b1b35c 100644
--- a/rest/src/main/kotlin/builder/interaction/FollowupMessageBuilders.kt
+++ b/rest/src/main/kotlin/builder/interaction/FollowupMessageBuilders.kt
@@ -123,8 +123,8 @@ class PublicFollowupMessageCreateBuilder : RequestBuilder<MultipartFollowupMessa
     private var _tts: OptionalBoolean = OptionalBoolean.Missing
     var tts: Boolean? by ::_tts.delegate()
 
-    private var _allowedMentions: Optional<AllowedMentions> = Optional.Missing()
-    var allowedMentions: AllowedMentions? by ::_allowedMentions.delegate()
+    private var _allowedMentions: Optional<AllowedMentionsBuilder> = Optional.Missing()
+    var allowedMentions: AllowedMentionsBuilder? by ::_allowedMentions.delegate()
 
     val files: MutableList<Pair<String, InputStream>> = mutableListOf()
     var embeds: MutableList<EmbedRequest> = mutableListOf()
@@ -137,6 +137,17 @@ class PublicFollowupMessageCreateBuilder : RequestBuilder<MultipartFollowupMessa
         addFile(path.fileName.toString(), Files.newInputStream(path))
     }
 
+    /**
+     * Configures the mentions that should trigger a mention (aka ping). Not calling this function will result in the default behavior
+     * (ping everything), calling this function but not configuring it before the request is build will result in all
+     * pings being ignored.
+     */
+    @OptIn(ExperimentalContracts::class)
+    inline fun allowedMentions(block: AllowedMentionsBuilder.() -> Unit = {}) {
+        contract { callsInPlace(block, InvocationKind.EXACTLY_ONCE) }
+        allowedMentions = (allowedMentions ?: AllowedMentionsBuilder()).apply(block)
+    }
+
     @OptIn(ExperimentalContracts::class)
     inline fun embed(builder: EmbedBuilder.() -> Unit) {
         contract {
@@ -151,7 +162,7 @@ class PublicFollowupMessageCreateBuilder : RequestBuilder<MultipartFollowupMessa
                 content = _content,
                 tts = _tts,
                 embeds = Optional.missingOnEmpty(embeds),
-                allowedMentions = _allowedMentions
+                allowedMentions = _allowedMentions.map { it.build() }
             ),
             files,
         )
@@ -167,15 +178,26 @@ class EphemeralFollowupMessageCreateBuilder(var content: String) :
     private var _tts: OptionalBoolean = OptionalBoolean.Missing
     var tts: Boolean? by ::_tts.delegate()
 
-    private var _allowedMentions: Optional<AllowedMentions> = Optional.Missing()
-    var allowedMentions: AllowedMentions? by ::_allowedMentions.delegate()
+    private var _allowedMentions: Optional<AllowedMentionsBuilder> = Optional.Missing()
+    var allowedMentions: AllowedMentionsBuilder? by ::_allowedMentions.delegate()
+
+    /**
+     * Configures the mentions that should trigger a mention (aka ping). Not calling this function will result in the default behavior
+     * (ping everything), calling this function but not configuring it before the request is build will result in all
+     * pings being ignored.
+     */
+    @OptIn(ExperimentalContracts::class)
+    inline fun allowedMentions(block: AllowedMentionsBuilder.() -> Unit = {}) {
+        contract { callsInPlace(block, InvocationKind.EXACTLY_ONCE) }
+        allowedMentions = (allowedMentions ?: AllowedMentionsBuilder()).apply(block)
+    }
 
     override fun toRequest(): MultipartFollowupMessageCreateRequest =
         MultipartFollowupMessageCreateRequest(
             FollowupMessageCreateRequest(
                 content = Optional.Value(content),
                 tts = _tts,
-                allowedMentions = _allowedMentions
+                allowedMentions = _allowedMentions.map { it.build() }
             ),
         )
 

From a1b3fa6e2b16c320f2ef1b00ec89c9978f4c0278 Mon Sep 17 00:00:00 2001
From: BartArys <mysterybtdn@gmail.com>
Date: Tue, 25 May 2021 19:10:05 +0200
Subject: [PATCH 08/22] Add permission edits to guild commands

---
 .../behavior/GlobalApplicationCommandBehavior.kt     | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/core/src/main/kotlin/behavior/GlobalApplicationCommandBehavior.kt b/core/src/main/kotlin/behavior/GlobalApplicationCommandBehavior.kt
index 9c3168ed4a0..0ae7a368b95 100644
--- a/core/src/main/kotlin/behavior/GlobalApplicationCommandBehavior.kt
+++ b/core/src/main/kotlin/behavior/GlobalApplicationCommandBehavior.kt
@@ -76,6 +76,18 @@ interface GuildApplicationCommandBehavior : ApplicationCommandBehavior {
         return GuildApplicationCommand(data, service, guildId)
     }
 
+    /**
+     * Updates the permissions for this command on the guild.
+     *
+     * @throws [RestRequestException] when something goes wrong during the request.
+     */
+    suspend fun editPermissions(
+        builder: ApplicationCommandPermissionsModifyBuilder.() -> Unit
+    ) {
+        val request = ApplicationCommandPermissionsModifyBuilder().apply(builder).toRequest()
+        service.editApplicationCommandPermissions(applicationId, guildId, id, request)
+    }
+
     override suspend fun delete() {
         service.deleteGuildApplicationCommand(applicationId, guildId, id)
     }

From a440dc78ac908604f872d213f7fb666df3b18c6d Mon Sep 17 00:00:00 2001
From: BartArys <mysterybtdn@gmail.com>
Date: Mon, 31 May 2021 00:30:17 +0200
Subject: [PATCH 09/22] Make full member available for guild contexts

---
 common/src/main/kotlin/entity/optional/Optional.kt     | 9 +++++++++
 core/src/main/kotlin/cache/data/InteractionData.kt     | 3 ++-
 core/src/main/kotlin/entity/interaction/Interaction.kt | 6 +++++-
 3 files changed, 16 insertions(+), 2 deletions(-)

diff --git a/common/src/main/kotlin/entity/optional/Optional.kt b/common/src/main/kotlin/entity/optional/Optional.kt
index 173710ba206..8ae5b83e993 100644
--- a/common/src/main/kotlin/entity/optional/Optional.kt
+++ b/common/src/main/kotlin/entity/optional/Optional.kt
@@ -239,6 +239,15 @@ inline fun <E : Any, T : Any> Optional<E>.map(mapper: (E) -> T): Optional<T> = w
     is Value -> Value(mapper(value))
 }
 
+/**
+ * Applies the [mapper] to the optional if it is a [Value], returns the same optional otherwise.
+ */
+@Suppress("UNCHECKED_CAST")
+inline fun <E : Any, T : Any> Optional<E>.flatMap(mapper: (E) -> Optional<T>): Optional<T> = when (this) {
+    is Missing, is Null<*> -> this as Optional<T>
+    is Value -> mapper(value)
+}
+
 @Suppress("UNCHECKED_CAST")
 @JvmName("mapNullableOptional")
 inline fun <E : Any, T : Any> Optional<E?>.map(mapper: (E) -> T): Optional<T?> = when (this) {
diff --git a/core/src/main/kotlin/cache/data/InteractionData.kt b/core/src/main/kotlin/cache/data/InteractionData.kt
index 031552e97bc..566cb3f1189 100644
--- a/core/src/main/kotlin/cache/data/InteractionData.kt
+++ b/core/src/main/kotlin/cache/data/InteractionData.kt
@@ -39,7 +39,8 @@ data class InteractionData(
                     guildId,
                     channelId,
                     member.map { it.toData(it.user.value!!.id, guildId.value!!) },
-                    user.map { it.toData() },
+                    //borrow user from member if present
+                    user.switchOnMissing(member.flatMap { it.user }).map { it.toData() },
                     token,
                     member.map { it.permissions },
                     version
diff --git a/core/src/main/kotlin/entity/interaction/Interaction.kt b/core/src/main/kotlin/entity/interaction/Interaction.kt
index 9c1e6bad2d6..9190b186a3c 100644
--- a/core/src/main/kotlin/entity/interaction/Interaction.kt
+++ b/core/src/main/kotlin/entity/interaction/Interaction.kt
@@ -350,7 +350,11 @@ class GuildInteraction(
     /**
      * The invoker of the command as [MemberBehavior].
      */
-    val member: MemberBehavior get() = MemberBehavior(guildId, data.member.value!!.userId, kord)
+    val member: Member get() = Member(
+        data.member.value!!,
+        data.user.value!!,
+        kord
+    )
 
     override val channel: GuildMessageChannelBehavior
         get() = GuildMessageChannelBehavior(guildId, channelId, kord)

From e047ba9e2a806971fbdb13c578a013d6bc05ce2d Mon Sep 17 00:00:00 2001
From: Michael Rittmeister <michael@rittmeister.in>
Date: Wed, 9 Jun 2021 22:21:59 +0200
Subject: [PATCH 10/22] Support buttons/components (#303)

* Add new API models and properties

* Add new InteractionCallbackType

* Add ability to send components

* Update core entities

* Update tests

* Add @KordPreview annotations

* Convert don't trust doc comments to normal comments

* Fix compilation issue

* Optimize interaction serializing

* Add builder

* Fix tests

* Apply some requested changes

* Hopefully fix formatting

* Make builders enforce Discord restrictions

* Improve builders again

* Remove LinkButtonBuilder.style

* Improve builders
- Add components to more supported builders
- Make required fields parameters
- Make builders appending

* Update deprecated message (#280)

* Expose the creation of application commands behavior (#281)

* Fix GuildUpdate core handling (#284)

* Expose the creation of application commands behavior

* Fix type of emitted event

* Sealed message types (#282)

* Expose the creation of application commands behavior

* Make message types sealed

* make Unknown a class

* Add missing message types

* make MessageTypeSerializer internal

* Add buttons to Activity (#287)

* Add buttons to Activity

* Also pass buttons in constructor

* Add missing fields to Guild (#288)

* Add missing fields to Guild
- Add welcome_screen
- Add nsfw

* Fix failing tests

* Fix another failing tests

* Add Message.applicationId (#289)

* Message interaction (#283)

* Expose the creation of application commands behavior

* Add interaction message

* Apply suggestions

* reference the MessageInteraction in docs

* Implement Strategizable for MessageInteraction

* cache user from interaction message

* Fix compilation errors

* Fix withStrategy return type

Co-authored-by: Bart Arys <BartArys@users.noreply.github.com>

Co-authored-by: Bart Arys <BartArys@users.noreply.github.com>

* Implement Stage instances (#291)

* Add low-level implementation of stage instances

* Add helper functions

* Add core entities and api representations

* Expose creation of StageInstanceBehavior to unsafe
- Revert outdated change

* Final additions
- Add StageInstanceBehavior.asStageInstance
- Fix compiler issue
- Add StageChannelBehavior.getStageInstance()

* Add StageInstances to EntitySupplier.kt

* Add StageInstances to EntitySupplier.kt

* Fix typo

* Apply requested changes

* Fix return type of channel in VoiceState (#295)

* Fix return type of channel in VoiceState

* Fix GuildService#modifyVoiceState endpoint

* Fix MessageInteraction#user id

* Add missing session start limit field (#306)

- Adds the max_concurrency field to the session start limit data class

* Update to Kotlin 1.5 (#299)

* Update to 1.5.0-RC

* trigger on branch pushes

* Port to Kotlin 1.5 (#268)

* Port dependencies to Kotlin 1.5
- Convert AbstractRateLimiter.AbstractRequestToken to a static rather than an inner class due to a compiler bug
- Downgrade kx.ser-json to 1.0.0 to avoid a compiler bug
- Bump other Kotlin dependencies to latest

fixup! Port dependencies to Kotlin 1.5 - Convert AbstractRateLimiter.AbstractRequestToken to a static rather than an inner class due to a compiler bug - Downgrade kx.ser-json to 1.0.0 to avoid a compiler bug - Bump other Kotlin dependencies to latest

* Replace deprecated kotlin.time APIs

* Replace more deprecated APIs & inline classes

* Replace deprecated usage of time API in tests

* Possibly fix test

Co-authored-by: Hope <34831095+HopeBaron@users.noreply.github.com>

* Port to Kotlin 1.5
- Bump dependencies to 1.5 recommended versions
- Remove inline classes in favor of value classes
- Add required opt-ins
- Migrate some more deprecated apis

* Fix some gradle issues

* Fix Gradle compilation issue

* Remove documentationFileName as the new dokka version doesn't support it anymore and there is no replacement yet

* Port kotlinx.serialization to 1.2.0 (#279)

* Port kotlinx.serialization to 1.2.0
- Convert local classes to top level classes (See Kotlin/kotlinx.serialization#1472)
- Improve handling of empty JSON bodies (See Kotlin/kotlinx.serialization#678)
- Fix Failing Command test

* Fix failing test

* Properly decode null in gateway events (#286)

* Properly decode null in gateway events

* Update gateway/src/main/kotlin/Event.kt

Co-authored-by: Bart Arys <BartArys@users.noreply.github.com>

Co-authored-by: Bart Arys <BartArys@users.noreply.github.com>

* Update Kotlinx.serialization (#290)

* Update Kotlin 1.5 branch to upstream (#292)

* Implement voice stage channel (#239)

* compute All

* implement rest endpoints

* JSON representation

* implement core representation

* handle stage channels

* Apply suggestions

Co-authored-by: BartArys <mysterybtdn@gmail.com>

* Remove duplicated factory function
Co-authored-by: BartArys <mysterybtdn@gmail.com>

* add documentation

* Document the requestToSpeak variable

Co-authored-by: BartArys <mysterybtdn@gmail.com>

* Fix CI triggers

* Add "Competing" activity type (Fix #270) (#272)

* Make Updatestatus activities not-null (#274)

As per Discord's documentation: https://github.com/discord/discord-api-docs/pull/2789

* Fix memory issues related to Permission combining (#277)

* Do not octuple bitset size on copy

the pure plus and minus function create a new array to work with, this incorrectly created an array of a size equal to the amount of bits that were allocated, instead the amount of longs. Thus, octupling the internal size.

* Optimize Permission All

The All Permission folded each DiscordBitSet of each value into eachother, resulting in n + 1 bitsets being created. This commit changes that to use the internal `add` which instead, which only mutates the single bitset created.

* Add Stream permission

It was missing

* Add Permission All regression tests

* Update deprecated message (#280)

* Expose the creation of application commands behavior (#281)

* Fix GuildUpdate core handling (#284)

* Expose the creation of application commands behavior

* Fix type of emitted event

* Sealed message types (#282)

* Expose the creation of application commands behavior

* Make message types sealed

* make Unknown a class

* Add missing message types

* make MessageTypeSerializer internal

* Add buttons to Activity (#287)

* Add buttons to Activity

* Also pass buttons in constructor

* Add missing fields to Guild (#288)

* Add missing fields to Guild
- Add welcome_screen
- Add nsfw

* Fix failing tests

* Fix another failing tests

* Add Message.applicationId (#289)

Co-authored-by: Hope <34831095+HopeBaron@users.noreply.github.com>
Co-authored-by: BartArys <mysterybtdn@gmail.com>
Co-authored-by: HopeBaron <truehope9000@gmail.com>
Co-authored-by: Bart Arys <BartArys@users.noreply.github.com>
Co-authored-by: Noah Hendrickson <noah@noahhendrickson.com>

* Fix broken CI (#293)

* Migrate to kotlinx-datetime (#297)

* Migrate API code to kotlinx-datetime

* Update tests

* Remove dead code

* Replace iso serializing with kx.dt

* Bump dependencies to Kotlin 1.5.10 (#305)

* Bump dependencies to Kotlin 1.5.10
- Fix sample code

* Update remaining dependencies

* Update ktor to 1.6.0

Co-authored-by: HopeBaron <truehope9000@gmail.com>
Co-authored-by: Michael Rittmeister <michael@rittmeister.in>
Co-authored-by: Hope <34831095+HopeBaron@users.noreply.github.com>
Co-authored-by: Noah Hendrickson <noah@noahhendrickson.com>

* Filter out non-guilds when fetching rest guilds (#301)

This is a side-effect from the system we currently employ when it comes to creating channels. Unknown channels are instantiated as an anonymous channel without hierarchy. While we could assume it is a guild channel, it's not in actuality.

So the solution, as we did with cache, is to filter out channels that don't inherit the hierarchy.

* Improve builders again
- Merge in upstream

* Fix builder requirements
- Fix error when sending a emoji button

* Fix merge related syntax errors

* Restore default sample

* Fix formatting isssue in documentation

Co-authored-by: Bart Arys <BartArys@users.noreply.github.com>

* Max component list a val

Co-authored-by: Bart Arys <BartArys@users.noreply.github.com>

* Apply suggestions from code review

Co-authored-by: Bart Arys <BartArys@users.noreply.github.com>

* Apply requested changes

* No longer make DiscordInteraction a sealed class

* Fix DiscordInteraction serialization

* Add some documentation for components

* Remove unused imports from builder

Co-authored-by: Noah Hendrickson <noah@noahhendrickson.com>
Co-authored-by: Hope <34831095+HopeBaron@users.noreply.github.com>
Co-authored-by: Bart Arys <BartArys@users.noreply.github.com>
Co-authored-by: 2D <gino@dimensional.fun>
Co-authored-by: HopeBaron <truehope9000@gmail.com>
---
 build.gradle.kts                              |   5 +-
 buildSrc/build.gradle.kts                     |   2 +-
 buildSrc/src/main/kotlin/Compiler.kt          |   1 -
 buildSrc/src/main/kotlin/Dependencies.kt      |  16 +-
 common/build.gradle.kts                       |   5 +-
 .../src/main/kotlin/entity/DiscordActivity.kt |   3 +-
 .../main/kotlin/entity/DiscordComponent.kt    | 140 ++++++++++++++++++
 common/src/main/kotlin/entity/DiscordEmoji.kt |   4 +-
 common/src/main/kotlin/entity/DiscordGuild.kt |   5 +-
 .../src/main/kotlin/entity/DiscordMessage.kt  |  97 +++++++++---
 .../kotlin/entity/DiscordStageInstance.kt     |  23 +++
 common/src/main/kotlin/entity/Interactions.kt |  41 +++--
 common/src/main/kotlin/entity/Snowflake.kt    |  14 +-
 .../kotlin/ratelimit/BucketRateLimiter.kt     |  16 +-
 common/src/test/kotlin/FixedClock.kt          |   8 +
 .../entity/optional/OptionalBooleanTest.kt    |  23 +--
 .../kotlin/entity/optional/OptionalIntTest.kt |  24 +--
 .../entity/optional/OptionalLongTest.kt       |  30 ++--
 .../entity/optional/OptionalSnowflakeTest.kt  |  26 ++--
 .../kotlin/entity/optional/OptionalTest.kt    |  48 +++---
 common/src/test/kotlin/json/GuildTest.kt      |   1 +
 .../kotlin/ratelimit/BucketRateLimiterTest.kt |  15 +-
 .../src/test/resources/json/guild/guild.json  |   3 +-
 core/build.gradle.kts                         |   1 -
 core/src/main/kotlin/Unsafe.kt                |  20 +++
 core/src/main/kotlin/Util.kt                  |   8 +-
 .../GlobalApplicationCommandBehavior.kt       |  33 +++++
 .../kotlin/behavior/StageInstanceBehavior.kt  |  45 ++++++
 .../channel/GuildMessageChannelBehavior.kt    |   9 +-
 .../channel/MessageChannelBehavior.kt         |  13 +-
 .../behavior/channel/StageChannelBehavior.kt  |  16 +-
 .../components/ButtonBuilderExtensions.kt     |  17 +++
 .../main/kotlin/builder/kord/KordBuilder.kt   |   9 +-
 .../main/kotlin/cache/data/ActivityData.kt    |   4 +-
 core/src/main/kotlin/cache/data/GuildData.kt  |   4 +
 .../main/kotlin/cache/data/InteractionData.kt |  61 +++++---
 .../src/main/kotlin/cache/data/MessageData.kt |  18 ++-
 .../cache/data/MessageInteractionData.kt      |  24 +++
 .../kotlin/cache/data/StageInstanceData.kt    |  19 +++
 core/src/main/kotlin/entity/Activity.kt       |   5 +-
 core/src/main/kotlin/entity/Embed.kt          |   4 +-
 core/src/main/kotlin/entity/Guild.kt          |  21 ++-
 core/src/main/kotlin/entity/Integration.kt    |   9 +-
 core/src/main/kotlin/entity/Member.kt         |   7 +-
 core/src/main/kotlin/entity/Message.kt        |  31 +++-
 core/src/main/kotlin/entity/StageInstance.kt  |  19 +++
 core/src/main/kotlin/entity/Template.kt       |   8 +-
 core/src/main/kotlin/entity/VoiceState.kt     |   9 +-
 .../kotlin/entity/channel/MessageChannel.kt   |   4 +-
 .../kotlin/entity/interaction/Interaction.kt  | 118 ++++++++++-----
 .../entity/interaction/MessageInteraction.kt  |  67 +++++++++
 .../event/channel/ChannelPinsUpdateEvent.kt   |   4 +-
 .../kotlin/event/channel/TypingStartEvent.kt  |   2 +-
 .../kotlin/event/guild/InviteCreateEvent.kt   |   7 +-
 .../kotlin/event/guild/MemberUpdateEvent.kt   |   2 +-
 .../exception/EntityNotFoundException.kt      |   3 +
 core/src/main/kotlin/gateway/MasterGateway.kt |   4 +-
 .../gateway/handler/GuildEventHandler.kt      |   2 +-
 .../gateway/handler/MessageEventHandler.kt    |   8 +
 .../kotlin/supplier/CacheEntitySupplier.kt    |   2 +
 .../main/kotlin/supplier/EntitySupplier.kt    |   7 +-
 .../kotlin/supplier/FallbackEntitySupplier.kt |   2 +
 .../kotlin/supplier/RestEntitySupplier.kt     |  16 +-
 core/src/test/kotlin/KordTest.kt              |   2 +-
 .../kotlin/interaction/CommandTypesTest.kt    |  16 +-
 .../kotlin/performance/KordEventDropTest.kt   |  28 ++--
 .../kotlin/regression/CacheMissRegression.kt  |   4 +-
 gateway/build.gradle.kts                      |   1 -
 gateway/src/main/kotlin/DefaultGateway.kt     |   1 -
 .../src/main/kotlin/DefaultGatewayBuilder.kt  |   7 +-
 gateway/src/main/kotlin/Event.kt              |   8 +-
 .../main/kotlin/builder/PresenceBuilder.kt    |   6 +-
 .../main/kotlin/handler/HeartbeatHandler.kt   |   6 +-
 gateway/src/main/kotlin/retry/LinearRetry.kt  |  11 +-
 gateway/src/samples/kotlin/EventListener.kt   |  20 ++-
 .../test/kotlin/gateway/DefaultGatewayTest.kt |  11 +-
 gateway/src/test/kotlin/json/CommandTest.kt   |  27 +++-
 gradle/wrapper/gradle-wrapper.properties      |   2 +-
 rest/build.gradle.kts                         |   1 -
 .../builder/components/ActionRowBuilder.kt    |  55 +++++++
 .../components/ActionRowContainerBuilder.kt   |  23 +++
 .../builder/components/ButtonBuilder.kt       |  46 ++++++
 .../builder/components/ComponentBuilders.kt   |  15 ++
 .../builder/guild/VoiceStateModifyBuilder.kt  |   2 +-
 .../interaction/FollowupMessageBuilders.kt    |  40 ++++-
 .../interaction/PublicInteractionBuilder.kt   |  31 +++-
 .../kotlin/builder/message/EmbedBuilder.kt    |   5 +-
 .../builder/message/MessageCreateBuilder.kt   |  25 +++-
 .../builder/message/MessageModifyBuilder.kt   |  25 +++-
 .../main/kotlin/json/OptionalSerializer.kt    |  35 -----
 .../kotlin/json/request/ChannelRequests.kt    |   1 +
 .../json/request/InteractionsRequests.kt      |   7 +-
 .../kotlin/json/request/MessageRequests.kt    |  10 +-
 .../json/request/StageInstanceRequests.kt     |  15 ++
 rest/src/main/kotlin/json/response/Gateway.kt |   6 +-
 .../kotlin/ratelimit/AbstractRateLimiter.kt   |  59 ++++----
 .../ratelimit/ExclusionRequestRateLimiter.kt  |  17 ++-
 .../ratelimit/ParallelRequestRateLimiter.kt   |  10 +-
 .../kotlin/ratelimit/RequestRateLimiter.kt    |  15 +-
 rest/src/main/kotlin/request/HttpUtils.kt     |  18 +--
 .../main/kotlin/request/KtorRequestHandler.kt |  12 +-
 rest/src/main/kotlin/route/Route.kt           |  70 +++++++--
 rest/src/main/kotlin/service/GuildService.kt  |   2 +-
 rest/src/main/kotlin/service/RestClient.kt    |   1 +
 .../kotlin/service/StageInstanceService.kt    |  39 +++++
 .../AbstractRequestRateLimiterTest.kt         |  36 +++--
 .../ExclusionRequestRateLimiterTest.kt        |   2 +-
 .../ParallelRequestRateLimiterTest.kt         |   2 +-
 rest/src/test/kotlin/ratelimit/TestClock.kt   |  12 +-
 settings.gradle.kts                           |   1 +
 110 files changed, 1482 insertions(+), 518 deletions(-)
 create mode 100644 common/src/main/kotlin/entity/DiscordComponent.kt
 create mode 100644 common/src/main/kotlin/entity/DiscordStageInstance.kt
 create mode 100644 common/src/test/kotlin/FixedClock.kt
 create mode 100644 core/src/main/kotlin/behavior/StageInstanceBehavior.kt
 create mode 100644 core/src/main/kotlin/builder/components/ButtonBuilderExtensions.kt
 create mode 100644 core/src/main/kotlin/cache/data/MessageInteractionData.kt
 create mode 100644 core/src/main/kotlin/cache/data/StageInstanceData.kt
 create mode 100644 core/src/main/kotlin/entity/StageInstance.kt
 create mode 100644 core/src/main/kotlin/entity/interaction/MessageInteraction.kt
 create mode 100644 rest/src/main/kotlin/builder/components/ActionRowBuilder.kt
 create mode 100644 rest/src/main/kotlin/builder/components/ActionRowContainerBuilder.kt
 create mode 100644 rest/src/main/kotlin/builder/components/ButtonBuilder.kt
 create mode 100644 rest/src/main/kotlin/builder/components/ComponentBuilders.kt
 delete mode 100644 rest/src/main/kotlin/json/OptionalSerializer.kt
 create mode 100644 rest/src/main/kotlin/json/request/StageInstanceRequests.kt
 create mode 100644 rest/src/main/kotlin/service/StageInstanceService.kt

diff --git a/build.gradle.kts b/build.gradle.kts
index 95179e1b92d..5acbc04134c 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -5,6 +5,7 @@ import org.apache.commons.codec.binary.Base64
 buildscript {
     repositories {
         jcenter()
+        mavenCentral()
         maven(url = "https://plugins.gradle.org/m2/")
     }
     dependencies {
@@ -20,7 +21,7 @@ buildscript {
 
 plugins {
     id("org.jetbrains.kotlin.jvm") version Versions.kotlin
-    id("org.jetbrains.dokka") version "1.4.0"
+    id("org.jetbrains.dokka") version "1.4.30"
     id("org.ajoberstar.git-publish") version "2.1.3"
 
     signing
@@ -32,7 +33,6 @@ apply(plugin = "binary-compatibility-validator")
 
 repositories {
     mavenCentral()
-    jcenter()
     mavenLocal()
 }
 
@@ -218,7 +218,6 @@ tasks {
     dokkaHtmlMultiModule.configure {
         dependsOn(clean)
         outputDirectory.set(file(dokkaOutputDir))
-        documentationFileName.set("DokkaDescription.md")
     }
 
 
diff --git a/buildSrc/build.gradle.kts b/buildSrc/build.gradle.kts
index 03e1bb944d0..4c81a14cc72 100644
--- a/buildSrc/build.gradle.kts
+++ b/buildSrc/build.gradle.kts
@@ -11,7 +11,7 @@ repositories {
 }
 
 dependencies {
-    implementation(kotlin("gradle-plugin-api", version = "1.4.0"))
+    implementation(kotlin("gradle-plugin-api", version = "1.4.21"))
     implementation(gradleApi())
     implementation(localGroovy())
 }
\ No newline at end of file
diff --git a/buildSrc/src/main/kotlin/Compiler.kt b/buildSrc/src/main/kotlin/Compiler.kt
index 102a1449365..237192819a2 100644
--- a/buildSrc/src/main/kotlin/Compiler.kt
+++ b/buildSrc/src/main/kotlin/Compiler.kt
@@ -1,5 +1,4 @@
 object CompilerArguments {
-    const val inlineClasses = "-XXLanguage:+InlineClasses"
     const val coroutines = "-Xopt-in=kotlinx.coroutines.ExperimentalCoroutinesApi"
     const val time = "-Xopt-in=kotlin.time.ExperimentalTime"
     const val stdLib = "-Xopt-in=kotlin.ExperimentalStdlibApi"
diff --git a/buildSrc/src/main/kotlin/Dependencies.kt b/buildSrc/src/main/kotlin/Dependencies.kt
index fb9475f42d2..f3cf34fcf38 100644
--- a/buildSrc/src/main/kotlin/Dependencies.kt
+++ b/buildSrc/src/main/kotlin/Dependencies.kt
@@ -1,11 +1,12 @@
 object Versions {
-    const val kotlin = "1.4.32"
-    const val kotlinxSerialization = "1.1.0"
-    const val ktor = "1.5.2"
-    const val kotlinxCoroutines = "1.4.2"
-    const val kotlinLogging = "2.0.4"
-    const val atomicFu = "0.15.1"
-    const val binaryCompatibilityValidator = "0.4.0"
+    const val kotlin = "1.5.10"
+    const val kotlinxSerialization = "1.2.1"
+    const val ktor = "1.6.0"
+    const val kotlinxCoroutines = "1.5.0"
+    const val kotlinLogging = "2.0.6"
+    const val dateTime = "0.2.1"
+    const val atomicFu = "0.16.1"
+    const val binaryCompatibilityValidator = "0.5.0"
 
     //test deps
     const val kotlinTest = kotlin
@@ -28,6 +29,7 @@ object Dependencies {
         "org.jetbrains.kotlinx:kotlinx-serialization-json:${Versions.kotlinxSerialization}"
     const val `kotlinx-coroutines` = "org.jetbrains.kotlinx:kotlinx-coroutines-core:${Versions.kotlinxCoroutines}"
     const val `kotlinx-atomicfu` = "org.jetbrains.kotlinx:atomicfu-jvm:${Versions.atomicFu}"
+    const val `kotlinx-datetime` = "org.jetbrains.kotlinx:kotlinx-datetime:${Versions.dateTime}"
 
     const val `kotlin-logging` = "io.github.microutils:kotlin-logging:${Versions.kotlinLogging}"
 
diff --git a/common/build.gradle.kts b/common/build.gradle.kts
index 93413505262..88f16fa192b 100644
--- a/common/build.gradle.kts
+++ b/common/build.gradle.kts
@@ -13,11 +13,14 @@ configurations {
     }
 }
 
+dependencies {
+    api(Dependencies.`kotlinx-datetime`)
+}
+
 tasks.withType<KotlinCompile> {
     kotlinOptions {
         jvmTarget = Jvm.target
         freeCompilerArgs = listOf(
-                CompilerArguments.inlineClasses,
                 CompilerArguments.coroutines,
                 CompilerArguments.time,
                 CompilerArguments.optIn
diff --git a/common/src/main/kotlin/entity/DiscordActivity.kt b/common/src/main/kotlin/entity/DiscordActivity.kt
index 385e333180c..20de507c4fd 100644
--- a/common/src/main/kotlin/entity/DiscordActivity.kt
+++ b/common/src/main/kotlin/entity/DiscordActivity.kt
@@ -35,7 +35,8 @@ data class DiscordActivity(
     val assets: Optional<DiscordActivityAssets> = Optional.Missing(),
     val secrets: Optional<DiscordActivitySecrets> = Optional.Missing(),
     val instance: OptionalBoolean = OptionalBoolean.Missing,
-    val flags: Optional<ActivityFlags> = Optional.Missing()
+    val flags: Optional<ActivityFlags> = Optional.Missing(),
+    val buttons: Optional<List<String>> = Optional.Missing()
 )
 
 enum class ActivityFlag(val value: Int) {
diff --git a/common/src/main/kotlin/entity/DiscordComponent.kt b/common/src/main/kotlin/entity/DiscordComponent.kt
new file mode 100644
index 00000000000..85f452d274c
--- /dev/null
+++ b/common/src/main/kotlin/entity/DiscordComponent.kt
@@ -0,0 +1,140 @@
+package dev.kord.common.entity
+
+import dev.kord.common.annotation.KordPreview
+import dev.kord.common.entity.optional.Optional
+import dev.kord.common.entity.optional.OptionalBoolean
+import kotlinx.serialization.KSerializer
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.descriptors.PrimitiveKind
+import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
+import kotlinx.serialization.descriptors.SerialDescriptor
+import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.encoding.Encoder
+
+/**
+ * Represent a [intractable component within a message sent in Discord](https://discord.com/developers/docs/interactions/message-components#what-are-components).
+ *
+ * @property type the [ComponentType] of the component
+ * @property style the [ButtonStyle] of the component (if it is a button)
+ * @property style the text that appears on the button (if the component is a button)
+ * @property emoji an [DiscordPartialEmoji] that appears on the button (if the component is a button)
+ * @property customId a developer-defined identifier for the button, max 100 characters
+ * @property url a url for link-style buttons
+ * @property disabled whether the button is disabled, default `false`
+ * @property components a list of child components (for action rows)
+ */
+@KordPreview
+@Serializable
+data class DiscordComponent(
+    val type: ComponentType,
+    val style: Optional<ButtonStyle> = Optional.Missing(),
+    val label: Optional<String> = Optional.Missing(),
+    val emoji: Optional<DiscordPartialEmoji> = Optional.Missing(),
+    @SerialName("custom_id")
+    val customId: Optional<String> = Optional.Missing(),
+    val url: Optional<String> = Optional.Missing(),
+    val disabled: OptionalBoolean = OptionalBoolean.Missing,
+    val components: Optional<List<DiscordComponent>> = Optional.Missing()
+)
+
+/**
+ * Representation of different [DiscordComponent] types.
+ *
+ * @property value the raw type value used by the Discord API
+ */
+@KordPreview
+@Serializable(with = ComponentType.Serializer::class)
+sealed class ComponentType(val value: Int) {
+
+    /**
+     * Fallback type used for types that haven't been added to Kord yet.
+     */
+    class Unknown(value: Int) : ComponentType(value)
+
+    /**
+     * A container for other components.
+     */
+    object ActionRow : ComponentType(1)
+
+    /**
+     * A clickable button.
+     */
+    object Button : ComponentType(2)
+
+    companion object Serializer : KSerializer<ComponentType> {
+        override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("ComponentType", PrimitiveKind.INT)
+
+        override fun deserialize(decoder: Decoder): ComponentType =
+            when (val value = decoder.decodeInt()) {
+                1 -> ActionRow
+                2 -> Button
+                else -> Unknown(value)
+            }
+
+        override fun serialize(encoder: Encoder, value: ComponentType) = encoder.encodeInt(value.value)
+    }
+}
+
+/**
+ * Representation of different ButtonStyles.
+ *
+ * A cheat sheet on how the styles look like can be found [here](https://discord.com/assets/7bb017ce52cfd6575e21c058feb3883b.png)
+ *
+ * @see ComponentType.Button
+ */
+@KordPreview
+@Serializable(with = ButtonStyle.Serializer::class)
+sealed class ButtonStyle(val value: Int) {
+
+    /**
+     * A fallback style used for styles that haven't been added to Kord yet.
+     */
+    class Unknown(value: Int) : ButtonStyle(value)
+
+    /**
+     * Blurple.
+     * Requires: [DiscordComponent.customId]
+     */
+    object Primary : ButtonStyle(1)
+
+    /**
+     * Grey.
+     * Requires: [DiscordComponent.customId]
+     */
+    object Secondary : ButtonStyle(2)
+
+    /**
+     * Green
+     * Requires: [DiscordComponent.customId]
+     */
+    object Success : ButtonStyle(3)
+
+    /**
+     * Red.
+     * Requires: [DiscordComponent.customId]
+     */
+    object Danger : ButtonStyle(4)
+
+    /**
+     * Grey, navigates to an URL.
+     * Requires: [DiscordComponent.url]
+     */
+    object Link : ButtonStyle(5)
+
+    companion object Serializer : KSerializer<ButtonStyle> {
+        override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("ButtonStyle", PrimitiveKind.INT)
+
+        override fun deserialize(decoder: Decoder): ButtonStyle =
+            when (val value = decoder.decodeInt()) {
+                1 -> Primary
+                2 -> Secondary
+                3 -> Success
+                4 -> Danger
+                5 -> Link
+                else -> Unknown(value)
+            }
+
+        override fun serialize(encoder: Encoder, value: ButtonStyle) = encoder.encodeInt(value.value)
+    }
+}
diff --git a/common/src/main/kotlin/entity/DiscordEmoji.kt b/common/src/main/kotlin/entity/DiscordEmoji.kt
index d096c5b966f..d008388215a 100644
--- a/common/src/main/kotlin/entity/DiscordEmoji.kt
+++ b/common/src/main/kotlin/entity/DiscordEmoji.kt
@@ -47,7 +47,7 @@ data class DiscordUpdatedEmojis(
  */
 @Serializable
 data class DiscordPartialEmoji(
-    val id: Snowflake?,
-    val name: String?,
+    val id: Snowflake? = null,
+    val name: String? = null,
     val animated: OptionalBoolean = OptionalBoolean.Missing,
 )
\ No newline at end of file
diff --git a/common/src/main/kotlin/entity/DiscordGuild.kt b/common/src/main/kotlin/entity/DiscordGuild.kt
index 914c584b742..d063bdd162d 100644
--- a/common/src/main/kotlin/entity/DiscordGuild.kt
+++ b/common/src/main/kotlin/entity/DiscordGuild.kt
@@ -74,6 +74,7 @@ data class DiscordUnavailableGuild(
  * @param approximateMemberCount The approximate number of members in this guild, returned from the `GET /guild/<id>` endpoint when `with_counts` is `true`.
  * @param approximatePresenceCount The approximate number of non-offline members in this guild, returned from the `GET /guild/<id>` endpoint when `with_counts` is `true`.
  * @param welcomeScreen The welcome screen of a Community guild, shown to new members.
+ * @param nsfw true if this guild is [designated as NSFW](https://support.discord.com/hc/en-us/articles/1500005389362-NSFW-Server-Designation)
  */
 @Serializable
 data class DiscordGuild(
@@ -150,7 +151,9 @@ data class DiscordGuild(
     val approximateMemberCount: OptionalInt = OptionalInt.Missing,
     @SerialName("approximate_presence_count")
     val approximatePresenceCount: OptionalInt = OptionalInt.Missing,
-
+    @SerialName("welcome_screen")
+    val welcomeScreen: Optional<DiscordWelcomeScreen> = Optional.Missing(),
+    val nsfw: Boolean
     )
 
 /**
diff --git a/common/src/main/kotlin/entity/DiscordMessage.kt b/common/src/main/kotlin/entity/DiscordMessage.kt
index a802889e7c8..1c8ccaf4876 100644
--- a/common/src/main/kotlin/entity/DiscordMessage.kt
+++ b/common/src/main/kotlin/entity/DiscordMessage.kt
@@ -1,5 +1,6 @@
 package dev.kord.common.entity
 
+import dev.kord.common.annotation.KordPreview
 import dev.kord.common.entity.optional.Optional
 import dev.kord.common.entity.optional.OptionalBoolean
 import dev.kord.common.entity.optional.OptionalInt
@@ -61,6 +62,8 @@ import kotlin.contracts.contract
  * @param flags Message flags.
  * @param stickers The stickers sent with the message (bots currently can only receive messages with stickers, not send).
  * @param referencedMessage the message associated with [messageReference].
+ * @param applicationId if the message is a response to an [Interaction][DiscordInteraction], this is the id of the interaction's application
+ * @param components a list of [components][DiscordComponent] which have been added to this message
  */
 @Serializable
 data class DiscordMessage(
@@ -93,12 +96,21 @@ data class DiscordMessage(
     val type: MessageType,
     val activity: Optional<MessageActivity> = Optional.Missing(),
     val application: Optional<MessageApplication> = Optional.Missing(),
+    @SerialName("application_id")
+    val applicationId: OptionalSnowflake = OptionalSnowflake.Missing,
     @SerialName("message_reference")
     val messageReference: Optional<DiscordMessageReference> = Optional.Missing(),
     val flags: Optional<MessageFlags> = Optional.Missing(),
     val stickers: Optional<List<DiscordMessageSticker>> = Optional.Missing(),
     @SerialName("referenced_message")
     val referencedMessage: Optional<DiscordMessage?> = Optional.Missing(),
+    val interaction: Optional<DiscordMessageInteraction> = Optional.Missing(),
+
+    /*
+     * don't trust the docs:
+     * This is a list even though the docs say it's a component
+     */
+    val components: Optional<List<DiscordComponent>> = Optional.Missing()
 )
 
 /**
@@ -239,6 +251,7 @@ data class DiscordPartialMessage(
     val stickers: Optional<List<DiscordMessageSticker>> = Optional.Missing(),
     @SerialName("referenced_message")
     val referencedMessage: Optional<DiscordMessage?> = Optional.Missing(),
+    val interaction: Optional<DiscordMessageInteraction> = Optional.Missing(),
 )
 
 @Serializable
@@ -719,42 +732,77 @@ data class AllRemovedMessageReactions(
 )
 
 @Serializable(with = MessageType.MessageTypeSerializer::class)
-enum class MessageType(val code: Int) {
+sealed class MessageType(val code: Int) {
     /** The default code for unknown values. */
-    Unknown(Int.MIN_VALUE),
-    Default(0),
-    RecipientAdd(1),
-    RecipientRemove(2),
-    Call(3),
-    ChannelNameChange(4),
-    ChannelIconChange(5),
-    ChannelPinnedMessage(6),
-    GuildMemberJoin(7),
-    UserPremiumGuildSubscription(8),
-    UserPremiumGuildSubscriptionTierOne(9),
-    UserPremiumGuildSubscriptionTwo(10),
-    UserPremiumGuildSubscriptionThree(11),
-    ChannelFollowAdd(12),
-    GuildDiscoveryDisqualified(14),
+    class Unknown(code: Int) : MessageType(code)
+    object Default : MessageType(0)
+    object RecipientAdd : MessageType(1)
+    object RecipientRemove : MessageType(2)
+    object Call : MessageType(3)
+    object ChannelNameChange : MessageType(4)
+    object ChannelIconChange : MessageType(5)
+    object ChannelPinnedMessage : MessageType(6)
+    object GuildMemberJoin : MessageType(7)
+    object UserPremiumGuildSubscription : MessageType(8)
+    object UserPremiumGuildSubscriptionTierOne : MessageType(9)
+    object UserPremiumGuildSubscriptionTwo : MessageType(10)
+    object UserPremiumGuildSubscriptionThree : MessageType(11)
+    object ChannelFollowAdd : MessageType(12)
+    object GuildDiscoveryDisqualified : MessageType(14)
 
     @Suppress("SpellCheckingInspection")
-    GuildDiscoveryRequalified(15),
-    Reply(19);
+    object GuildDiscoveryRequalified : MessageType(15)
+    object GuildDiscoveryGracePeriodInitialWarning : MessageType(16)
+    object GuildDiscoveryGracePeriodFinalWarning : MessageType(17)
+    object ThreadCreated : MessageType(18)
+    object Reply : MessageType(19)
+    object ApplicationCommand : MessageType(20)
+    object ThreadStarterMessage : MessageType(21)
+    object GuildInviteReminder : MessageType(22)
 
-    companion object MessageTypeSerializer : KSerializer<MessageType> {
+    internal object MessageTypeSerializer : KSerializer<MessageType> {
 
         override val descriptor: SerialDescriptor
             get() = PrimitiveSerialDescriptor("type", PrimitiveKind.INT)
 
         override fun deserialize(decoder: Decoder): MessageType {
             val code = decoder.decodeInt()
-            return values().firstOrNull { it.code == code } ?: Unknown
+            return values.firstOrNull { it.code == code } ?: Unknown(code)
         }
 
         override fun serialize(encoder: Encoder, value: MessageType) {
             encoder.encodeInt(value.code)
         }
     }
+
+    companion object {
+        val values: Set<MessageType>
+            get() = setOf(
+                Default,
+                RecipientAdd,
+                RecipientRemove,
+                Call,
+                ChannelNameChange,
+                ChannelIconChange,
+                ChannelPinnedMessage,
+                GuildMemberJoin,
+                UserPremiumGuildSubscription,
+                UserPremiumGuildSubscriptionTierOne,
+                UserPremiumGuildSubscriptionTwo,
+                UserPremiumGuildSubscriptionThree,
+                ChannelFollowAdd,
+                GuildDiscoveryDisqualified,
+                GuildDiscoveryRequalified,
+                Reply,
+                GuildDiscoveryGracePeriodInitialWarning,
+                GuildDiscoveryGracePeriodFinalWarning,
+                ThreadCreated,
+                ApplicationCommand,
+                ThreadStarterMessage,
+                GuildInviteReminder,
+
+                )
+    }
 }
 
 @Serializable(with = AllowedMentionType.Serializer::class)
@@ -789,3 +837,12 @@ data class AllowedMentions(
     @SerialName("replied_user")
     val repliedUser: OptionalBoolean = OptionalBoolean.Missing
 )
+
+@KordPreview
+@Serializable
+data class DiscordMessageInteraction(
+    val id: Snowflake,
+    val type: InteractionType,
+    val name: String,
+    val user: DiscordUser
+)
diff --git a/common/src/main/kotlin/entity/DiscordStageInstance.kt b/common/src/main/kotlin/entity/DiscordStageInstance.kt
new file mode 100644
index 00000000000..826eb9a4f79
--- /dev/null
+++ b/common/src/main/kotlin/entity/DiscordStageInstance.kt
@@ -0,0 +1,23 @@
+package dev.kord.common.entity
+
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+
+/**
+ * A _Stage Instance_ holds information about a live stage.
+ *
+ * @property id The id of this Stage instance
+ * @property guildId The guild id of the associated Stage channel
+ * @property channelId The id of the associated Stage channel
+ * @property topic The topic of the Stage instance (1-120 characters)
+ */
+@Serializable
+data class DiscordStageInstance(
+    val id: Snowflake,
+    @SerialName("guild_id")
+    val guildId: Snowflake,
+    @SerialName("channel_id")
+    val channelId: Snowflake,
+    val topic: String
+)
diff --git a/common/src/main/kotlin/entity/Interactions.kt b/common/src/main/kotlin/entity/Interactions.kt
index 4cd693c2cc9..a26e4984497 100644
--- a/common/src/main/kotlin/entity/Interactions.kt
+++ b/common/src/main/kotlin/entity/Interactions.kt
@@ -156,20 +156,21 @@ data class ResolvedObjects(
 
 @Serializable
 @KordPreview
-data class DiscordInteraction(
+class DiscordInteraction(
     val id: Snowflake,
     @SerialName("application_id")
     val applicationId: Snowflake,
-    val type: InteractionType,
-    val data: DiscordApplicationCommandInteractionData,
+    val data: InteractionCallbackData,
     @SerialName("guild_id")
-    val guildId: OptionalSnowflake = OptionalSnowflake.Missing,
+    val guildId: OptionalSnowflake,
     @SerialName("channel_id")
     val channelId: Snowflake,
     val member: Optional<DiscordInteractionGuildMember> = Optional.Missing(),
     val user: Optional<DiscordUser> = Optional.Missing(),
     val token: String,
     val version: Int,
+    val message: Optional<DiscordMessage> = Optional.Missing(),
+    val type: InteractionType
 )
 
 @Serializable(InteractionType.Serializer::class)
@@ -177,11 +178,19 @@ data class DiscordInteraction(
 sealed class InteractionType(val type: Int) {
     object Ping : InteractionType(1)
     object ApplicationCommand : InteractionType(2)
+
+    /*
+     * don't trust the docs:
+     *
+     * this type exists and is needed for components even though it's not documented
+     */
+    object Component : InteractionType(3)
     class Unknown(type: Int) : InteractionType(type)
 
     override fun toString(): String = when (this) {
         Ping -> "InteractionType.Ping($type)"
         ApplicationCommand -> "InteractionType.ApplicationCommand($type)"
+        Component -> "InteractionType.ComponentInvoke($type)"
         is Unknown -> "InteractionType.Unknown($type)"
     }
 
@@ -195,6 +204,7 @@ sealed class InteractionType(val type: Int) {
             return when (val type = decoder.decodeInt()) {
                 1 -> Ping
                 2 -> ApplicationCommand
+                3 -> Component
                 else -> Unknown(type)
             }
         }
@@ -207,12 +217,15 @@ sealed class InteractionType(val type: Int) {
 }
 
 @Serializable
-@KordPreview
-data class DiscordApplicationCommandInteractionData(
-    val id: Snowflake,
-    val name: String,
+data class InteractionCallbackData(
+    val id: OptionalSnowflake = OptionalSnowflake.Missing,
+    val name: Optional<String> = Optional.Missing(),
     val resolved: Optional<ResolvedObjects> = Optional.Missing(),
-    val options: Optional<List<Option>> = Optional.Missing()
+    val options: Optional<List<Option>> = Optional.Missing(),
+    @SerialName("custom_id")
+    val customId: Optional<String> = Optional.Missing(),
+    @SerialName("component_type")
+    val componentType: Optional<ComponentType> = Optional.Missing()
 )
 
 @Serializable(with = Option.Serializer::class)
@@ -287,7 +300,7 @@ sealed class Option {
         }
 
         override fun serialize(encoder: Encoder, value: Option) {
-            when(value){
+            when (value) {
                 is CommandArgument<*> -> CommandArgument.Serializer.serialize(encoder, value)
                 is CommandGroup -> encoder.encodeStructure(descriptor) {
                     encodeSerializableElement(
@@ -540,13 +553,14 @@ fun CommandArgument<*>.snowflake(): Snowflake {
     return Snowflake(id)
 }
 
-
 @Serializable(InteractionResponseType.Serializer::class)
 @KordPreview
 sealed class InteractionResponseType(val type: Int) {
     object Pong : InteractionResponseType(1)
     object ChannelMessageWithSource : InteractionResponseType(4)
     object DeferredChannelMessageWithSource : InteractionResponseType(5)
+    object DeferredUpdateMessage : InteractionResponseType(6)
+    object UpdateMessage : InteractionResponseType(7)
     class Unknown(type: Int) : InteractionResponseType(type)
 
     companion object;
@@ -561,6 +575,8 @@ sealed class InteractionResponseType(val type: Int) {
                 1 -> Pong
                 4 -> ChannelMessageWithSource
                 5 -> DeferredChannelMessageWithSource
+                6 -> DeferredUpdateMessage
+                7 -> UpdateMessage
                 else -> Unknown(type)
             }
         }
@@ -568,11 +584,9 @@ sealed class InteractionResponseType(val type: Int) {
         override fun serialize(encoder: Encoder, value: InteractionResponseType) {
             encoder.encodeInt(value.type)
         }
-
     }
 }
 
-
 @KordPreview
 @Serializable
 data class DiscordGuildApplicationCommandPermissions(
@@ -619,3 +633,4 @@ data class DiscordGuildApplicationCommandPermission(
         }
     }
 }
+
diff --git a/common/src/main/kotlin/entity/Snowflake.kt b/common/src/main/kotlin/entity/Snowflake.kt
index 37ac5fc6f62..187d6e20308 100644
--- a/common/src/main/kotlin/entity/Snowflake.kt
+++ b/common/src/main/kotlin/entity/Snowflake.kt
@@ -1,5 +1,6 @@
 package dev.kord.common.entity
 
+import kotlinx.datetime.Clock
 import kotlinx.serialization.KSerializer
 import kotlinx.serialization.Serializable
 import kotlinx.serialization.descriptors.PrimitiveKind
@@ -7,10 +8,9 @@ import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
 import kotlinx.serialization.descriptors.SerialDescriptor
 import kotlinx.serialization.encoding.Decoder
 import kotlinx.serialization.encoding.Encoder
-import java.time.Instant
+import kotlinx.datetime.Instant
 import kotlin.time.Duration
 import kotlin.time.TimeMark
-import kotlin.time.toKotlinDuration
 
 /**
  * A unique identifier for entities [used by discord](https://discord.com/developers/docs/reference#snowflakes).
@@ -28,11 +28,11 @@ class Snowflake(val value: Long) : Comparable<Snowflake> {
     /**
      * Creates a Snowflake from a given [instant].
      */
-    constructor(instant: Instant) : this((instant.toEpochMilli() shl 22) - discordEpochLong)
+    constructor(instant: Instant) : this((instant.toEpochMilliseconds() shl 22) - discordEpochLong)
 
     val asString get() = value.toString()
 
-    val timeStamp: Instant get() = Instant.ofEpochMilli(discordEpochLong + (value shr 22))
+    val timeStamp: Instant get() = Instant.fromEpochMilliseconds(discordEpochLong + (value shr 22))
 
     val timeMark: TimeMark get() = SnowflakeMark(value shr 22)
 
@@ -48,7 +48,7 @@ class Snowflake(val value: Long) : Comparable<Snowflake> {
 
     companion object {
         private const val discordEpochLong = 1420070400000L
-        val discordEpochStart: Instant = Instant.ofEpochMilli(discordEpochLong)
+        val discordEpochStart: Instant = Instant.fromEpochMilliseconds(discordEpochLong)
 
         /**
          * The maximum value a Snowflake can hold.
@@ -78,7 +78,5 @@ class Snowflake(val value: Long) : Comparable<Snowflake> {
 
 private class SnowflakeMark(val epochMilliseconds: Long) : TimeMark() {
 
-    override fun elapsedNow(): Duration =
-        java.time.Duration.between(Instant.ofEpochMilli(epochMilliseconds), Instant.now()).toKotlinDuration()
-
+    override fun elapsedNow(): Duration = Instant.fromEpochMilliseconds(epochMilliseconds) - Clock.System.now()
 }
\ No newline at end of file
diff --git a/common/src/main/kotlin/ratelimit/BucketRateLimiter.kt b/common/src/main/kotlin/ratelimit/BucketRateLimiter.kt
index 407b071a1b4..57bfcc21fde 100644
--- a/common/src/main/kotlin/ratelimit/BucketRateLimiter.kt
+++ b/common/src/main/kotlin/ratelimit/BucketRateLimiter.kt
@@ -2,11 +2,9 @@ package dev.kord.common.ratelimit
 
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
-import java.time.Clock
+import kotlinx.datetime.Clock
+import kotlinx.datetime.Instant
 import kotlin.time.Duration
-import kotlin.time.milliseconds
-import kotlin.time.toKotlinDuration
-import java.time.Duration as JavaDuration
 
 
 /**
@@ -19,30 +17,30 @@ import java.time.Duration as JavaDuration
 class BucketRateLimiter(
     private val capacity: Int,
     private val refillInterval: Duration,
-    private val clock: Clock = Clock.systemUTC()
+    private val clock: Clock = Clock.System
 ) : RateLimiter {
 
     private val mutex = Mutex()
 
     private var count = 0
-    private var nextInterval = 0L
+    private var nextInterval = Instant.fromEpochMilliseconds(0)
 
     init {
         require(capacity > 0) { "capacity must be a positive number" }
         require(refillInterval.isPositive()) { "refill interval must be positive" }
     }
 
-    private val isNextInterval get() = nextInterval <= clock.millis()
+    private val isNextInterval get() = nextInterval <= clock.now()
 
     private val isAtCapacity get() = count == capacity
 
     private fun resetState() {
         count = 0
-        nextInterval = clock.millis() + refillInterval.inMilliseconds.toLong()
+        nextInterval = clock.now() + refillInterval
     }
 
     private suspend fun delayUntilNextInterval() {
-        val delay = nextInterval - clock.millis()
+        val delay = nextInterval - clock.now()
         kotlinx.coroutines.delay(delay)
     }
 
diff --git a/common/src/test/kotlin/FixedClock.kt b/common/src/test/kotlin/FixedClock.kt
new file mode 100644
index 00000000000..9268573652a
--- /dev/null
+++ b/common/src/test/kotlin/FixedClock.kt
@@ -0,0 +1,8 @@
+import kotlinx.datetime.Clock
+import kotlinx.datetime.Instant
+
+fun Clock.Companion.fixed(instant: Instant): Clock = FixedClock(instant)
+
+private class FixedClock(private val instant: Instant): Clock {
+    override fun now(): Instant = instant
+}
diff --git a/common/src/test/kotlin/entity/optional/OptionalBooleanTest.kt b/common/src/test/kotlin/entity/optional/OptionalBooleanTest.kt
index 0d004196e76..14b32bf1d2b 100644
--- a/common/src/test/kotlin/entity/optional/OptionalBooleanTest.kt
+++ b/common/src/test/kotlin/entity/optional/OptionalBooleanTest.kt
@@ -10,41 +10,42 @@ import org.junit.jupiter.api.Test
 
 internal class OptionalBooleanTest {
 
+    @Serializable
+    private class EmptyOptionalEntity(val value: OptionalBoolean = OptionalBoolean.Missing)
+
     @Test
     fun `deserializing nothing in optional assigns Missing`(){
         @Language("json")
         val json = """{}"""
 
-        @Serializable
-        class Entity(val value: OptionalBoolean = OptionalBoolean.Missing)
-
-        val entity = Json.decodeFromString<Entity>(json)
+        val entity = Json.decodeFromString<EmptyOptionalEntity>(json)
 
         assert(entity.value is OptionalBoolean.Missing)
     }
 
+    @Serializable
+    private class NullOptionalEntity(@Suppress("unused") val value: OptionalBoolean = OptionalBoolean.Missing)
+
     @Test
     fun `deserializing null in optional throws SerializationException`(){
         @Language("json")
         val json = """{ "value":null }"""
 
-        @Serializable
-        class Entity(@Suppress("unused") val value: OptionalBoolean = OptionalBoolean.Missing)
-
         org.junit.jupiter.api.assertThrows<SerializationException> {
-            Json.decodeFromString<Entity>(json)
+            Json.decodeFromString<NullOptionalEntity>(json)
         }
     }
 
+    @Serializable
+    private class ValueOptionalEntity(@Suppress("unused") val value: OptionalBoolean = OptionalBoolean.Missing)
+
     @Test
     fun `deserializing value in optional assigns Value`(){
         @Language("json")
         val json = """{ "value":true }"""
 
-        @Serializable
-        class Entity(@Suppress("unused") val value: OptionalBoolean = OptionalBoolean.Missing)
 
-        val entity = Json.decodeFromString<Entity>(json)
+        val entity = Json.decodeFromString<ValueOptionalEntity>(json)
         require(entity.value is OptionalBoolean.Value)
 
         Assertions.assertEquals(true, entity.value.value)
diff --git a/common/src/test/kotlin/entity/optional/OptionalIntTest.kt b/common/src/test/kotlin/entity/optional/OptionalIntTest.kt
index c9d3990ab04..a6f497e26be 100644
--- a/common/src/test/kotlin/entity/optional/OptionalIntTest.kt
+++ b/common/src/test/kotlin/entity/optional/OptionalIntTest.kt
@@ -10,41 +10,43 @@ import org.junit.jupiter.api.Test
 
 internal class OptionalIntTest {
 
+    @Serializable
+    private class EmptyOptionalEntity(val value: OptionalInt = OptionalInt.Missing)
+
     @Test
     fun `deserializing nothing in optional assigns Missing`(){
         @Language("json")
         val json = """{}"""
 
-        @Serializable
-        class Entity(val value: OptionalInt = OptionalInt.Missing)
-
-        val entity = Json.decodeFromString<Entity>(json)
+        val entity = Json.decodeFromString<EmptyOptionalEntity>(json)
 
         assert(entity.value is OptionalInt.Missing)
     }
 
+
+    @Serializable
+    private class NullOptionalEntity(@Suppress("unused") val value: OptionalInt = OptionalInt.Missing)
+
     @Test
     fun `deserializing null in optional throws SerializationException`(){
         @Language("json")
         val json = """{ "value":null }"""
 
-        @Serializable
-        class Entity(@Suppress("unused") val value: OptionalInt = OptionalInt.Missing)
 
         org.junit.jupiter.api.assertThrows<SerializationException> {
-            Json.decodeFromString<Entity>(json)
+            Json.decodeFromString<NullOptionalEntity>(json)
         }
     }
 
+    @Serializable
+    class ValueOptionalEntity(@Suppress("unused") val value: OptionalInt = OptionalInt.Missing)
+
     @Test
     fun `deserializing value in optional assigns Value`(){
         @Language("json")
         val json = """{ "value":5 }"""
 
-        @Serializable
-        class Entity(@Suppress("unused") val value: OptionalInt = OptionalInt.Missing)
-
-        val entity = Json.decodeFromString<Entity>(json)
+        val entity = Json.decodeFromString<ValueOptionalEntity>(json)
         require(entity.value is OptionalInt.Value)
 
         assertEquals(5, entity.value.value)
diff --git a/common/src/test/kotlin/entity/optional/OptionalLongTest.kt b/common/src/test/kotlin/entity/optional/OptionalLongTest.kt
index f5222c6525b..9ec0618be62 100644
--- a/common/src/test/kotlin/entity/optional/OptionalLongTest.kt
+++ b/common/src/test/kotlin/entity/optional/OptionalLongTest.kt
@@ -10,41 +10,45 @@ import org.junit.jupiter.api.Test
 
 internal class OptionalLongTest {
 
+    @Serializable
+    class EmptyOptionalEntity(val value: OptionalLong = OptionalLong.Missing)
+
     @Test
-    fun `deserializing nothing in optional assigns Missing`(){
+    fun `deserializing nothing in optional assigns Missing`() {
         @Language("json")
         val json = """{}"""
 
-        @Serializable
-        class Entity(val value: OptionalLong = OptionalLong.Missing)
 
-        val entity = Json.decodeFromString<Entity>(json)
+        val entity = Json.decodeFromString<EmptyOptionalEntity>(json)
 
         assert(entity.value is OptionalLong.Missing)
     }
 
+
+    @Serializable
+    class NullOptionalEntity(@Suppress("unused") val value: OptionalLong = OptionalLong.Missing)
+
     @Test
-    fun `deserializing null in optional throws SerializationException`(){
+    fun `deserializing null in optional throws SerializationException`() {
         @Language("json")
         val json = """{ "value":null }"""
 
-        @Serializable
-        class Entity(@Suppress("unused") val value: OptionalLong = OptionalLong.Missing)
 
         org.junit.jupiter.api.assertThrows<SerializationException> {
-            Json.decodeFromString<Entity>(json)
+            Json.decodeFromString<NullOptionalEntity>(json)
         }
     }
 
+
+    @Serializable
+    class ValueOptionalEntity(@Suppress("unused") val value: OptionalLong = OptionalLong.Missing)
+
     @Test
-    fun `deserializing value in optional assigns Value`(){
+    fun `deserializing value in optional assigns Value`() {
         @Language("json")
         val json = """{ "value":5 }"""
 
-        @Serializable
-        class Entity(@Suppress("unused") val value: OptionalLong = OptionalLong.Missing)
-
-        val entity = Json.decodeFromString<Entity>(json)
+        val entity = Json.decodeFromString<ValueOptionalEntity>(json)
         require(entity.value is OptionalLong.Value)
 
         Assertions.assertEquals(5, entity.value.value)
diff --git a/common/src/test/kotlin/entity/optional/OptionalSnowflakeTest.kt b/common/src/test/kotlin/entity/optional/OptionalSnowflakeTest.kt
index d28cd31dfbb..948b8c3ce72 100644
--- a/common/src/test/kotlin/entity/optional/OptionalSnowflakeTest.kt
+++ b/common/src/test/kotlin/entity/optional/OptionalSnowflakeTest.kt
@@ -11,41 +11,45 @@ import org.junit.jupiter.api.Test
 
 internal class OptionalSnowflakeTest {
 
+
+    @Serializable
+    class EmptyOptionalEntity(val value: OptionalSnowflake = OptionalSnowflake.Missing)
+
     @Test
     fun `deserializing nothing in optional assigns Missing`(){
         @Language("json")
         val json = """{}"""
 
-        @Serializable
-        class Entity(val value: OptionalSnowflake = OptionalSnowflake.Missing)
 
-        val entity = Json.decodeFromString<Entity>(json)
+        val entity = Json.decodeFromString<EmptyOptionalEntity>(json)
 
         assert(entity.value is OptionalSnowflake.Missing)
     }
 
+
+    @Serializable
+    class NullOptionalEntity(@Suppress("unused") val value: OptionalSnowflake = OptionalSnowflake.Missing)
+
     @Test
     fun `deserializing null in optional throws SerializationException`(){
         @Language("json")
         val json = """{ "value":null }"""
 
-        @Serializable
-        class Entity(@Suppress("unused") val value: OptionalSnowflake = OptionalSnowflake.Missing)
-
         org.junit.jupiter.api.assertThrows<SerializationException> {
-            Json.decodeFromString<Entity>(json)
+            Json.decodeFromString<NullOptionalEntity>(json)
         }
     }
 
+
+    @Serializable
+    class ValueOptionalEntity(@Suppress("unused") val value: OptionalSnowflake = OptionalSnowflake.Missing)
+
     @Test
     fun `deserializing value in optional assigns Value`(){
         @Language("json")
         val json = """{ "value":5 }"""
 
-        @Serializable
-        class Entity(@Suppress("unused") val value: OptionalSnowflake = OptionalSnowflake.Missing)
-
-        val entity = Json.decodeFromString<Entity>(json)
+        val entity = Json.decodeFromString<ValueOptionalEntity>(json)
         require(entity.value is OptionalSnowflake.Value)
 
         Assertions.assertEquals(Snowflake(5), entity.value.value)
diff --git a/common/src/test/kotlin/entity/optional/OptionalTest.kt b/common/src/test/kotlin/entity/optional/OptionalTest.kt
index b66e0d6f255..144a0387288 100644
--- a/common/src/test/kotlin/entity/optional/OptionalTest.kt
+++ b/common/src/test/kotlin/entity/optional/OptionalTest.kt
@@ -10,7 +10,7 @@ import org.junit.jupiter.api.Test
 internal class OptionalTest {
 
     @Test
-    fun `creating optional from nullable value returns Value on non-null value`(){
+    fun `creating optional from nullable value returns Value on non-null value`() {
         val value: Int? = 5
         val optional = Optional(value)
 
@@ -19,62 +19,66 @@ internal class OptionalTest {
     }
 
     @Test
-    fun `creating optional from nullable value returns Null on null value`(){
+    fun `creating optional from nullable value returns Null on null value`() {
         val value: Int? = null
         val optional = Optional(value)
 
         assert(optional is Optional.Null)
     }
 
+
+    @Serializable
+    private class NullOptionalEntity(val value: Optional<String?>)
+
     @Test
-    fun `deserializing null in nullable optional assigns Null`(){
+    fun `deserializing null in nullable optional assigns Null`() {
         @Language("json")
         val json = """{ "value":null }"""
 
-        @Serializable
-        class Entity(val value: Optional<String?>)
-
-        val entity = Json.decodeFromString<Entity>(json)
+        val entity = Json.decodeFromString<NullOptionalEntity>(json)
 
         assert(entity.value is Optional.Null)
     }
 
+
+    @Serializable
+    class EmptyOptionalEntity(val value: Optional<String?> = Optional.Missing())
+
     @Test
-    fun `deserializing nothing in nullable optional assigns Missing`(){
+    fun `deserializing nothing in nullable optional assigns Missing`() {
         @Language("json")
         val json = """{}"""
 
-        @Serializable
-        class Entity(val value: Optional<String?> = Optional.Missing())
-
-        val entity = Json.decodeFromString<Entity>(json)
+        val entity = Json.decodeFromString<EmptyOptionalEntity>(json)
 
         assert(entity.value is Optional.Missing)
     }
 
+
+    @Serializable
+    class UnexpectedEmptyOptionalEntity(val value: Optional<String> = Optional.Missing())
+
     @Test
-    fun `deserializing nothing in non-nullable optional assigns Missing`(){
+    fun `deserializing nothing in non-nullable optional assigns Missing`() {
         @Language("json")
         val json = """{}"""
 
-        @Serializable
-        class Entity(val value: Optional<String> = Optional.Missing())
-
-        val entity = Json.decodeFromString<Entity>(json)
+        val entity = Json.decodeFromString<UnexpectedEmptyOptionalEntity>(json)
 
         assert(entity.value is Optional.Missing)
     }
 
+
+    @Serializable
+    private class UnexpectedNullOptionalEntity(@Suppress("unused") val value: Optional<String> = Optional.Missing())
+
     @Test
-    fun `deserializing null in non-nullable optional throws SerializationException`(){
+    fun `deserializing null in non-nullable optional throws SerializationException`() {
         @Language("json")
         val json = """{ "value":null }"""
 
-        @Serializable
-        class Entity(@Suppress("unused") val value: Optional<String> = Optional.Missing())
-
         org.junit.jupiter.api.assertThrows<SerializationException> {
-            Json.decodeFromString<Entity>(json)
+            Json.decodeFromString<UnexpectedNullOptionalEntity>(json)
         }
     }
 
diff --git a/common/src/test/kotlin/json/GuildTest.kt b/common/src/test/kotlin/json/GuildTest.kt
index 23b90127498..8880dcd394b 100644
--- a/common/src/test/kotlin/json/GuildTest.kt
+++ b/common/src/test/kotlin/json/GuildTest.kt
@@ -59,6 +59,7 @@ class GuildTest {
             preferredLocale shouldBe "en-US"
             rulesChannelId shouldBe "441688182833020939"
             publicUpdatesChannelId shouldBe "281283303326089216"
+            nsfw shouldBe true
         }
 
     }
diff --git a/common/src/test/kotlin/ratelimit/BucketRateLimiterTest.kt b/common/src/test/kotlin/ratelimit/BucketRateLimiterTest.kt
index da970531a54..5122f538327 100644
--- a/common/src/test/kotlin/ratelimit/BucketRateLimiterTest.kt
+++ b/common/src/test/kotlin/ratelimit/BucketRateLimiterTest.kt
@@ -1,24 +1,25 @@
 package ratelimit
 
 import dev.kord.common.ratelimit.BucketRateLimiter
+import fixed
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.test.runBlockingTest
-import java.time.Clock
-import java.time.Instant
+import kotlinx.datetime.Clock
+import kotlinx.datetime.Instant
 import java.time.ZoneOffset
 import kotlin.test.BeforeTest
 import kotlin.test.Test
 import kotlin.test.asserter
+import kotlin.time.Duration
 import kotlin.time.ExperimentalTime
-import kotlin.time.milliseconds
 
 @ExperimentalTime
 @ExperimentalCoroutinesApi
 class BucketRateLimiterTest {
 
-    val interval = 1_000_000.milliseconds
-    val instant = Instant.now()
-    val clock = Clock.fixed(instant, ZoneOffset.UTC)
+    val interval = Duration.milliseconds(1_000_000)
+    val instant = Clock.System.now()
+    val clock = Clock.fixed(instant)
     lateinit var rateLimiter: BucketRateLimiter
 
     @BeforeTest
@@ -38,7 +39,7 @@ class BucketRateLimiterTest {
         rateLimiter.consume()
         rateLimiter.consume()
 
-        asserter.assertTrue("expected timeout of ${interval.inMilliseconds.toLong()} ms but was $currentTime ms", interval.toLongMilliseconds() == currentTime)
+        asserter.assertTrue("expected timeout of ${interval.inWholeMilliseconds} ms but was $currentTime ms", interval.inWholeMilliseconds == currentTime)
     }
 
 }
diff --git a/common/src/test/resources/json/guild/guild.json b/common/src/test/resources/json/guild/guild.json
index 0c7995a220d..a9f61a3f258 100644
--- a/common/src/test/resources/json/guild/guild.json
+++ b/common/src/test/resources/json/guild/guild.json
@@ -38,5 +38,6 @@
   "system_channel_flags": 0,
   "preferred_locale": "en-US",
   "rules_channel_id": "441688182833020939",
-  "public_updates_channel_id": "281283303326089216"
+  "public_updates_channel_id": "281283303326089216",
+  "nsfw": true
 }
\ No newline at end of file
diff --git a/core/build.gradle.kts b/core/build.gradle.kts
index c0005177513..00dbed06cd7 100644
--- a/core/build.gradle.kts
+++ b/core/build.gradle.kts
@@ -37,7 +37,6 @@ tasks.withType<KotlinCompile> {
     kotlinOptions {
         jvmTarget = Jvm.target
         freeCompilerArgs = listOf(
-            CompilerArguments.inlineClasses,
             CompilerArguments.coroutines,
             CompilerArguments.time,
             CompilerArguments.stdLib,
diff --git a/core/src/main/kotlin/Unsafe.kt b/core/src/main/kotlin/Unsafe.kt
index dc3edb0017e..c949920656d 100644
--- a/core/src/main/kotlin/Unsafe.kt
+++ b/core/src/main/kotlin/Unsafe.kt
@@ -6,6 +6,7 @@ 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.rest.service.InteractionService
 
 /**
  * A class that exposes the creation of `{Entity}Behavior` classes.
@@ -67,8 +68,27 @@ class Unsafe(private val kord: Kord) {
     fun webhook(id: Snowflake): WebhookBehavior =
         WebhookBehavior(id, kord)
 
+    fun stageInstance(id: Snowflake, channelId: Snowflake): StageInstanceBehavior = StageInstanceBehavior(
+        id, channelId, kord, kord.defaultSupplier
+    )
+
     override fun toString(): String {
         return "Unsafe"
     }
 
+    fun guildApplicationCommand(
+        guildId: Snowflake,
+        applicationId: Snowflake,
+        commandId: Snowflake,
+        service: InteractionService = kord.rest.interaction
+    ): GuildApplicationCommandBehavior =
+        GuildApplicationCommandBehavior(guildId, applicationId, commandId, service)
+
+    fun globalApplicationCommand(
+        applicationId: Snowflake,
+        commandId: Snowflake,
+        service: InteractionService = kord.rest.interaction
+    ): GlobalApplicationCommandBehavior =
+        GlobalApplicationCommandBehavior(applicationId, commandId, service)
+
 }
\ No newline at end of file
diff --git a/core/src/main/kotlin/Util.kt b/core/src/main/kotlin/Util.kt
index 72096671dd8..53216775441 100644
--- a/core/src/main/kotlin/Util.kt
+++ b/core/src/main/kotlin/Util.kt
@@ -21,8 +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 java.time.Instant
-import java.time.format.DateTimeFormatter
+import kotlinx.datetime.Instant
 import kotlin.contracts.ExperimentalContracts
 import kotlin.contracts.InvocationKind
 import kotlin.contracts.contract
@@ -38,9 +37,8 @@ internal fun Long?.toSnowflakeOrNull(): Snowflake? = when {
     else -> Snowflake(this)
 }
 
-internal fun String.toInstant() = DateTimeFormatter.ISO_OFFSET_DATE_TIME.parse(this, Instant::from)
-internal fun Int.toInstant() = Instant.ofEpochMilli(toLong())
-internal fun Long.toInstant() = Instant.ofEpochMilli(this)
+internal fun Int.toInstant() = Instant.fromEpochMilliseconds(toLong())
+internal fun Long.toInstant() = Instant.fromEpochMilliseconds(this)
 
 @OptIn(ExperimentalContracts::class)
 internal inline fun <T> catchNotFound(block: () -> T): T? {
diff --git a/core/src/main/kotlin/behavior/GlobalApplicationCommandBehavior.kt b/core/src/main/kotlin/behavior/GlobalApplicationCommandBehavior.kt
index 0ae7a368b95..3ac88c5040c 100644
--- a/core/src/main/kotlin/behavior/GlobalApplicationCommandBehavior.kt
+++ b/core/src/main/kotlin/behavior/GlobalApplicationCommandBehavior.kt
@@ -91,4 +91,37 @@ interface GuildApplicationCommandBehavior : ApplicationCommandBehavior {
     override suspend fun delete() {
         service.deleteGuildApplicationCommand(applicationId, guildId, id)
     }
+
+}
+
+@KordPreview
+fun GuildApplicationCommandBehavior(
+    guildId: Snowflake,
+    applicationId: Snowflake,
+    id: Snowflake,
+    service: InteractionService
+): GuildApplicationCommandBehavior = object : GuildApplicationCommandBehavior {
+    override val guildId: Snowflake
+        get() = guildId
+    override val applicationId: Snowflake
+        get() = applicationId
+    override val service: InteractionService
+        get() = service
+    override val id: Snowflake
+        get() = id
 }
+
+
+@KordPreview
+fun GlobalApplicationCommandBehavior(
+    applicationId: Snowflake,
+    id: Snowflake,
+    service: InteractionService
+): GlobalApplicationCommandBehavior = object : GlobalApplicationCommandBehavior {
+    override val applicationId: Snowflake
+        get() = applicationId
+    override val service: InteractionService
+        get() = service
+    override val id: Snowflake
+        get() = id
+}
\ No newline at end of file
diff --git a/core/src/main/kotlin/behavior/StageInstanceBehavior.kt b/core/src/main/kotlin/behavior/StageInstanceBehavior.kt
new file mode 100644
index 00000000000..bd8f4ed2c05
--- /dev/null
+++ b/core/src/main/kotlin/behavior/StageInstanceBehavior.kt
@@ -0,0 +1,45 @@
+package dev.kord.core.behavior
+
+import dev.kord.common.entity.Snowflake
+import dev.kord.core.Kord
+import dev.kord.core.cache.data.StageInstanceData
+import dev.kord.core.entity.KordEntity
+import dev.kord.core.entity.StageInstance
+import dev.kord.core.entity.Strategizable
+import dev.kord.core.supplier.EntitySupplier
+import dev.kord.core.supplier.EntitySupplyStrategy
+import dev.kord.rest.json.request.StageInstanceUpdateRequest
+
+interface StageInstanceBehavior : KordEntity, Strategizable {
+    val channelId: Snowflake
+
+    suspend fun delete(): Unit = kord.rest.stageInstance.deleteStageInstance(channelId)
+
+    suspend fun update(topic: String): StageInstance {
+        val instance = kord.rest.stageInstance.updateStageInstance(channelId, StageInstanceUpdateRequest(topic))
+        val data = StageInstanceData.from(instance)
+
+        return StageInstance(data, kord, supplier)
+    }
+
+    suspend fun asStageInstance(): StageInstance = supplier.getStageInstance(channelId)
+
+    override fun withStrategy(strategy: EntitySupplyStrategy<*>): StageInstanceBehavior =
+        StageInstanceBehavior(id, channelId, kord, strategy.supply(kord))
+}
+
+internal fun StageInstanceBehavior(id: Snowflake, channelId: Snowflake, kord: Kord, supplier: EntitySupplier) =
+    object : StageInstanceBehavior {
+        override val channelId: Snowflake
+            get() = channelId
+        override val kord: Kord
+            get() = kord
+        override val id: Snowflake
+            get() = id
+        override val supplier: EntitySupplier
+            get() = supplier
+
+        override fun toString(): String {
+            return "StageInstanceBehavior(id=$id, channelId=$id, kord=$kord, supplier=$supplier)"
+        }
+    }
diff --git a/core/src/main/kotlin/behavior/channel/GuildMessageChannelBehavior.kt b/core/src/main/kotlin/behavior/channel/GuildMessageChannelBehavior.kt
index 63e4f5cbc28..0e457946e94 100644
--- a/core/src/main/kotlin/behavior/channel/GuildMessageChannelBehavior.kt
+++ b/core/src/main/kotlin/behavior/channel/GuildMessageChannelBehavior.kt
@@ -16,8 +16,9 @@ import dev.kord.rest.request.RestRequestException
 import dev.kord.rest.service.RestClient
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.flow
-import java.time.Duration
-import java.time.Instant
+import kotlinx.datetime.Clock
+import kotlin.time.Duration
+import kotlinx.datetime.Instant
 import java.util.*
 import kotlin.contracts.ExperimentalContracts
 import kotlin.contracts.InvocationKind
@@ -70,11 +71,11 @@ interface GuildMessageChannelBehavior : GuildChannelBehavior, MessageChannelBeha
      * @throws [RestRequestException] if something went wrong during the request.
      */
     suspend fun bulkDelete(messages: Iterable<Snowflake>) {
-        val daysLimit = Instant.now() - Duration.ofDays(14)
+        val daysLimit = Clock.System.now() - Duration.days(14)
         //split up in bulk delete and manual delete
         // if message.timeMark + 14 days > now, then the message isn't 14 days old yet, and we can add it to the bulk delete
         // if message.timeMark + 14 days < now, then the message is more than 14 days old, and we'll have to manually delete them
-        val (younger, older) = messages.partition { it.timeStamp.isAfter(daysLimit) }
+        val (younger, older) = messages.partition { it.timeStamp > daysLimit }
 
         younger.chunked(100).forEach {
             if (it.size < 2) kord.rest.channel.deleteMessage(id, it.first())
diff --git a/core/src/main/kotlin/behavior/channel/MessageChannelBehavior.kt b/core/src/main/kotlin/behavior/channel/MessageChannelBehavior.kt
index df3e98301f7..b702eaf046c 100644
--- a/core/src/main/kotlin/behavior/channel/MessageChannelBehavior.kt
+++ b/core/src/main/kotlin/behavior/channel/MessageChannelBehavior.kt
@@ -18,14 +18,15 @@ import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.flow
 import kotlinx.coroutines.launch
-import java.time.Instant
+import kotlinx.datetime.Clock
+import kotlinx.datetime.Instant
 import java.util.*
 import kotlin.contracts.ExperimentalContracts
 import kotlin.contracts.InvocationKind
 import kotlin.contracts.contract
 import kotlin.coroutines.coroutineContext
+import kotlin.time.Duration
 import kotlin.time.TimeMark
-import kotlin.time.seconds
 
 /**
  * The behavior of a Discord channel that can use messages.
@@ -199,7 +200,7 @@ interface MessageChannelBehavior : ChannelBehavior, Strategizable {
     suspend fun typeUntil(mark: TimeMark) {
         while (mark.hasNotPassedNow()) {
             type()
-            delay(8.seconds.toLongMilliseconds()) //bracing ourselves for some network delays
+            delay(Duration.seconds(8).inWholeMilliseconds) //bracing ourselves for some network delays
         }
     }
 
@@ -210,9 +211,9 @@ interface MessageChannelBehavior : ChannelBehavior, Strategizable {
      * @throws [RestRequestException] if something went wrong during the request.
      */
     suspend fun typeUntil(instant: Instant) {
-        while (instant.isBefore(Instant.now())) {
+        while (instant < Clock.System.now()) {
             type()
-            delay(8.seconds.toLongMilliseconds()) //bracing ourselves for some network delays
+            delay(Duration.seconds(8).inWholeMilliseconds) //bracing ourselves for some network delays
         }
     }
 
@@ -297,7 +298,7 @@ suspend inline fun <T : MessageChannelBehavior> T.withTyping(block: T.() -> Unit
     kord.launch(context = coroutineContext) {
         while (typing) {
             type()
-            delay(8.seconds.toLongMilliseconds())
+            delay(Duration.seconds(8).inWholeMilliseconds)
         }
     }
 
diff --git a/core/src/main/kotlin/behavior/channel/StageChannelBehavior.kt b/core/src/main/kotlin/behavior/channel/StageChannelBehavior.kt
index 2d93dcc7bd7..6a01603a989 100644
--- a/core/src/main/kotlin/behavior/channel/StageChannelBehavior.kt
+++ b/core/src/main/kotlin/behavior/channel/StageChannelBehavior.kt
@@ -3,15 +3,18 @@ package dev.kord.core.behavior.channel
 import dev.kord.common.entity.Snowflake
 import dev.kord.core.Kord
 import dev.kord.core.cache.data.ChannelData
+import dev.kord.core.entity.channel.VoiceChannel
+import dev.kord.core.cache.data.StageInstanceData
+import dev.kord.core.entity.StageInstance
 import dev.kord.core.entity.channel.Channel
 import dev.kord.core.entity.channel.StageChannel
-import dev.kord.core.entity.channel.VoiceChannel
 import dev.kord.core.supplier.EntitySupplier
 import dev.kord.core.supplier.EntitySupplyStrategy
 import dev.kord.rest.builder.channel.StageVoiceChannelModifyBuilder
 import dev.kord.rest.builder.guild.CurrentVoiceStateModifyBuilder
 import dev.kord.rest.builder.guild.VoiceStateModifyBuilder
 import dev.kord.rest.request.RestRequestException
+import dev.kord.rest.service.createStageInstance
 import dev.kord.rest.service.modifyCurrentVoiceState
 import dev.kord.rest.service.modifyVoiceState
 import dev.kord.rest.service.patchStageVoiceChannel
@@ -30,6 +33,17 @@ interface StageChannelBehavior : BaseVoiceChannelBehavior {
         return StageChannelBehavior(id, guildId, kord, strategy.supply(kord))
     }
 
+    suspend fun createStageInstance(topic: String): StageInstance {
+        val instance = kord.rest.stageInstance.createStageInstance(id, topic)
+        val data = StageInstanceData.from(instance)
+
+        return StageInstance(data, kord, supplier)
+    }
+
+    suspend fun getStageInstanceOrNull(): StageInstance? = supplier.getStageInstanceOrNull(id)
+
+    suspend fun getStageInstance(): StageInstance = supplier.getStageInstance(id)
+
 }
 
 /**
diff --git a/core/src/main/kotlin/builder/components/ButtonBuilderExtensions.kt b/core/src/main/kotlin/builder/components/ButtonBuilderExtensions.kt
new file mode 100644
index 00000000000..1fec49064e3
--- /dev/null
+++ b/core/src/main/kotlin/builder/components/ButtonBuilderExtensions.kt
@@ -0,0 +1,17 @@
+package dev.kord.core.builder.components
+
+import dev.kord.common.annotation.KordPreview
+import dev.kord.common.entity.DiscordPartialEmoji
+import dev.kord.core.entity.GuildEmoji
+import dev.kord.core.entity.ReactionEmoji
+import dev.kord.rest.builder.components.ButtonBuilder
+
+@KordPreview
+fun ButtonBuilder.emoji(emoji: ReactionEmoji) {
+    this.emoji = DiscordPartialEmoji(name = emoji.name, id = null)
+}
+
+@KordPreview
+fun ButtonBuilder.emoji(emoji: GuildEmoji) {
+    this.emoji = DiscordPartialEmoji(id = emoji.id, name = null)
+}
diff --git a/core/src/main/kotlin/builder/kord/KordBuilder.kt b/core/src/main/kotlin/builder/kord/KordBuilder.kt
index 3e3d987cb86..2f6edd0053e 100644
--- a/core/src/main/kotlin/builder/kord/KordBuilder.kt
+++ b/core/src/main/kotlin/builder/kord/KordBuilder.kt
@@ -40,18 +40,19 @@ import kotlin.concurrent.thread
 import kotlin.contracts.ExperimentalContracts
 import kotlin.contracts.InvocationKind
 import kotlin.contracts.contract
+import kotlin.time.Duration
 import kotlin.time.seconds
 
 operator fun DefaultGateway.Companion.invoke(
     resources: ClientResources,
-    retry: Retry = LinearRetry(2.seconds, 60.seconds, 10)
+    retry: Retry = LinearRetry(Duration.seconds(2), Duration.seconds(60), 10)
 ): DefaultGateway {
     return DefaultGateway {
         url = "wss://gateway.discord.gg/"
         client = resources.httpClient
         reconnectRetry = retry
-        sendRateLimiter = BucketRateLimiter(120, 60.seconds)
-        identifyRateLimiter = BucketRateLimiter(1, 5.seconds)
+        sendRateLimiter = BucketRateLimiter(120, Duration.seconds(60))
+        identifyRateLimiter = BucketRateLimiter(1, Duration.seconds(5))
     }
 }
 
@@ -63,7 +64,7 @@ class KordBuilder(val token: String) {
     private var shardsBuilder: (recommended: Int) -> Shards = { Shards(it) }
     private var gatewayBuilder: (resources: ClientResources, shards: List<Int>) -> List<Gateway> =
         { resources, shards ->
-            val rateLimiter = BucketRateLimiter(1, 5.seconds)
+            val rateLimiter = BucketRateLimiter(1, Duration.seconds(5))
             shards.map {
                 DefaultGateway {
                     client = resources.httpClient
diff --git a/core/src/main/kotlin/cache/data/ActivityData.kt b/core/src/main/kotlin/cache/data/ActivityData.kt
index 5346dc820df..fbcff408dcc 100644
--- a/core/src/main/kotlin/cache/data/ActivityData.kt
+++ b/core/src/main/kotlin/cache/data/ActivityData.kt
@@ -22,6 +22,7 @@ data class ActivityData(
     val secrets: Optional<DiscordActivitySecrets> = Optional.Missing(),
     val instance: OptionalBoolean = OptionalBoolean.Missing,
     val flags: Optional<ActivityFlags> = Optional.Missing(),
+    val buttons: Optional<List<String>> = Optional.Missing()
 ) {
     companion object {
         fun from(entity: DiscordActivity) = with(entity) {
@@ -39,7 +40,8 @@ data class ActivityData(
                 assets,
                 secrets,
                 instance,
-                flags
+                flags,
+                buttons
             )
         }
     }
diff --git a/core/src/main/kotlin/cache/data/GuildData.kt b/core/src/main/kotlin/cache/data/GuildData.kt
index 2da5a2aa2d5..32e92ede9b9 100644
--- a/core/src/main/kotlin/cache/data/GuildData.kt
+++ b/core/src/main/kotlin/cache/data/GuildData.kt
@@ -54,6 +54,8 @@ data class GuildData(
     val maxVideoChannelUsers: OptionalInt = OptionalInt.Missing,
     val approximateMemberCount: OptionalInt = OptionalInt.Missing,
     val approximatePresenceCount: OptionalInt = OptionalInt.Missing,
+    val welcomeScreen: Optional<WelcomeScreenData> = Optional.Missing(),
+    val nsfw: Boolean
 ) {
     companion object {
 
@@ -113,6 +115,8 @@ data class GuildData(
                 maxVideoChannelUsers = maxVideoChannelUsers,
                 approximateMemberCount = approximateMemberCount,
                 approximatePresenceCount = approximatePresenceCount,
+                welcomeScreen = welcomeScreen.map { WelcomeScreenData.from(it) },
+                nsfw = nsfw
             )
         }
     }
diff --git a/core/src/main/kotlin/cache/data/InteractionData.kt b/core/src/main/kotlin/cache/data/InteractionData.kt
index 566cb3f1189..4884442ee9d 100644
--- a/core/src/main/kotlin/cache/data/InteractionData.kt
+++ b/core/src/main/kotlin/cache/data/InteractionData.kt
@@ -2,11 +2,24 @@ package dev.kord.core.cache.data
 
 import dev.kord.common.annotation.KordExperimental
 import dev.kord.common.annotation.KordPreview
-import dev.kord.common.entity.*
-import dev.kord.common.entity.NotSerializable
-import dev.kord.common.entity.optional.*
-import dev.kord.gateway.InteractionCreate
-import kotlinx.serialization.Contextual
+import dev.kord.common.entity.Choice
+import dev.kord.common.entity.CommandArgument
+import dev.kord.common.entity.CommandGroup
+import dev.kord.common.entity.ComponentType
+import dev.kord.common.entity.DiscordInteraction
+import dev.kord.common.entity.InteractionCallbackData
+import dev.kord.common.entity.InteractionType
+import dev.kord.common.entity.Option
+import dev.kord.common.entity.Permissions
+import dev.kord.common.entity.ResolvedObjects
+import dev.kord.common.entity.Snowflake
+import dev.kord.common.entity.SubCommand
+import dev.kord.common.entity.optional.Optional
+import dev.kord.common.entity.optional.OptionalSnowflake
+import dev.kord.common.entity.optional.flatMap
+import dev.kord.common.entity.optional.map
+import dev.kord.common.entity.optional.mapValues
+import dev.kord.common.entity.optional.switchOnMissing
 import kotlinx.serialization.KSerializer
 import kotlinx.serialization.Serializable
 import kotlinx.serialization.builtins.serializer
@@ -19,14 +32,15 @@ data class InteractionData(
     val id: Snowflake,
     val applicationId: Snowflake,
     val type: InteractionType,
-    val data: ApplicationCommandInteractionData,
+    val data: ApplicationInteractionData,
     val guildId: OptionalSnowflake = OptionalSnowflake.Missing,
     val channelId: Snowflake,
     val member: Optional<MemberData> = Optional.Missing(),
     val user: Optional<UserData> = Optional.Missing(),
     val token: String,
     val permissions: Optional<Permissions>,
-    val version: Int
+    val version: Int,
+    val message: Optional<MessageData> = Optional.Missing()
 ) {
     companion object {
         fun from(interaction: DiscordInteraction): InteractionData {
@@ -35,7 +49,7 @@ data class InteractionData(
                     id,
                     applicationId,
                     type,
-                    ApplicationCommandInteractionData.from(data, guildId.value),
+                    ApplicationInteractionData.from(data, guildId.value),
                     guildId,
                     channelId,
                     member.map { it.toData(it.user.value!!.id, guildId.value!!) },
@@ -43,7 +57,10 @@ data class InteractionData(
                     user.switchOnMissing(member.flatMap { it.user }).map { it.toData() },
                     token,
                     member.map { it.permissions },
-                    version
+                    version,
+                    message.map {
+                        MessageData.from(it)
+                    }
                 )
             }
         }
@@ -70,28 +87,30 @@ data class ResolvedObjectsData(
     }
 }
 
-
-@KordPreview
 @Serializable
-data class ApplicationCommandInteractionData(
-    val id: Snowflake,
-    val name: String,
+data class ApplicationInteractionData(
+    val id: OptionalSnowflake = OptionalSnowflake.Missing,
+    val name: Optional<String> = Optional.Missing(),
     val options: Optional<List<OptionData>> = Optional.Missing(),
-    val resolvedObjectsData: Optional<ResolvedObjectsData> = Optional.Missing()
+    val resolvedObjectsData: Optional<ResolvedObjectsData> = Optional.Missing(),
+    val customId: Optional<String> = Optional.Missing(),
+    val componentType: Optional<ComponentType> = Optional.Missing()
 ) {
     companion object {
+
         fun from(
-            data: DiscordApplicationCommandInteractionData,
+            data: InteractionCallbackData,
             guildId: Snowflake?
-        ): ApplicationCommandInteractionData {
+        ): ApplicationInteractionData {
             return with(data) {
-                ApplicationCommandInteractionData(
+                ApplicationInteractionData(
                     id,
                     name,
-                    options.mapList { OptionData.from(it) },
-                    data.resolved.map { ResolvedObjectsData.from(it, guildId) }
+                    options.map { it.map { OptionData.from(it) } },
+                    resolved.map { ResolvedObjectsData.from(it, guildId) },
+                    customId,
+                    componentType
                 )
-
             }
         }
     }
diff --git a/core/src/main/kotlin/cache/data/MessageData.kt b/core/src/main/kotlin/cache/data/MessageData.kt
index b64740e94aa..dd0e619ad99 100644
--- a/core/src/main/kotlin/cache/data/MessageData.kt
+++ b/core/src/main/kotlin/cache/data/MessageData.kt
@@ -1,5 +1,6 @@
 package dev.kord.core.cache.data
 
+import cache.data.MessageInteractionData
 import dev.kord.cache.api.data.description
 import dev.kord.common.entity.*
 import dev.kord.common.entity.optional.*
@@ -30,10 +31,13 @@ data class MessageData(
     val type: MessageType,
     val activity: Optional<MessageActivity> = Optional.Missing(),
     val application: Optional<MessageApplication> = Optional.Missing(),
+    val applicationId: OptionalSnowflake = OptionalSnowflake.Missing,
     val messageReference: Optional<MessageReferenceData> = Optional.Missing(),
     val flags: Optional<MessageFlags> = Optional.Missing(),
     val stickers: Optional<List<MessageStickerData>> = Optional.Missing(),
     val referencedMessage: Optional<MessageData?> = Optional.Missing(),
+    val interaction: Optional<MessageInteractionData> = Optional.Missing(),
+    val components: Optional<List<DiscordComponent>> = Optional.Missing()
 ) {
 
     fun plus(selfId: Snowflake, reaction: MessageReactionAddData): MessageData {
@@ -69,6 +73,9 @@ data class MessageData(
             partialMessage.mentionedChannels.mapList { it.id }.switchOnMissing(mentionedChannels.value.orEmpty())
                 .coerceToMissing()
         val stickers = partialMessage.stickers.mapList { MessageStickerData.from(it) }.switchOnMissing(this.stickers)
+        val referencedMessage = partialMessage.referencedMessage.mapNullable { it?.toData() ?: referencedMessage.value }
+        val interaction =
+            partialMessage.interaction.map { MessageInteractionData.from(it) }.switchOnMissing(interaction)
 
         return MessageData(
             id,
@@ -92,9 +99,13 @@ data class MessageData(
             type,
             activity,
             application,
+            applicationId,
             messageReference,
             flags,
             stickers = stickers,
+            referencedMessage = referencedMessage,
+            interaction = interaction,
+            components = components
         )
     }
 
@@ -124,13 +135,16 @@ data class MessageData(
                 type,
                 activity,
                 application,
+                applicationId,
                 messageReference.map { MessageReferenceData.from(it) },
                 flags,
                 stickers.mapList { MessageStickerData.from(it) },
-                referencedMessage.mapNotNull { from(it) }
+                referencedMessage.mapNotNull { from(it) },
+                interaction.map { MessageInteractionData.from(it) },
+                components = components
             )
         }
     }
 }
 
-fun DiscordMessage.toData() = MessageData.from(this)
\ No newline at end of file
+fun DiscordMessage.toData() = MessageData.from(this)
diff --git a/core/src/main/kotlin/cache/data/MessageInteractionData.kt b/core/src/main/kotlin/cache/data/MessageInteractionData.kt
new file mode 100644
index 00000000000..a7882ff8dc2
--- /dev/null
+++ b/core/src/main/kotlin/cache/data/MessageInteractionData.kt
@@ -0,0 +1,24 @@
+package cache.data;
+
+import dev.kord.common.annotation.KordPreview
+import dev.kord.common.entity.DiscordMessageInteraction
+import dev.kord.common.entity.InteractionType
+import dev.kord.common.entity.Snowflake
+import dev.kord.core.cache.data.UserData
+import dev.kord.core.cache.data.toData
+import kotlinx.serialization.Serializable
+
+@KordPreview
+@Serializable
+data class MessageInteractionData(
+    val id:Snowflake,
+    val type:InteractionType,
+    val name:String,
+    val user: Snowflake
+) {
+    companion object {
+        fun from(entity: DiscordMessageInteraction): MessageInteractionData = with(entity) {
+            MessageInteractionData(id, type, name, user.id)
+        }
+    }
+}
diff --git a/core/src/main/kotlin/cache/data/StageInstanceData.kt b/core/src/main/kotlin/cache/data/StageInstanceData.kt
new file mode 100644
index 00000000000..43e6af3ba95
--- /dev/null
+++ b/core/src/main/kotlin/cache/data/StageInstanceData.kt
@@ -0,0 +1,19 @@
+package dev.kord.core.cache.data
+
+import dev.kord.common.entity.DiscordStageInstance
+import dev.kord.common.entity.Snowflake
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class StageInstanceData(
+    val id: Snowflake,
+    val guildId: Snowflake,
+    val channelId: Snowflake,
+    val topic: String
+) {
+    companion object {
+        fun from(stageInstance: DiscordStageInstance) = with(stageInstance) {
+            StageInstanceData(id, guildId, channelId, topic)
+        }
+    }
+}
diff --git a/core/src/main/kotlin/entity/Activity.kt b/core/src/main/kotlin/entity/Activity.kt
index 299c4ee316b..e5f0bacdb90 100644
--- a/core/src/main/kotlin/entity/Activity.kt
+++ b/core/src/main/kotlin/entity/Activity.kt
@@ -5,7 +5,7 @@ import dev.kord.common.entity.*
 import dev.kord.common.entity.optional.value
 import dev.kord.core.cache.data.ActivityData
 import dev.kord.core.toInstant
-import java.time.Instant
+import kotlinx.datetime.Instant
 
 class Activity(val data: ActivityData) {
 
@@ -57,6 +57,9 @@ class Activity(val data: ActivityData) {
     val flags: ActivityFlags?
         get() = data.flags.value
 
+    val buttons: List<String>?
+        get() = data.buttons.value
+
     override fun toString(): String {
         return "Activity(data=$data)"
     }
diff --git a/core/src/main/kotlin/entity/Embed.kt b/core/src/main/kotlin/entity/Embed.kt
index 7911fbde1d6..57f44d4b371 100644
--- a/core/src/main/kotlin/entity/Embed.kt
+++ b/core/src/main/kotlin/entity/Embed.kt
@@ -9,9 +9,9 @@ import dev.kord.common.entity.optional.value
 import dev.kord.core.Kord
 import dev.kord.core.KordObject
 import dev.kord.core.cache.data.*
-import dev.kord.core.toInstant
 import dev.kord.rest.builder.message.EmbedBuilder
-import java.time.Instant
+import kotlinx.datetime.Instant
+import kotlinx.datetime.toInstant
 
 internal const val embedDeprecationMessage = """
 Embed types should be considered deprecated and might be removed in a future API version.
diff --git a/core/src/main/kotlin/entity/Guild.kt b/core/src/main/kotlin/entity/Guild.kt
index 0c0ec59c56e..a996240e8e1 100644
--- a/core/src/main/kotlin/entity/Guild.kt
+++ b/core/src/main/kotlin/entity/Guild.kt
@@ -27,8 +27,8 @@ import dev.kord.core.supplier.getChannelOfOrNull
 import dev.kord.rest.Image
 import dev.kord.rest.service.RestClient
 import kotlinx.coroutines.flow.first
-import java.time.Instant
-import java.time.format.DateTimeFormatter
+import kotlinx.datetime.Instant
+import kotlinx.datetime.toInstant
 import java.util.*
 
 /**
@@ -182,12 +182,7 @@ class Guild(
      * The time at which this guild was joined, if present.
      */
     val joinedTime: Instant?
-        get() = data.joinedAt.value?.let {
-            DateTimeFormatter.ISO_OFFSET_DATE_TIME.parse(
-                it,
-                Instant::from
-            )
-        }
+        get() = data.joinedAt.value?.toInstant()
 
     /**
      * The id of the owner.
@@ -332,6 +327,16 @@ class Guild(
      */
     val maxVideoChannelUsers: Int? get() = data.maxVideoChannelUsers.value
 
+    /**
+     * The welcome screen of a Community guild, shown to new members, returned in an [Invite]'s guild object
+     */
+    val welcomeScreen: WelcomeScreen? get() = data.welcomeScreen.unwrap { WelcomeScreen(it, kord) }
+
+    /**
+     * True if this guild is [designated as NSFW](https://support.discord.com/hc/en-us/articles/1500005389362-NSFW-Server-Designation)
+     */
+    val nsfw: Boolean get() = data.nsfw
+
     /**
      * Requests to get the [VoiceChannel] represented by the [afkChannelId],
      * returns null if the [afkChannelId] isn't present or the channel itself isn't present.
diff --git a/core/src/main/kotlin/entity/Integration.kt b/core/src/main/kotlin/entity/Integration.kt
index 82b44db0256..91bd8c7d162 100644
--- a/core/src/main/kotlin/entity/Integration.kt
+++ b/core/src/main/kotlin/entity/Integration.kt
@@ -11,12 +11,11 @@ import dev.kord.core.cache.data.IntegrationData
 import dev.kord.core.exception.EntityNotFoundException
 import dev.kord.core.supplier.EntitySupplier
 import dev.kord.core.supplier.EntitySupplyStrategy
-import dev.kord.core.toInstant
 import dev.kord.rest.builder.integration.IntegrationModifyBuilder
 import dev.kord.rest.request.RestRequestException
-import java.time.Duration
-import java.time.Instant
-import java.time.temporal.ChronoUnit
+import kotlin.time.Duration
+import kotlinx.datetime.Instant
+import kotlinx.datetime.toInstant
 import java.util.*
 import kotlin.contracts.ExperimentalContracts
 import kotlin.contracts.InvocationKind
@@ -99,7 +98,7 @@ class Integration(
      * The grace period in days before expiring subscribers.
      */
     val expireGracePeriod: Duration
-        get() = Duration.of(data.expireGracePeriod.toLong(), ChronoUnit.DAYS)
+        get() = Duration.days(data.expireGracePeriod)
 
     /**
      * The id of the [user][User] for this integration.
diff --git a/core/src/main/kotlin/entity/Member.kt b/core/src/main/kotlin/entity/Member.kt
index 6ccf25caef1..36a9744e47d 100644
--- a/core/src/main/kotlin/entity/Member.kt
+++ b/core/src/main/kotlin/entity/Member.kt
@@ -12,10 +12,9 @@ import dev.kord.core.cache.data.MemberData
 import dev.kord.core.cache.data.UserData
 import dev.kord.core.supplier.EntitySupplier
 import dev.kord.core.supplier.EntitySupplyStrategy
-import dev.kord.core.toInstant
 import kotlinx.coroutines.flow.*
-import java.time.Instant
-import java.time.format.DateTimeFormatter
+import kotlinx.datetime.toInstant
+import kotlinx.datetime.Instant
 import java.util.*
 
 /**
@@ -39,7 +38,7 @@ class Member(
     /**
      * When the user joined this [guild].
      */
-    val joinedAt: Instant get() = DateTimeFormatter.ISO_OFFSET_DATE_TIME.parse(memberData.joinedAt, Instant::from)
+    val joinedAt: Instant get() = memberData.joinedAt.toInstant()
 
     /**
      * The guild-specific nickname of the user, if present.
diff --git a/core/src/main/kotlin/entity/Message.kt b/core/src/main/kotlin/entity/Message.kt
index 05d22f2f666..f3a53dda558 100644
--- a/core/src/main/kotlin/entity/Message.kt
+++ b/core/src/main/kotlin/entity/Message.kt
@@ -1,8 +1,13 @@
 package dev.kord.core.entity
 
+import dev.kord.common.annotation.KordPreview
+import dev.kord.common.entity.DiscordComponent
 import dev.kord.common.entity.MessageType
 import dev.kord.common.entity.Snowflake
+import dev.kord.common.entity.optional.map
+import dev.kord.common.entity.optional.mapNullable
 import dev.kord.common.entity.optional.orEmpty
+import dev.kord.common.entity.optional.unwrap
 import dev.kord.common.exception.RequestException
 import dev.kord.core.Kord
 import dev.kord.core.behavior.MessageBehavior
@@ -13,14 +18,16 @@ import dev.kord.core.entity.channel.Channel
 import dev.kord.core.entity.channel.GuildChannel
 import dev.kord.core.entity.channel.GuildMessageChannel
 import dev.kord.core.entity.channel.MessageChannel
+import dev.kord.core.entity.interaction.MessageInteraction
+import dev.kord.core.entity.interaction.Interaction
 import dev.kord.core.exception.EntityNotFoundException
 import dev.kord.core.supplier.EntitySupplier
 import dev.kord.core.supplier.EntitySupplyStrategy
 import dev.kord.core.supplier.getChannelOf
 import dev.kord.core.supplier.getChannelOfOrNull
 import kotlinx.coroutines.flow.*
-import java.time.Instant
-import java.time.format.DateTimeFormatter
+import kotlinx.datetime.Instant
+import kotlinx.datetime.toInstant
 import java.util.*
 
 /**
@@ -69,9 +76,7 @@ class Message(
      * Returns null if the message was never edited.
      */
     val editedTimestamp: Instant?
-        get() = data.editedTimestamp?.let {
-            DateTimeFormatter.ISO_OFFSET_DATE_TIME.parse(it, Instant::from)
-        }
+        get() = data.editedTimestamp?.toInstant()
 
     /**
      * The embedded content of this message.
@@ -102,6 +107,11 @@ class Message(
      */
     val stickers: List<MessageSticker> get() = data.stickers.orEmpty().map { MessageSticker(it, kord) }
 
+    /**
+     * If the message is a response to an [Interaction], this is the id of the interaction's application
+     */
+    val applicationId: Snowflake? get() = data.application.unwrap { it.id }
+
     /**
      * The message being replied to.
      *
@@ -174,6 +184,12 @@ class Message(
      */
     val mentionedUserBehaviors: Set<UserBehavior> get() = data.mentions.map { UserBehavior(it, kord) }.toSet()
 
+    /**
+     * The [MessageInteraction] sent on this message object when it is a response to an [dev.kord.core.entity.interaction.Interaction].
+     */
+    @KordPreview
+    val interaction: MessageInteraction? get() = data.interaction.mapNullable { MessageInteraction(it, kord) }.value
+
     /**
      * The [users][User] mentioned in this message.
      *
@@ -199,7 +215,7 @@ class Message(
     /**
      * The instant when this message was created.
      */
-    val timestamp: Instant get() = DateTimeFormatter.ISO_OFFSET_DATE_TIME.parse(data.timestamp, Instant::from)
+    val timestamp: Instant get() = data.timestamp.toInstant()
 
     /**
      * Whether this message was send using `\tts`.
@@ -218,6 +234,9 @@ class Message(
      */
     val webhookId: Snowflake? get() = data.webhookId.value
 
+    @KordPreview
+    val components: List<DiscordComponent> get() = data.components.orEmpty()
+
     /**
      * Returns itself.
      */
diff --git a/core/src/main/kotlin/entity/StageInstance.kt b/core/src/main/kotlin/entity/StageInstance.kt
new file mode 100644
index 00000000000..5987e4d95e0
--- /dev/null
+++ b/core/src/main/kotlin/entity/StageInstance.kt
@@ -0,0 +1,19 @@
+package dev.kord.core.entity
+
+import dev.kord.common.entity.Snowflake
+import dev.kord.core.Kord
+import dev.kord.core.behavior.StageInstanceBehavior
+import dev.kord.core.cache.data.StageInstanceData
+import dev.kord.core.supplier.EntitySupplier
+import dev.kord.core.supplier.EntitySupplyStrategy
+
+class StageInstance(val data: StageInstanceData, override val kord: Kord, override val supplier: EntitySupplier) : StageInstanceBehavior {
+    override val id: Snowflake get() = data.id
+    val guildId: Snowflake get() = data.guildId
+    override val channelId: Snowflake get() = data.channelId
+    val topic: String get() = data.topic
+
+    override fun withStrategy(strategy: EntitySupplyStrategy<*>): StageInstanceBehavior =
+        StageInstance(data, kord, strategy.supply(kord))
+
+}
diff --git a/core/src/main/kotlin/entity/Template.kt b/core/src/main/kotlin/entity/Template.kt
index 1135a1d3bb5..821b8641d93 100644
--- a/core/src/main/kotlin/entity/Template.kt
+++ b/core/src/main/kotlin/entity/Template.kt
@@ -5,8 +5,8 @@ import dev.kord.core.Kord
 import dev.kord.core.KordObject
 import dev.kord.core.behavior.TemplateBehavior
 import dev.kord.core.cache.data.TemplateData
-import java.time.Instant
-import java.time.format.DateTimeFormatter
+import kotlinx.datetime.Instant
+import kotlinx.datetime.toInstant
 
 class Template(val data: TemplateData, override val kord: Kord) : KordObject, TemplateBehavior {
     override val code: String get() = data.code
@@ -21,9 +21,9 @@ class Template(val data: TemplateData, override val kord: Kord) : KordObject, Te
 
     val creator: User get() = User(data.creator, kord)
 
-    val createdAt: Instant get() = DateTimeFormatter.ISO_OFFSET_DATE_TIME.parse(data.createdAt, Instant::from)
+    val createdAt: Instant get() = data.createdAt.toInstant()
 
-    val updatedAt: Instant get() = DateTimeFormatter.ISO_OFFSET_DATE_TIME.parse(data.updatedAt, Instant::from)
+    val updatedAt: Instant get() = data.updatedAt.toInstant()
 
     override val guildId: Snowflake get() = data.sourceGuildId
 
diff --git a/core/src/main/kotlin/entity/VoiceState.kt b/core/src/main/kotlin/entity/VoiceState.kt
index bd5009b5c32..c64d40a1e7f 100644
--- a/core/src/main/kotlin/entity/VoiceState.kt
+++ b/core/src/main/kotlin/entity/VoiceState.kt
@@ -4,6 +4,7 @@ import dev.kord.common.annotation.DeprecatedSinceKord
 import dev.kord.common.entity.Snowflake
 import dev.kord.core.Kord
 import dev.kord.core.KordObject
+import dev.kord.core.behavior.channel.BaseVoiceChannelBehavior
 import dev.kord.core.cache.data.VoiceStateData
 import dev.kord.core.entity.channel.VoiceChannel
 import dev.kord.core.supplier.EntitySupplier
@@ -50,8 +51,8 @@ class VoiceState(
      * @throws [RequestException] if anything went wrong during the request.
      */
     @DeprecatedSinceKord("0.7.0")
-    @Deprecated("User getChannelOrNull instead.", ReplaceWith("getChannelOrNull"), DeprecationLevel.ERROR)
-    suspend fun getChannel(): VoiceChannel? = channelId?.let { supplier.getChannelOfOrNull(it) }
+    @Deprecated("Use getChannelOrNull instead.", ReplaceWith("getChannelOrNull"), DeprecationLevel.ERROR)
+    suspend fun getChannel(): BaseVoiceChannelBehavior? = channelId?.let { supplier.getChannelOfOrNull(it) }
 
     /**
      * Requests to get the voice channel through the [strategy],
@@ -59,7 +60,7 @@ class VoiceState(
      *
      * @throws [RequestException] if anything went wrong during the request.
      */
-    suspend fun getChannelOrNull(): VoiceChannel? = channelId?.let { supplier.getChannelOfOrNull(it) }
+    suspend fun getChannelOrNull(): BaseVoiceChannelBehavior? = channelId?.let { supplier.getChannelOfOrNull(it) }
 
 
     /**
@@ -104,4 +105,4 @@ class VoiceState(
         return "VoiceState(data=$data, kord=$kord, supplier=$supplier)"
     }
 
-}
\ No newline at end of file
+}
diff --git a/core/src/main/kotlin/entity/channel/MessageChannel.kt b/core/src/main/kotlin/entity/channel/MessageChannel.kt
index 4e69db7179b..aecba2f988c 100644
--- a/core/src/main/kotlin/entity/channel/MessageChannel.kt
+++ b/core/src/main/kotlin/entity/channel/MessageChannel.kt
@@ -7,8 +7,8 @@ import dev.kord.core.behavior.MessageBehavior
 import dev.kord.core.behavior.channel.MessageChannelBehavior
 import dev.kord.core.entity.Message
 import dev.kord.core.supplier.EntitySupplyStrategy
-import dev.kord.core.toInstant
-import java.time.Instant
+import kotlinx.datetime.Instant
+import kotlinx.datetime.toInstant
 
 /**
  * An instance of a Discord channel that can use messages.
diff --git a/core/src/main/kotlin/entity/interaction/Interaction.kt b/core/src/main/kotlin/entity/interaction/Interaction.kt
index 9190b186a3c..daa3fb0ebb1 100644
--- a/core/src/main/kotlin/entity/interaction/Interaction.kt
+++ b/core/src/main/kotlin/entity/interaction/Interaction.kt
@@ -1,10 +1,7 @@
 package dev.kord.core.entity.interaction
 
 import dev.kord.common.annotation.KordPreview
-import dev.kord.common.entity.CommandArgument
-import dev.kord.common.entity.InteractionType
-import dev.kord.common.entity.Permissions
-import dev.kord.common.entity.Snowflake
+import dev.kord.common.entity.*
 import dev.kord.common.entity.optional.*
 import dev.kord.core.Kord
 import dev.kord.core.KordObject
@@ -14,13 +11,10 @@ import dev.kord.core.behavior.MemberBehavior
 import dev.kord.core.behavior.UserBehavior
 import dev.kord.core.behavior.channel.GuildMessageChannelBehavior
 import dev.kord.core.behavior.interaction.InteractionBehavior
-import dev.kord.core.cache.data.ApplicationCommandInteractionData
+import dev.kord.core.cache.data.ApplicationInteractionData
 import dev.kord.core.cache.data.InteractionData
 import dev.kord.core.cache.data.ResolvedObjectsData
-import dev.kord.core.entity.Entity
-import dev.kord.core.entity.Member
-import dev.kord.core.entity.Role
-import dev.kord.core.entity.User
+import dev.kord.core.entity.*
 import dev.kord.core.entity.channel.DmChannel
 import dev.kord.core.entity.channel.ResolvedChannel
 import dev.kord.core.supplier.EntitySupplier
@@ -51,15 +45,8 @@ sealed class Interaction : InteractionBehavior {
      */
     val type: InteractionType get() = data.type
 
-
     abstract val user: UserBehavior
 
-    /**
-     * [InteractionCommand] object that contains the data related to the interaction's command.
-     */
-    val command: InteractionCommand
-        get() = InteractionCommand(data.data, kord)
-
     /**
      * read-only property, always 1
      */
@@ -73,15 +60,38 @@ sealed class Interaction : InteractionBehavior {
             kord: Kord,
             strategy: EntitySupplyStrategy<*> = kord.resources.defaultStrategy
         ): Interaction {
-            return if (data.guildId !is OptionalSnowflake.Missing)
-                GuildInteraction(data, data.applicationId, kord, strategy.supply(kord))
-            else
-                DmInteraction(data, data.applicationId, kord, strategy.supply(kord))
+            return when {
+                data.type == InteractionType.Component -> ComponentInteraction(
+                    data,
+                    data.applicationId,
+                    kord,
+                    strategy.supply(kord)
+                )
+                data.guildId !is OptionalSnowflake.Missing -> GuildInteraction(
+                    data,
+                    data.applicationId,
+                    kord,
+                    strategy.supply(kord)
+                )
+                else -> DmInteraction(data, data.applicationId, kord, strategy.supply(kord))
+            }
         }
     }
 
 }
 
+/**
+ * The base interaction for all slash-command related interactions.
+ *
+ * @see DmInteraction
+ * @see GuildInteraction
+ */
+@KordPreview
+sealed class CommandInteraction : Interaction() {
+    val command: InteractionCommand
+        get() = InteractionCommand(data.data, kord)
+}
+
 /**
  * The base command of all commands that can be executed under an interaction event.
  */
@@ -106,7 +116,7 @@ sealed class InteractionCommand : KordObject {
 }
 
 fun InteractionCommand(
-    data: ApplicationCommandInteractionData,
+    data: ApplicationInteractionData,
     kord: Kord
 ): InteractionCommand {
     val firstLevelOptions = data.options.orEmpty()
@@ -130,14 +140,14 @@ fun InteractionCommand(
  */
 @KordPreview
 class RootCommand(
-    val data: ApplicationCommandInteractionData,
+    val data: ApplicationInteractionData,
     override val kord: Kord
 ) : InteractionCommand() {
 
     override val rootId: Snowflake
-        get() = data.id
+        get() = data.id.value!!
 
-    override val rootName get() = data.name
+    override val rootName get() = data.name.value!!
 
     override val options: Map<String, OptionValue<*>>
         get() = data.options.orEmpty()
@@ -153,16 +163,16 @@ class RootCommand(
  */
 @KordPreview
 class SubCommand(
-    val data: ApplicationCommandInteractionData,
+    val data: ApplicationInteractionData,
     override val kord: Kord
 ) : InteractionCommand() {
 
     private val subCommandData = data.options.orEmpty().first()
 
-    override val rootName get() = data.name
+    override val rootName get() = data.name.value!!
 
     override val rootId: Snowflake
-        get() = data.id
+        get() = data.id.value!!
 
     /**
      * Name of the sub-command executed.
@@ -185,7 +195,7 @@ class SubCommand(
  */
 @KordPreview
 class GroupCommand(
-    val data: ApplicationCommandInteractionData,
+    val data: ApplicationInteractionData,
     override val kord: Kord
 ) : InteractionCommand() {
 
@@ -193,9 +203,9 @@ class GroupCommand(
     private val subCommandData get() = groupData.subCommands.orEmpty().first()
 
     override val rootId: Snowflake
-        get() = data.id
+        get() = data.id.value!!
 
-    override val rootName get() = data.name
+    override val rootName get() = data.name.value!!
 
     /**
      * Name of the group of this sub-command.
@@ -230,7 +240,7 @@ class ResolvedObjects(
     val users: Map<Snowflake, User>? get() = data.users.mapValues { User(it.value, kord) }.value
     val members: Map<Snowflake, Member>?
         get() = data.members.mapValues {
-            Member(it.value,users!![it.key]!!.data, kord)
+            Member(it.value, users!![it.key]!!.data, kord)
         }.value
 
 }
@@ -241,24 +251,31 @@ sealed class OptionValue<out T>(val value: T) {
     class RoleOptionValue(value: Role) : OptionValue<Role>(value) {
         override fun toString(): String = "RoleOptionValue(value=$value)"
     }
+
     open class UserOptionValue(value: User) : OptionValue<User>(value) {
         override fun toString(): String = "UserOptionValue(value=$value)"
     }
+
     class MemberOptionValue(value: Member) : UserOptionValue(value) {
         override fun toString(): String = "MemberOptionValue(value=$value)"
     }
+
     class ChannelOptionValue(value: ResolvedChannel) : OptionValue<ResolvedChannel>(value) {
         override fun toString(): String = "ChannelOptionValue(value=$value)"
     }
+
     class IntOptionValue(value: Int) : OptionValue<Int>(value) {
         override fun toString(): String = "IntOptionValue(value=$value)"
     }
+
     class StringOptionValue(value: String) : OptionValue<String>(value) {
         override fun toString(): String = "StringOptionValue(value=$value)"
     }
+
     class BooleanOptionValue(value: Boolean) : OptionValue<Boolean>(value) {
         override fun toString(): String = "BooleanOptionValue(value=$value)"
     }
+
     class MentionableOptionValue(value: Entity) : OptionValue<Entity>(value) {
         override fun toString(): String = "MentionableOptionValue(value=$value)"
     }
@@ -316,7 +333,7 @@ class DmInteraction(
     override val applicationId: Snowflake,
     override val kord: Kord,
     override val supplier: EntitySupplier = kord.defaultSupplier,
-) : Interaction() {
+) : CommandInteraction() {
     /**
      * The user who invoked the interaction.
      */
@@ -326,13 +343,48 @@ class DmInteraction(
         DmInteraction(data, applicationId, kord, strategy.supply(kord))
 }
 
+/**
+ * An [Interaction] that was made with a [DiscordComponent].
+ */
+@KordPreview
+class ComponentInteraction(
+    override val data: InteractionData,
+    override val applicationId: Snowflake,
+    override val kord: Kord,
+    override val supplier: EntitySupplier
+) : Interaction(), InteractionBehavior {
+    override val user: UserBehavior = UserBehavior(data.member.value!!.userId, kord)
+
+    val message: Message
+        get() = data.message.unwrap {
+            Message(it, kord, supplier)
+        }!!
+
+    /**
+     * The [components][DiscordComponent] of the message that was interacted with.
+     */
+    val components: List<DiscordComponent> get() = message.components
+
+    /**
+     * The [DiscordComponent] the user interacted with.
+     *
+     * @see components
+     * @see DiscordComponent
+     */
+    val component: DiscordComponent get() = message.components.first { it.customId == data.data.customId }
+
+    override fun withStrategy(strategy: EntitySupplyStrategy<*>): Interaction = ComponentInteraction(
+        data, applicationId, kord, strategy.supply(kord)
+    )
+}
+
 @KordPreview
 class GuildInteraction(
     override val data: InteractionData,
     override val applicationId: Snowflake,
     override val kord: Kord,
     override val supplier: EntitySupplier
-) : Interaction(), GuildInteractionBehavior {
+) : CommandInteraction(), GuildInteractionBehavior {
 
     override val guildId: Snowflake
         get() = data.guildId.value!!
diff --git a/core/src/main/kotlin/entity/interaction/MessageInteraction.kt b/core/src/main/kotlin/entity/interaction/MessageInteraction.kt
new file mode 100644
index 00000000000..dbc82e78480
--- /dev/null
+++ b/core/src/main/kotlin/entity/interaction/MessageInteraction.kt
@@ -0,0 +1,67 @@
+package dev.kord.core.entity.interaction
+
+import cache.data.MessageInteractionData
+import dev.kord.common.annotation.KordPreview
+import dev.kord.common.entity.InteractionType
+import dev.kord.common.entity.Snowflake
+import dev.kord.common.exception.RequestException
+import dev.kord.core.Kord
+import dev.kord.core.behavior.UserBehavior
+import dev.kord.core.entity.KordEntity
+import dev.kord.core.entity.Message
+import dev.kord.core.entity.Strategizable
+import dev.kord.core.entity.User
+import dev.kord.core.exception.EntityNotFoundException
+import dev.kord.core.supplier.EntitySupplier
+import dev.kord.core.supplier.EntitySupplyStrategy
+
+/**
+ * An instance of [MessageInteraction](https://discord.com/developers/docs/interactions/slash-commands#messageinteraction)
+ * This is sent on the [Message] object when the message is a response to an [Interaction].
+ */
+@KordPreview
+class MessageInteraction(
+    val data: MessageInteractionData,
+    override val kord: Kord,
+    override val supplier: EntitySupplier = kord.defaultSupplier
+) : KordEntity, Strategizable {
+    /**
+     * [id][Interaction.id] of the [Interaction] this message is responding to.
+     */
+    override val id: Snowflake get() = data.id
+
+    /**
+     * the [name][ApplicationCommand.name] of the [ApplicationCommand] that triggered this message.
+     */
+    val name: String get() = data.name
+
+    /**
+     * The [UserBehavior] of the [user][Interaction.user] who invoked the [Interaction]
+     */
+    val user: UserBehavior get() = UserBehavior(data.user, kord)
+
+    /**
+     * the [InteractionType] of the interaction [MessageInteraction].
+     */
+    val type: InteractionType get() = data.type
+
+    /**
+     * Requests the [User] of this interaction message.
+     *
+     * @throws RequestException if something went wrong while retrieving the user.
+     * @throws EntityNotFoundException if the user was null.
+     */
+    suspend fun getUser(): User = supplier.getUser(user.id)
+
+    /**
+     * Requests to get the user of this interaction message,
+     * returns null if the [User] isn't present.
+     *
+     * @throws [RequestException] if anything went wrong during the request.
+     */
+    suspend fun getUserOrNull(): User? = supplier.getUserOrNull(user.id)
+
+    override fun withStrategy(strategy: EntitySupplyStrategy<*>): MessageInteraction {
+        return MessageInteraction(data, kord, strategy.supply(kord))
+    }
+}
diff --git a/core/src/main/kotlin/event/channel/ChannelPinsUpdateEvent.kt b/core/src/main/kotlin/event/channel/ChannelPinsUpdateEvent.kt
index f19b3652f91..875b0a1e40b 100644
--- a/core/src/main/kotlin/event/channel/ChannelPinsUpdateEvent.kt
+++ b/core/src/main/kotlin/event/channel/ChannelPinsUpdateEvent.kt
@@ -12,8 +12,8 @@ import dev.kord.core.supplier.EntitySupplier
 import dev.kord.core.supplier.EntitySupplyStrategy
 import dev.kord.core.supplier.getChannelOf
 import dev.kord.core.supplier.getChannelOfOrNull
-import dev.kord.core.toInstant
-import java.time.Instant
+import kotlinx.datetime.Instant
+import kotlinx.datetime.toInstant
 
 class ChannelPinsUpdateEvent(
     val data: ChannelPinsUpdateEventData,
diff --git a/core/src/main/kotlin/event/channel/TypingStartEvent.kt b/core/src/main/kotlin/event/channel/TypingStartEvent.kt
index cb04f29a75a..d44659a2a3c 100644
--- a/core/src/main/kotlin/event/channel/TypingStartEvent.kt
+++ b/core/src/main/kotlin/event/channel/TypingStartEvent.kt
@@ -18,7 +18,7 @@ import dev.kord.core.supplier.EntitySupplyStrategy
 import dev.kord.core.supplier.getChannelOf
 import dev.kord.core.supplier.getChannelOfOrNull
 import dev.kord.core.toInstant
-import java.time.Instant
+import kotlinx.datetime.Instant
 
 class TypingStartEvent(
     val data: TypingStartEventData,
diff --git a/core/src/main/kotlin/event/guild/InviteCreateEvent.kt b/core/src/main/kotlin/event/guild/InviteCreateEvent.kt
index 9d333f007c1..fb6329e7658 100644
--- a/core/src/main/kotlin/event/guild/InviteCreateEvent.kt
+++ b/core/src/main/kotlin/event/guild/InviteCreateEvent.kt
@@ -21,10 +21,9 @@ import dev.kord.core.supplier.EntitySupplier
 import dev.kord.core.supplier.EntitySupplyStrategy
 import dev.kord.core.supplier.getChannelOf
 import dev.kord.core.supplier.getChannelOfOrNull
-import dev.kord.core.toInstant
-import java.time.Instant
+import kotlinx.datetime.Instant
+import kotlinx.datetime.toInstant
 import kotlin.time.Duration
-import kotlin.time.seconds
 
 /**
  * Sent when a new invite to a channel is created.
@@ -87,7 +86,7 @@ class InviteCreateEvent(
     /**
      * How long the invite is valid for (in seconds).
      */
-    val maxAge: Duration get() = data.maxAge.seconds
+    val maxAge: Duration get() = Duration.seconds(data.maxAge)
 
     /**
      * The maximum number of times the invite can be used.
diff --git a/core/src/main/kotlin/event/guild/MemberUpdateEvent.kt b/core/src/main/kotlin/event/guild/MemberUpdateEvent.kt
index d82c6ead783..c42ce7a0811 100644
--- a/core/src/main/kotlin/event/guild/MemberUpdateEvent.kt
+++ b/core/src/main/kotlin/event/guild/MemberUpdateEvent.kt
@@ -9,7 +9,7 @@ import dev.kord.core.event.Event
 import dev.kord.core.supplier.EntitySupplier
 import dev.kord.core.supplier.EntitySupplyStrategy
 import kotlinx.coroutines.flow.Flow
-import java.time.Instant
+import kotlinx.datetime.Instant
 
 private const val deprecationMessage = "The full member is now available in this Event."
 
diff --git a/core/src/main/kotlin/exception/EntityNotFoundException.kt b/core/src/main/kotlin/exception/EntityNotFoundException.kt
index 4a6ca68aed2..39c45e34699 100644
--- a/core/src/main/kotlin/exception/EntityNotFoundException.kt
+++ b/core/src/main/kotlin/exception/EntityNotFoundException.kt
@@ -63,6 +63,9 @@ class EntityNotFoundException : Exception {
         fun welcomeScreenNotFound(guildId: Snowflake): Nothing =
             throw EntityNotFoundException("Welcome screen for guild $guildId was not found.")
 
+        fun stageInstanceNotFound(channelId: Snowflake): Nothing =
+            throw EntityNotFoundException("Stage instance for channel $channelId was not found")
+
     }
 
 }
\ No newline at end of file
diff --git a/core/src/main/kotlin/gateway/MasterGateway.kt b/core/src/main/kotlin/gateway/MasterGateway.kt
index 72b2ce1afe5..09c7fa93e11 100644
--- a/core/src/main/kotlin/gateway/MasterGateway.kt
+++ b/core/src/main/kotlin/gateway/MasterGateway.kt
@@ -25,10 +25,10 @@ class MasterGateway(
      */
     val averagePing
         get(): Duration? {
-            val pings = gateways.values.mapNotNull { it.ping.value?.inMicroseconds }
+            val pings = gateways.values.mapNotNull { it.ping.value?.inWholeMilliseconds }
             if (pings.isEmpty()) return null
 
-            return pings.average().microseconds
+            return Duration.microseconds(pings.average())
         }
 
 
diff --git a/core/src/main/kotlin/gateway/handler/GuildEventHandler.kt b/core/src/main/kotlin/gateway/handler/GuildEventHandler.kt
index 78c7dbb2dee..6fa5709330c 100644
--- a/core/src/main/kotlin/gateway/handler/GuildEventHandler.kt
+++ b/core/src/main/kotlin/gateway/handler/GuildEventHandler.kt
@@ -90,7 +90,7 @@ internal class GuildEventHandler(
         cache.put(data)
         event.guild.cache()
 
-        coreFlow.emit(GuildCreateEvent(Guild(data, kord), shard))
+        coreFlow.emit(GuildUpdateEvent(Guild(data, kord), shard))
     }
 
     private suspend fun handle(event: GuildDelete, shard: Int) = with(event.guild) {
diff --git a/core/src/main/kotlin/gateway/handler/MessageEventHandler.kt b/core/src/main/kotlin/gateway/handler/MessageEventHandler.kt
index dda8eb285ef..c3b73704762 100644
--- a/core/src/main/kotlin/gateway/handler/MessageEventHandler.kt
+++ b/core/src/main/kotlin/gateway/handler/MessageEventHandler.kt
@@ -1,5 +1,6 @@
 package dev.kord.core.gateway.handler
 
+import cache.data.MessageInteractionData
 import dev.kord.cache.api.DataCache
 import dev.kord.cache.api.put
 import dev.kord.cache.api.query
@@ -10,6 +11,7 @@ import dev.kord.core.cache.idEq
 import dev.kord.core.entity.Member
 import dev.kord.core.entity.Message
 import dev.kord.core.entity.ReactionEmoji
+import dev.kord.core.entity.interaction.MessageInteraction
 import dev.kord.core.event.message.*
 import dev.kord.core.gateway.MasterGateway
 import dev.kord.gateway.*
@@ -59,6 +61,12 @@ internal class MessageEventHandler(
             Member(memberData, userData, kord)
         } else null
 
+        //cache interaction user if present.
+        if(interaction is Optional.Value) {
+            val userData = UserData.from(interaction.value!!.user)
+            cache.put(userData)
+        }
+
         mentions.forEach {
             val user = UserData.from(it)
             cache.put(user)
diff --git a/core/src/main/kotlin/supplier/CacheEntitySupplier.kt b/core/src/main/kotlin/supplier/CacheEntitySupplier.kt
index 5f994729de5..351fd651fd3 100644
--- a/core/src/main/kotlin/supplier/CacheEntitySupplier.kt
+++ b/core/src/main/kotlin/supplier/CacheEntitySupplier.kt
@@ -272,6 +272,8 @@ class CacheEntitySupplier(private val kord: Kord) : EntitySupplier {
         }.asFlow().map { Template(it, kord) }
     }
 
+    override suspend fun getStageInstanceOrNull(channelId: Snowflake): StageInstance? = null
+
     override fun toString(): String {
         return "CacheEntitySupplier(cache=$cache)"
     }
diff --git a/core/src/main/kotlin/supplier/EntitySupplier.kt b/core/src/main/kotlin/supplier/EntitySupplier.kt
index 38dfae09b29..f059f4da729 100644
--- a/core/src/main/kotlin/supplier/EntitySupplier.kt
+++ b/core/src/main/kotlin/supplier/EntitySupplier.kt
@@ -1,5 +1,6 @@
 package dev.kord.core.supplier
 
+import dev.kord.common.entity.ChannelType.Unknown
 import dev.kord.common.entity.Snowflake
 import dev.kord.common.exception.RequestException
 import dev.kord.core.entity.*
@@ -8,7 +9,6 @@ import dev.kord.core.entity.channel.GuildChannel
 import dev.kord.core.entity.channel.MessageChannel
 import dev.kord.core.exception.EntityNotFoundException
 import kotlinx.coroutines.flow.Flow
-import dev.kord.common.entity.ChannelType.Unknown
 
 /**
  * An abstraction that allows for requesting Discord entities.
@@ -389,6 +389,11 @@ interface EntitySupplier {
         getTemplateOrNull(code) ?: EntityNotFoundException.templateNotFound(code)
 
     fun getTemplates(guildId: Snowflake): Flow<Template>
+
+    suspend fun getStageInstanceOrNull(channelId: Snowflake): StageInstance?
+
+    suspend fun getStageInstance(channelId: Snowflake): StageInstance =
+        getStageInstanceOrNull(channelId) ?: EntityNotFoundException.stageInstanceNotFound(channelId)
 }
 
 
diff --git a/core/src/main/kotlin/supplier/FallbackEntitySupplier.kt b/core/src/main/kotlin/supplier/FallbackEntitySupplier.kt
index 926fe395722..f352cf14de0 100644
--- a/core/src/main/kotlin/supplier/FallbackEntitySupplier.kt
+++ b/core/src/main/kotlin/supplier/FallbackEntitySupplier.kt
@@ -114,6 +114,8 @@ private class FallbackEntitySupplier(val first: EntitySupplier, val second: Enti
     override fun getTemplates(guildId: Snowflake): Flow<Template> =
         first.getTemplates(guildId).switchIfEmpty(second.getTemplates(guildId))
 
+    override suspend fun getStageInstanceOrNull(channelId: Snowflake): StageInstance? = first.getStageInstanceOrNull(channelId) ?: second.getStageInstanceOrNull(channelId)
+
 
     override fun toString(): String {
         return "FallbackEntitySupplier(first=$first, second=$second)"
diff --git a/core/src/main/kotlin/supplier/RestEntitySupplier.kt b/core/src/main/kotlin/supplier/RestEntitySupplier.kt
index cc573ca9bb0..27e079ad904 100644
--- a/core/src/main/kotlin/supplier/RestEntitySupplier.kt
+++ b/core/src/main/kotlin/supplier/RestEntitySupplier.kt
@@ -19,10 +19,7 @@ import dev.kord.rest.json.request.AuditLogGetRequest
 import dev.kord.rest.request.RestRequestException
 import dev.kord.rest.route.Position
 import dev.kord.rest.service.*
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.flow
-import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.flow.take
+import kotlinx.coroutines.flow.*
 import kotlin.contracts.ExperimentalContracts
 import kotlin.contracts.InvocationKind
 import kotlin.contracts.contract
@@ -74,8 +71,8 @@ class RestEntitySupplier(val kord: Kord) : EntitySupplier {
 
     override fun getGuildChannels(guildId: Snowflake): Flow<GuildChannel> = flow {
         for (channelData in guild.getGuildChannels(guildId))
-            emit(Channel.from(ChannelData.from(channelData), kord) as GuildChannel)
-    }
+            emit(Channel.from(ChannelData.from(channelData), kord))
+    }.filterIsInstance()
 
     override fun getChannelPins(channelId: Snowflake): Flow<Message> = flow {
         for (messageData in channel.getChannelPins(channelId))
@@ -333,6 +330,13 @@ class RestEntitySupplier(val kord: Kord) : EntitySupplier {
         auditLog.getAuditLogs(guildId, request.copy(before = it.value)).auditLogEntries
     }
 
+    override suspend fun getStageInstanceOrNull(channelId: Snowflake): StageInstance? = catchNotFound {
+        val instance = kord.rest.stageInstance.getStageInstance(channelId)
+        val data = StageInstanceData.from(instance)
+
+        return StageInstance(data, kord, this)
+    }
+
     override fun toString(): String {
         return "RestEntitySupplier(rest=${kord.rest})"
     }
diff --git a/core/src/test/kotlin/KordTest.kt b/core/src/test/kotlin/KordTest.kt
index a82ed4423b0..1b377e6928c 100644
--- a/core/src/test/kotlin/KordTest.kt
+++ b/core/src/test/kotlin/KordTest.kt
@@ -12,7 +12,7 @@ import java.util.concurrent.CountDownLatch
 internal class KordTest {
 
     @Test
-    @OptIn(KordExperimental::class)
+    @OptIn(KordExperimental::class, kotlinx.coroutines.DelicateCoroutinesApi::class)
     fun `Kord life cycle is correctly ended on shutdown`() {
         val kord = Kord.restOnly(System.getenv("KORD_TEST_TOKEN"))
         val lock = CountDownLatch(1)
diff --git a/core/src/test/kotlin/interaction/CommandTypesTest.kt b/core/src/test/kotlin/interaction/CommandTypesTest.kt
index f785894176e..47eb27f2042 100644
--- a/core/src/test/kotlin/interaction/CommandTypesTest.kt
+++ b/core/src/test/kotlin/interaction/CommandTypesTest.kt
@@ -2,8 +2,8 @@ package interaction
 
 import dev.kord.common.annotation.KordPreview
 import dev.kord.common.entity.ApplicationCommandOptionType
-import dev.kord.common.entity.DiscordApplicationCommandInteractionData
-import dev.kord.core.cache.data.ApplicationCommandInteractionData
+import dev.kord.common.entity.InteractionCallbackData
+import dev.kord.core.cache.data.ApplicationInteractionData
 import dev.kord.core.entity.interaction.*
 import kotlinx.serialization.json.*
 import mockKord
@@ -49,8 +49,8 @@ class CommandsTypeTests {
 
     @Test
     fun `Correctly infer RootCommand`() {
-        val serializedRoot = Json.decodeFromJsonElement(DiscordApplicationCommandInteractionData.serializer(), root)
-        val data = ApplicationCommandInteractionData.from(serializedRoot, null)
+        val serializedRoot = Json.decodeFromJsonElement(InteractionCallbackData.serializer(), root)
+        val data = ApplicationInteractionData.from(serializedRoot, null)
         val command = InteractionCommand(data, mockKord())
         assert(command is RootCommand)
         command as RootCommand
@@ -61,8 +61,8 @@ class CommandsTypeTests {
 
     @Test
     fun `Correctly infer subcommand`() {
-        val sub = Json.decodeFromJsonElement(DiscordApplicationCommandInteractionData.serializer(), subCommand)
-        val data = ApplicationCommandInteractionData.from(sub, null)
+        val sub = Json.decodeFromJsonElement(InteractionCallbackData.serializer(), subCommand)
+        val data = ApplicationInteractionData.from(sub, null)
         val command = InteractionCommand(data, mockKord())
         assert(command is SubCommand)
         command as SubCommand
@@ -74,8 +74,8 @@ class CommandsTypeTests {
 
     @Test
     fun `Correctly infer group`() {
-        val grouping = Json.decodeFromJsonElement(DiscordApplicationCommandInteractionData.serializer(), group)
-        val data = ApplicationCommandInteractionData.from(grouping, null)
+        val grouping = Json.decodeFromJsonElement(InteractionCallbackData.serializer(), group)
+        val data = ApplicationInteractionData.from(grouping, null)
         val command = InteractionCommand(data, mockKord())
         assert(command is GroupCommand)
         command as GroupCommand
diff --git a/core/src/test/kotlin/performance/KordEventDropTest.kt b/core/src/test/kotlin/performance/KordEventDropTest.kt
index 39542aa3970..19c1aa4dc77 100644
--- a/core/src/test/kotlin/performance/KordEventDropTest.kt
+++ b/core/src/test/kotlin/performance/KordEventDropTest.kt
@@ -14,10 +14,10 @@ import dev.kord.rest.request.KtorRequestHandler
 import dev.kord.rest.service.RestClient
 import io.ktor.client.*
 import kotlinx.coroutines.*
-import kotlinx.coroutines.channels.BroadcastChannel
-import kotlinx.coroutines.channels.Channel
-import kotlinx.coroutines.flow.*
-import java.time.Clock
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.datetime.Clock
 import java.util.concurrent.CountDownLatch
 import java.util.concurrent.atomic.AtomicInteger
 import kotlin.coroutines.CoroutineContext
@@ -25,7 +25,6 @@ import kotlin.coroutines.EmptyCoroutineContext
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.time.Duration
-import kotlin.time.minutes
 
 class KordEventDropTest {
 
@@ -47,13 +46,13 @@ class KordEventDropTest {
     }
 
     val kord = Kord(
-            resources = ClientResources("token", Shards(1), HttpClient(), EntitySupplyStrategy.cache, Intents.none),
-            cache = DataCache.none(),
-            MasterGateway(mapOf(0 to SpammyGateway)),
-            RestClient(KtorRequestHandler("token", clock = Clock.systemUTC())),
-            Snowflake("420"),
-            MutableSharedFlow(extraBufferCapacity = Int.MAX_VALUE),
-            Dispatchers.Default
+        resources = ClientResources("token", Shards(1), HttpClient(), EntitySupplyStrategy.cache, Intents.none),
+        cache = DataCache.none(),
+        MasterGateway(mapOf(0 to SpammyGateway)),
+        RestClient(KtorRequestHandler("token", clock = Clock.System)),
+        Snowflake("420"),
+        MutableSharedFlow(extraBufferCapacity = Int.MAX_VALUE),
+        Dispatchers.Default
     )
 
     @Test
@@ -85,7 +84,8 @@ class KordEventDropTest {
                         rulesChannelId = null,
                         vanityUrlCode = null,
                         banner = null,
-                        publicUpdatesChannelId = null
+                        publicUpdatesChannelId = null,
+                    nsfw = false
                 ), 0)
 
         val counter = AtomicInteger(0)
@@ -99,7 +99,7 @@ class KordEventDropTest {
             SpammyGateway.events.emit(event)
         }
 
-        withTimeout(1.minutes) {
+        withTimeout(Duration.minutes(1).inWholeMilliseconds) {
             countdown.await()
         }
         assertEquals(amount, counter.get())
diff --git a/core/src/test/kotlin/regression/CacheMissRegression.kt b/core/src/test/kotlin/regression/CacheMissRegression.kt
index 01a8bd89f40..e8678085b36 100644
--- a/core/src/test/kotlin/regression/CacheMissRegression.kt
+++ b/core/src/test/kotlin/regression/CacheMissRegression.kt
@@ -108,9 +108,7 @@ class CrashingHandler(val client: HttpClient) : RequestHandler {
 
         }.execute()
 
-        return parser.decodeFromString(request.route.strategy, response.readText())
-
-
+        return request.route.mapper.deserialize(parser, response.readText())
     }
 }
 
diff --git a/gateway/build.gradle.kts b/gateway/build.gradle.kts
index a0ab67a0fb0..28b7028a7c2 100644
--- a/gateway/build.gradle.kts
+++ b/gateway/build.gradle.kts
@@ -27,7 +27,6 @@ tasks.withType<KotlinCompile> {
     kotlinOptions {
         jvmTarget = Jvm.target
         freeCompilerArgs = listOf(
-                CompilerArguments.inlineClasses,
                 CompilerArguments.coroutines,
                 CompilerArguments.time,
                 CompilerArguments.optIn
diff --git a/gateway/src/main/kotlin/DefaultGateway.kt b/gateway/src/main/kotlin/DefaultGateway.kt
index 61ece591a80..b9813834ade 100644
--- a/gateway/src/main/kotlin/DefaultGateway.kt
+++ b/gateway/src/main/kotlin/DefaultGateway.kt
@@ -59,7 +59,6 @@ data class DefaultGatewayData(
 /**
  * The default Gateway implementation of Kord, using an [HttpClient] for the underlying webSocket
  */
-@ObsoleteCoroutinesApi
 class DefaultGateway(private val data: DefaultGatewayData) : Gateway {
 
     override val coroutineContext: CoroutineContext = data.dispatcher + SupervisorJob()
diff --git a/gateway/src/main/kotlin/DefaultGatewayBuilder.kt b/gateway/src/main/kotlin/DefaultGatewayBuilder.kt
index f4d521a0533..5305a78640e 100644
--- a/gateway/src/main/kotlin/DefaultGatewayBuilder.kt
+++ b/gateway/src/main/kotlin/DefaultGatewayBuilder.kt
@@ -15,6 +15,7 @@ import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.ObsoleteCoroutinesApi
 import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlin.time.Duration
 import kotlin.time.seconds
 
 class DefaultGatewayBuilder {
@@ -32,9 +33,9 @@ class DefaultGatewayBuilder {
             install(WebSockets)
             install(JsonFeature)
         }
-        val retry = reconnectRetry ?: LinearRetry(2.seconds, 20.seconds, 10)
-        val sendRateLimiter = sendRateLimiter ?: BucketRateLimiter(120, 60.seconds)
-        val identifyRateLimiter = identifyRateLimiter ?: BucketRateLimiter(1, 5.seconds)
+        val retry = reconnectRetry ?: LinearRetry(Duration.seconds(2), Duration.seconds(20), 10)
+        val sendRateLimiter = sendRateLimiter ?: BucketRateLimiter(120, Duration.seconds(60))
+        val identifyRateLimiter = identifyRateLimiter ?: BucketRateLimiter(1, Duration.seconds(5))
 
         client.requestPipeline.intercept(HttpRequestPipeline.Render) {
             // CIO adds this header even if no extensions are used, which causes it to be empty
diff --git a/gateway/src/main/kotlin/Event.kt b/gateway/src/main/kotlin/Event.kt
index 4fea9685a83..5e94a94f951 100644
--- a/gateway/src/main/kotlin/Event.kt
+++ b/gateway/src/main/kotlin/Event.kt
@@ -8,10 +8,7 @@ import dev.kord.common.entity.optional.OptionalSnowflake
 import kotlinx.serialization.*
 import kotlinx.serialization.builtins.nullable
 import kotlinx.serialization.builtins.serializer
-import kotlinx.serialization.descriptors.PrimitiveKind
-import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
-import kotlinx.serialization.descriptors.SerialDescriptor
-import kotlinx.serialization.descriptors.buildClassSerialDescriptor
+import kotlinx.serialization.descriptors.*
 import kotlinx.serialization.encoding.CompositeDecoder
 import kotlinx.serialization.encoding.Decoder
 import kotlinx.serialization.encoding.Encoder
@@ -31,6 +28,9 @@ private object NullDecoder : DeserializationStrategy<Nothing?> {
 
     @OptIn(ExperimentalSerializationApi::class)
     override fun deserialize(decoder: Decoder): Nothing? {
+        // decodeNull() doesn't consume the literal null therefore parsing doesn't end and in e.g. a heartbeat event
+        // the null gets parsed as a key
+        decoder.decodeNotNullMark()
         return decoder.decodeNull()
     }
 
diff --git a/gateway/src/main/kotlin/builder/PresenceBuilder.kt b/gateway/src/main/kotlin/builder/PresenceBuilder.kt
index bcf66338f43..9b4756036bc 100644
--- a/gateway/src/main/kotlin/builder/PresenceBuilder.kt
+++ b/gateway/src/main/kotlin/builder/PresenceBuilder.kt
@@ -7,7 +7,7 @@ import dev.kord.common.entity.DiscordBotActivity
 import dev.kord.common.entity.optional.Optional
 import dev.kord.gateway.DiscordPresence
 import dev.kord.gateway.UpdateStatus
-import java.time.Instant
+import kotlinx.datetime.Instant
 
 @KordDsl
 class PresenceBuilder {
@@ -36,7 +36,7 @@ class PresenceBuilder {
         game = DiscordBotActivity(name, ActivityType.Competing)
     }
 
-    fun toUpdateStatus(): UpdateStatus = UpdateStatus(since?.toEpochMilli(), game?.let(::listOf).orEmpty(), status, afk)
+    fun toUpdateStatus(): UpdateStatus = UpdateStatus(since?.toEpochMilliseconds(), game?.let(::listOf).orEmpty(), status, afk)
 
-    fun toPresence(): DiscordPresence = DiscordPresence(status, afk, since?.toEpochMilli(), game)
+    fun toPresence(): DiscordPresence = DiscordPresence(status, afk, since?.toEpochMilliseconds(), game)
 }
\ No newline at end of file
diff --git a/gateway/src/main/kotlin/handler/HeartbeatHandler.kt b/gateway/src/main/kotlin/handler/HeartbeatHandler.kt
index 0f057a9738c..6e85bcdef94 100644
--- a/gateway/src/main/kotlin/handler/HeartbeatHandler.kt
+++ b/gateway/src/main/kotlin/handler/HeartbeatHandler.kt
@@ -5,9 +5,11 @@ import kotlinx.atomicfu.atomic
 import kotlinx.atomicfu.update
 import kotlinx.coroutines.ObsoleteCoroutinesApi
 import kotlinx.coroutines.flow.Flow
-import kotlin.time.*
+import kotlin.time.Duration
+import kotlin.time.TimeMark
+import kotlin.time.TimeSource
 
-@ObsoleteCoroutinesApi
+@OptIn(ObsoleteCoroutinesApi::class)
 internal class HeartbeatHandler(
     flow: Flow<Event>,
     private val send: suspend (Command) -> Unit,
diff --git a/gateway/src/main/kotlin/retry/LinearRetry.kt b/gateway/src/main/kotlin/retry/LinearRetry.kt
index bcbfd080b50..dcf08181681 100644
--- a/gateway/src/main/kotlin/retry/LinearRetry.kt
+++ b/gateway/src/main/kotlin/retry/LinearRetry.kt
@@ -22,15 +22,12 @@ class LinearRetry constructor(
     private val maxTries: Int
 ) : Retry {
 
-    constructor(firstBackoffMillis: Long, maxBackoffMillis: Long, maxTries: Int) :
-            this(firstBackoffMillis.milliseconds, maxBackoffMillis.milliseconds, maxTries)
-
     init {
-        require(firstBackoff.isPositive()) { "firstBackoff needs to be positive but was ${firstBackoff.toLongMilliseconds()} ms" }
-        require(maxBackoff.isPositive()) { "maxBackoff needs to be positive but was ${maxBackoff.toLongMilliseconds()} ms" }
+        require(firstBackoff.isPositive()) { "firstBackoff needs to be positive but was ${firstBackoff.inWholeMilliseconds} ms" }
+        require(maxBackoff.isPositive()) { "maxBackoff needs to be positive but was ${maxBackoff.inWholeMilliseconds} ms" }
         require(
             maxBackoff.minus(firstBackoff).isPositive()
-        ) { "maxBackoff ${maxBackoff.toLongMilliseconds()} ms needs to be bigger than firstBackoff ${firstBackoff.toLongMilliseconds()} ms" }
+        ) { "maxBackoff ${maxBackoff.inWholeMilliseconds} ms needs to be bigger than firstBackoff ${firstBackoff.inWholeMilliseconds} ms" }
         require(maxTries > 0) { "maxTries needs to be positive but was $maxTries" }
     }
 
@@ -47,7 +44,7 @@ class LinearRetry constructor(
         if (!hasNext) error("max retries exceeded")
 
         tries.incrementAndGet()
-        var diff = (maxBackoff - firstBackoff).toLongMilliseconds() / maxTries
+        var diff = (maxBackoff - firstBackoff).inWholeMilliseconds / maxTries
         diff *= tries.value
         linearRetryLogger.trace { "retry attempt ${tries.value}, delaying for $diff ms" }
         delay(diff)
diff --git a/gateway/src/samples/kotlin/EventListener.kt b/gateway/src/samples/kotlin/EventListener.kt
index 3497ac46fea..be089651b22 100644
--- a/gateway/src/samples/kotlin/EventListener.kt
+++ b/gateway/src/samples/kotlin/EventListener.kt
@@ -2,23 +2,21 @@ import dev.kord.common.entity.*
 import dev.kord.common.ratelimit.BucketRateLimiter
 import dev.kord.gateway.*
 import dev.kord.gateway.retry.LinearRetry
-import io.ktor.client.HttpClient
-import io.ktor.client.engine.cio.CIO
-import io.ktor.client.features.json.JsonFeature
+import io.ktor.client.*
+import io.ktor.client.engine.cio.*
+import io.ktor.client.features.json.*
 import io.ktor.client.features.json.serializer.*
-import io.ktor.client.features.websocket.WebSockets
-import io.ktor.util.KtorExperimentalAPI
+import io.ktor.client.features.websocket.*
 import kotlinx.coroutines.*
 import kotlinx.coroutines.flow.filterIsInstance
 import kotlinx.coroutines.flow.flowOn
 import kotlinx.coroutines.flow.launchIn
 import kotlinx.coroutines.flow.onEach
 import kotlinx.serialization.json.Json
-import java.time.Duration
+import kotlin.time.Duration
 import kotlin.time.ExperimentalTime
-import kotlin.time.seconds
-import kotlin.time.toKotlinDuration
 
+@OptIn(DelicateCoroutinesApi::class)
 @FlowPreview
 @ExperimentalTime
 @ExperimentalCoroutinesApi
@@ -34,8 +32,8 @@ suspend fun main(args: Array<String>) {
             }
         }
 
-        reconnectRetry = LinearRetry(2.seconds, 20.seconds, 10)
-        sendRateLimiter = BucketRateLimiter(120, Duration.ofSeconds(60).toKotlinDuration())
+        reconnectRetry = LinearRetry(Duration.seconds(2), Duration.seconds(20), 10)
+        sendRateLimiter = BucketRateLimiter(120, Duration.seconds(60))
     }
 
     gateway.events.filterIsInstance<MessageCreate>().flowOn(Dispatchers.Default).onEach {
@@ -59,7 +57,7 @@ suspend fun main(args: Array<String>) {
                     afk = false,
                     activities = listOf(
                         DiscordBotActivity(
-                            "Ping is ${gateway.ping.value?.toLongMilliseconds()}",
+                            "Ping is ${gateway.ping.value?.inWholeMilliseconds}",
                             ActivityType.Game
                         )
                     ),
diff --git a/gateway/src/test/kotlin/gateway/DefaultGatewayTest.kt b/gateway/src/test/kotlin/gateway/DefaultGatewayTest.kt
index 2f1476500c4..77409ea5dd4 100644
--- a/gateway/src/test/kotlin/gateway/DefaultGatewayTest.kt
+++ b/gateway/src/test/kotlin/gateway/DefaultGatewayTest.kt
@@ -20,16 +20,15 @@ import kotlinx.coroutines.flow.onEach
 import kotlinx.serialization.json.Json
 import org.junit.jupiter.api.Disabled
 import org.junit.jupiter.api.Test
-import java.time.Duration
 import kotlin.time.ExperimentalTime
-import kotlin.time.seconds
-import kotlin.time.toKotlinDuration
+import kotlin.time.Duration as KDuration
 
 @FlowPreview
 @KtorExperimentalAPI
 @ObsoleteCoroutinesApi
 @ExperimentalCoroutinesApi
 class DefaultGatewayTest {
+    @OptIn(DelicateCoroutinesApi::class)
     @Test
     @Disabled
     @ExperimentalTime
@@ -44,8 +43,8 @@ class DefaultGatewayTest {
                 }
             }
 
-            reconnectRetry = LinearRetry(2.seconds, 20.seconds, 10)
-            sendRateLimiter = BucketRateLimiter(120, Duration.ofSeconds(60).toKotlinDuration())
+            reconnectRetry = LinearRetry(KDuration.seconds(2), KDuration.seconds(20), 10)
+            sendRateLimiter = BucketRateLimiter(120, KDuration.seconds(60))
         }
 
         gateway.events.filterIsInstance<MessageCreate>().flowOn(Dispatchers.Default).onEach {
@@ -57,7 +56,7 @@ class DefaultGatewayTest {
                 "!status" -> when (words.getOrNull(1)) {
                     "playing" -> gateway.send(UpdateStatus(status = PresenceStatus.Online, afk = false, activities = listOf(DiscordBotActivity("Kord", ActivityType.Game)), since = null))
                 }
-                "!ping" -> gateway.send(UpdateStatus(status = PresenceStatus.Online, afk = false, activities = listOf(DiscordBotActivity("Ping is ${gateway.ping.value?.toLongMilliseconds()}", ActivityType.Game)), since = null))
+                "!ping" -> gateway.send(UpdateStatus(status = PresenceStatus.Online, afk = false, activities = listOf(DiscordBotActivity("Ping is ${gateway.ping.value?.inWholeMilliseconds}", ActivityType.Game)), since = null))
             }
         }.launchIn(GlobalScope)
 
diff --git a/gateway/src/test/kotlin/json/CommandTest.kt b/gateway/src/test/kotlin/json/CommandTest.kt
index 9d0775392ec..45562e2233b 100644
--- a/gateway/src/test/kotlin/json/CommandTest.kt
+++ b/gateway/src/test/kotlin/json/CommandTest.kt
@@ -14,6 +14,7 @@ import dev.kord.gateway.*
 import kotlinx.serialization.json.*
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Test
+import java.util.*
 
 private val json = Json { encodeDefaults = false }
 
@@ -61,7 +62,10 @@ class CommandTest {
         val query = "test"
         val limit = 1337
 
-        val request = json.encodeToString(Command.Companion, RequestGuildMembers(Snowflake(guildId), query.optional(), OptionalInt.Value(limit)))
+        val request = json.encodeToString(
+            Command.Companion,
+            RequestGuildMembers(Snowflake(guildId), query.optional(), OptionalInt.Value(limit))
+        )
 
         val json = json.encodeToString(JsonObject.serializer(), buildJsonObject {
             put("op", OpCode.RequestGuildMembers.code)
@@ -83,7 +87,10 @@ class CommandTest {
         val selfMute = true
         val selfDeaf = false
 
-        val status = json.encodeToString(Command.Companion, UpdateVoiceStatus(Snowflake(guildId), Snowflake(channelId), selfMute, selfDeaf))
+        val status = json.encodeToString(
+            Command.Companion,
+            UpdateVoiceStatus(Snowflake(guildId), Snowflake(channelId), selfMute, selfDeaf)
+        )
 
         val json = json.encodeToString(JsonObject.serializer(), buildJsonObject {
             put("op", OpCode.VoiceStateUpdate.code)
@@ -112,8 +119,8 @@ class CommandTest {
             put("op", OpCode.StatusUpdate.code)
             put("d", buildJsonObject {
                 put("since", since)
-                put("activities", buildJsonArray {  })
-                put("status", status.value.toLowerCase())
+                put("activities", JsonArray(emptyList()))
+                put("status", status.value.lowercase(Locale.getDefault()))
                 put("afk", afk)
             })
         })
@@ -133,8 +140,16 @@ class CommandTest {
         val presence: DiscordPresence? = null
 
         val identify = json.encodeToString(
-                Command.Companion,
-                Identify(token, properties, compress.optional(), largeThreshold.optionalInt(), shard.optional(), presence.optional().coerceToMissing(), Intents.all)
+            Command.Companion,
+            Identify(
+                token,
+                properties,
+                compress.optional(),
+                largeThreshold.optionalInt(),
+                shard.optional(),
+                presence.optional().coerceToMissing(),
+                Intents.all
+            )
         )
 
         val json = json.encodeToString(JsonObject.serializer(), buildJsonObject {
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index 3758bba6e0e..851d0ca6f70 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,5 +1,5 @@
 #Tue Dec 31 15:02:18 CET 2019
-distributionUrl=https\://services.gradle.org/distributions/gradle-6.6-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.0-all.zip
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStorePath=wrapper/dists
diff --git a/rest/build.gradle.kts b/rest/build.gradle.kts
index 05e21b43a7f..7fa8ed96913 100644
--- a/rest/build.gradle.kts
+++ b/rest/build.gradle.kts
@@ -28,7 +28,6 @@ tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile> {
     kotlinOptions {
         jvmTarget = Jvm.target
         freeCompilerArgs = listOf(
-                CompilerArguments.inlineClasses,
                 CompilerArguments.coroutines,
                 CompilerArguments.time,
                 CompilerArguments.optIn
diff --git a/rest/src/main/kotlin/builder/components/ActionRowBuilder.kt b/rest/src/main/kotlin/builder/components/ActionRowBuilder.kt
new file mode 100644
index 00000000000..3a3f40664a7
--- /dev/null
+++ b/rest/src/main/kotlin/builder/components/ActionRowBuilder.kt
@@ -0,0 +1,55 @@
+package dev.kord.rest.builder.components
+
+import dev.kord.common.annotation.KordDsl
+import dev.kord.common.annotation.KordPreview
+import dev.kord.common.entity.ButtonStyle
+import dev.kord.common.entity.ComponentType
+import dev.kord.common.entity.DiscordComponent
+import dev.kord.common.entity.optional.Optional
+import kotlin.contracts.ExperimentalContracts
+import kotlin.contracts.InvocationKind
+import kotlin.contracts.contract
+
+@KordDsl
+@KordPreview
+class ActionRowBuilder : MessageComponentBuilder {
+    val components = mutableListOf<ActionRowComponentBuilder>()
+
+    @OptIn(ExperimentalContracts::class)
+    inline fun interactionButton(
+        style: ButtonStyle,
+        customId: String,
+        builder: ButtonBuilder.InteractionButtonBuilder.() -> Unit
+    ) {
+        contract {
+            callsInPlace(builder, InvocationKind.EXACTLY_ONCE)
+        }
+
+        components.add(ButtonBuilder.InteractionButtonBuilder()
+            .apply {
+                this.style = style
+                this.customId = customId
+            }
+            .apply(builder))
+    }
+
+    @OptIn(ExperimentalContracts::class)
+    inline fun linkButton(label: String, url: String, builder: ButtonBuilder.LinkButtonBuilder.() -> Unit = {}) {
+        contract {
+            callsInPlace(builder, InvocationKind.EXACTLY_ONCE)
+        }
+
+        components.add(ButtonBuilder.LinkButtonBuilder()
+            .apply {
+                this.url = url
+                this.label = label
+            }
+            .apply(builder))
+    }
+
+    override fun build(): DiscordComponent =
+        DiscordComponent(
+            ComponentType.ActionRow,
+            components = Optional.missingOnEmpty(components.map(ActionRowComponentBuilder::build))
+        )
+}
diff --git a/rest/src/main/kotlin/builder/components/ActionRowContainerBuilder.kt b/rest/src/main/kotlin/builder/components/ActionRowContainerBuilder.kt
new file mode 100644
index 00000000000..9d983ca0794
--- /dev/null
+++ b/rest/src/main/kotlin/builder/components/ActionRowContainerBuilder.kt
@@ -0,0 +1,23 @@
+package dev.kord.rest.builder.components
+
+import dev.kord.common.annotation.KordDsl
+import dev.kord.common.annotation.KordPreview
+import dev.kord.common.entity.DiscordComponent
+import kotlin.contracts.ExperimentalContracts
+import kotlin.contracts.InvocationKind
+import kotlin.contracts.contract
+
+@KordDsl
+@KordPreview
+class ActionRowContainerBuilder {
+    val components = mutableListOf<ActionRowBuilder>()
+
+    @OptIn(ExperimentalContracts::class)
+    inline fun actionRow(builder: ActionRowBuilder.() -> Unit = {}) {
+        contract {
+            callsInPlace(builder, InvocationKind.EXACTLY_ONCE)
+        }
+
+        components.add(ActionRowBuilder().apply(builder))
+    }
+}
diff --git a/rest/src/main/kotlin/builder/components/ButtonBuilder.kt b/rest/src/main/kotlin/builder/components/ButtonBuilder.kt
new file mode 100644
index 00000000000..ef10e6cb218
--- /dev/null
+++ b/rest/src/main/kotlin/builder/components/ButtonBuilder.kt
@@ -0,0 +1,46 @@
+package dev.kord.rest.builder.components
+
+import dev.kord.common.annotation.KordDsl
+import dev.kord.common.annotation.KordPreview
+import dev.kord.common.entity.ButtonStyle
+import dev.kord.common.entity.ComponentType
+import dev.kord.common.entity.DiscordComponent
+import dev.kord.common.entity.DiscordPartialEmoji
+import dev.kord.common.entity.optional.Optional
+import dev.kord.common.entity.optional.OptionalBoolean
+import dev.kord.common.entity.optional.delegate.delegate
+import dev.kord.common.entity.optional.optional
+import kotlin.contracts.ExperimentalContracts
+import kotlin.contracts.InvocationKind
+import kotlin.contracts.contract
+
+@KordDsl
+@KordPreview
+sealed class ButtonBuilder : ActionRowComponentBuilder {
+
+    @PublishedApi
+    internal open var _style: Optional<ButtonStyle> = Optional.Missing()
+    private var _label: Optional<String> = Optional.Missing()
+    var label by ::_label.delegate()
+    private var _emoji: Optional<DiscordPartialEmoji> = Optional.Missing()
+    var emoji by ::_emoji.delegate()
+    internal var _customId: Optional<String> = Optional.Missing()
+    internal var _url: Optional<String> = Optional.Missing()
+    private var _disabled: OptionalBoolean = OptionalBoolean.Missing
+    var disabled by ::_disabled.delegate()
+
+
+    class InteractionButtonBuilder : ButtonBuilder() {
+        var style by ::_style.delegate()
+        var customId by ::_customId.delegate()
+    }
+
+    class LinkButtonBuilder : ButtonBuilder() {
+        var url by ::_url.delegate()
+        override var _style: Optional<ButtonStyle> = ButtonStyle.Link.optional()
+    }
+
+    override fun build(): DiscordComponent = DiscordComponent(
+        ComponentType.Button, _style, _label, _emoji, _customId, _url, _disabled
+    )
+}
diff --git a/rest/src/main/kotlin/builder/components/ComponentBuilders.kt b/rest/src/main/kotlin/builder/components/ComponentBuilders.kt
new file mode 100644
index 00000000000..2f842d0af55
--- /dev/null
+++ b/rest/src/main/kotlin/builder/components/ComponentBuilders.kt
@@ -0,0 +1,15 @@
+package dev.kord.rest.builder.components
+
+import dev.kord.common.annotation.KordPreview
+import dev.kord.common.entity.DiscordComponent
+
+@KordPreview
+sealed interface ComponentBuilder {
+    fun build(): DiscordComponent
+}
+
+@KordPreview
+sealed interface ActionRowComponentBuilder : ComponentBuilder
+
+@KordPreview
+sealed interface MessageComponentBuilder : ComponentBuilder
diff --git a/rest/src/main/kotlin/builder/guild/VoiceStateModifyBuilder.kt b/rest/src/main/kotlin/builder/guild/VoiceStateModifyBuilder.kt
index 0b48f486ad6..bd22e803bff 100644
--- a/rest/src/main/kotlin/builder/guild/VoiceStateModifyBuilder.kt
+++ b/rest/src/main/kotlin/builder/guild/VoiceStateModifyBuilder.kt
@@ -8,7 +8,7 @@ import dev.kord.common.entity.optional.map
 import dev.kord.rest.builder.RequestBuilder
 import dev.kord.rest.json.request.CurrentVoiceStateModifyRequest
 import dev.kord.rest.json.request.VoiceStateModifyRequest
-import java.time.Instant
+import kotlinx.datetime.Instant
 
 class CurrentVoiceStateModifyBuilder(val channelId: Snowflake) : RequestBuilder<CurrentVoiceStateModifyRequest> {
 
diff --git a/rest/src/main/kotlin/builder/interaction/FollowupMessageBuilders.kt b/rest/src/main/kotlin/builder/interaction/FollowupMessageBuilders.kt
index ace68b1b35c..51796c16d25 100644
--- a/rest/src/main/kotlin/builder/interaction/FollowupMessageBuilders.kt
+++ b/rest/src/main/kotlin/builder/interaction/FollowupMessageBuilders.kt
@@ -2,16 +2,21 @@ package dev.kord.rest.builder.interaction
 
 import dev.kord.common.annotation.KordDsl
 import dev.kord.common.annotation.KordPreview
-import dev.kord.common.entity.AllowedMentions
 import dev.kord.common.entity.optional.Optional
 import dev.kord.common.entity.optional.OptionalBoolean
 import dev.kord.common.entity.optional.delegate.delegate
 import dev.kord.common.entity.optional.map
 import dev.kord.common.entity.optional.mapList
 import dev.kord.rest.builder.RequestBuilder
+import dev.kord.rest.builder.components.ActionRowBuilder
+import dev.kord.rest.builder.components.MessageComponentBuilder
 import dev.kord.rest.builder.message.AllowedMentionsBuilder
 import dev.kord.rest.builder.message.EmbedBuilder
-import dev.kord.rest.json.request.*
+import dev.kord.rest.json.request.EmbedRequest
+import dev.kord.rest.json.request.FollowupMessageCreateRequest
+import dev.kord.rest.json.request.FollowupMessageModifyRequest
+import dev.kord.rest.json.request.MultipartFollowupMessageCreateRequest
+import dev.kord.rest.json.request.MultipartFollowupMessageModifyRequest
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
 import java.io.InputStream
@@ -37,6 +42,9 @@ class PublicFollowupMessageModifyBuilder :
     private var _allowedMentions: Optional<AllowedMentionsBuilder> = Optional.Missing()
     var allowedMentions: AllowedMentionsBuilder? by ::_allowedMentions.delegate()
 
+    @KordPreview
+    val components: MutableList<MessageComponentBuilder> = mutableListOf()
+
     @OptIn(ExperimentalContracts::class)
     inline fun embed(builder: EmbedBuilder.() -> Unit) {
         contract { callsInPlace(builder, InvocationKind.EXACTLY_ONCE) }
@@ -44,6 +52,16 @@ class PublicFollowupMessageModifyBuilder :
         embeds!! += EmbedBuilder().apply(builder)
     }
 
+    @OptIn(ExperimentalContracts::class)
+    @KordPreview
+    inline fun actionRow(builder: ActionRowBuilder.() -> Unit) {
+        contract {
+            callsInPlace(builder, InvocationKind.EXACTLY_ONCE)
+        }
+
+        components.add(ActionRowBuilder().apply(builder))
+    }
+
 
     fun addFile(name: String, content: InputStream) {
         files += name to content
@@ -70,7 +88,8 @@ class PublicFollowupMessageModifyBuilder :
             FollowupMessageModifyRequest(
                 _content,
                 _embeds.mapList { it.toRequest() },
-                _allowedMentions.map { it.build() }
+                _allowedMentions.map { it.build() },
+                Optional.missingOnEmpty(components.map(MessageComponentBuilder::build))
             ),
             files
         )
@@ -91,6 +110,8 @@ class EphemeralFollowupMessageModifyBuilder :
     private var _allowedMentions: Optional<AllowedMentionsBuilder> = Optional.Missing()
     var allowedMentions: AllowedMentionsBuilder? by ::_allowedMentions.delegate()
 
+    val components: MutableList<MessageComponentBuilder> = mutableListOf()
+
 
     /**
      * Configures the mentions that should trigger a mention (aka ping). Not calling this function will result in the default behavior
@@ -106,7 +127,8 @@ class EphemeralFollowupMessageModifyBuilder :
     override fun toRequest(): FollowupMessageModifyRequest {
         return FollowupMessageModifyRequest(
             content = _content,
-            allowedMentions = _allowedMentions.map { it.build() }
+            allowedMentions = _allowedMentions.map { it.build() },
+            components = Optional.missingOnEmpty(components.map(MessageComponentBuilder::build))
         )
     }
 }
@@ -129,6 +151,8 @@ class PublicFollowupMessageCreateBuilder : RequestBuilder<MultipartFollowupMessa
     val files: MutableList<Pair<String, InputStream>> = mutableListOf()
     var embeds: MutableList<EmbedRequest> = mutableListOf()
 
+    val components: MutableList<MessageComponentBuilder> = mutableListOf()
+
     fun addFile(name: String, content: InputStream) {
         files += name to content
     }
@@ -162,7 +186,8 @@ class PublicFollowupMessageCreateBuilder : RequestBuilder<MultipartFollowupMessa
                 content = _content,
                 tts = _tts,
                 embeds = Optional.missingOnEmpty(embeds),
-                allowedMentions = _allowedMentions.map { it.build() }
+                allowedMentions = _allowedMentions.map { it.build() },
+                components = Optional.missingOnEmpty(components.map(MessageComponentBuilder::build))
             ),
             files,
         )
@@ -192,12 +217,15 @@ class EphemeralFollowupMessageCreateBuilder(var content: String) :
         allowedMentions = (allowedMentions ?: AllowedMentionsBuilder()).apply(block)
     }
 
+    val components: MutableList<MessageComponentBuilder> = mutableListOf()
+
     override fun toRequest(): MultipartFollowupMessageCreateRequest =
         MultipartFollowupMessageCreateRequest(
             FollowupMessageCreateRequest(
                 content = Optional.Value(content),
                 tts = _tts,
-                allowedMentions = _allowedMentions.map { it.build() }
+                allowedMentions = _allowedMentions.map { it.build() },
+                components = Optional.missingOnEmpty(components.map(MessageComponentBuilder::build))
             ),
         )
 
diff --git a/rest/src/main/kotlin/builder/interaction/PublicInteractionBuilder.kt b/rest/src/main/kotlin/builder/interaction/PublicInteractionBuilder.kt
index 2591263c095..0a28859abf7 100644
--- a/rest/src/main/kotlin/builder/interaction/PublicInteractionBuilder.kt
+++ b/rest/src/main/kotlin/builder/interaction/PublicInteractionBuilder.kt
@@ -2,11 +2,14 @@ package dev.kord.rest.builder.interaction
 
 import dev.kord.common.annotation.KordDsl
 import dev.kord.common.annotation.KordPreview
-import dev.kord.common.entity.AllowedMentions
+import dev.kord.common.entity.DiscordComponent
 import dev.kord.common.entity.InteractionResponseType
 import dev.kord.common.entity.optional.*
 import dev.kord.common.entity.optional.delegate.delegate
 import dev.kord.rest.builder.RequestBuilder
+import dev.kord.rest.builder.components.ActionRowBuilder
+import dev.kord.rest.builder.components.ActionRowContainerBuilder
+import dev.kord.rest.builder.components.MessageComponentBuilder
 import dev.kord.rest.builder.message.AllowedMentionsBuilder
 import dev.kord.rest.builder.message.EmbedBuilder
 import dev.kord.rest.json.request.*
@@ -36,6 +39,9 @@ class PublicInteractionResponseCreateBuilder :
     private var _tts: OptionalBoolean = OptionalBoolean.Missing
     var tts: Boolean? by ::_tts.delegate()
 
+    @KordPreview
+    val components: MutableList<MessageComponentBuilder> = mutableListOf()
+
     val files: MutableList<Pair<String, InputStream>> = mutableListOf()
 
 
@@ -58,6 +64,16 @@ class PublicInteractionResponseCreateBuilder :
         embeds!! += EmbedBuilder().apply(builder)
     }
 
+    @OptIn(ExperimentalContracts::class)
+    @KordPreview
+    inline fun actionRow(builder: ActionRowBuilder.() -> Unit) {
+        contract {
+            callsInPlace(builder, InvocationKind.EXACTLY_ONCE)
+        }
+
+        components.add(ActionRowBuilder().apply(builder))
+    }
+
     fun addFile(name: String, content: InputStream) {
         files += name to content
     }
@@ -102,6 +118,8 @@ class PublicInteractionResponseModifyBuilder :
 
     val files: MutableList<Pair<String, InputStream>> = mutableListOf()
 
+    val components: MutableList<MessageComponentBuilder> = mutableListOf()
+
     /**
      * Configures the mentions that should trigger a mention (aka ping). Not calling this function will result in the default behavior
      * (ping everything), calling this function but not configuring it before the request is build will result in all
@@ -126,6 +144,16 @@ class PublicInteractionResponseModifyBuilder :
         files += name to content
     }
 
+    @OptIn(ExperimentalContracts::class)
+    @KordPreview
+    inline fun actionRow(builder: ActionRowBuilder.() -> Unit) {
+        contract {
+            callsInPlace(builder, InvocationKind.EXACTLY_ONCE)
+        }
+
+        components.add(ActionRowBuilder().apply(builder))
+    }
+
     suspend fun addFile(path: Path) = withContext(Dispatchers.IO) {
         addFile(path.fileName.toString(), Files.newInputStream(path))
     }
@@ -136,6 +164,7 @@ class PublicInteractionResponseModifyBuilder :
                 content = _content,
                 embeds = _embeds.mapList { it.toRequest() },
                 allowedMentions = _allowedMentions.map { it.build() },
+                components = Optional.missingOnEmpty(components.map(MessageComponentBuilder::build))
             ),
             files
         )
diff --git a/rest/src/main/kotlin/builder/message/EmbedBuilder.kt b/rest/src/main/kotlin/builder/message/EmbedBuilder.kt
index cb854b44432..1f807a1324a 100644
--- a/rest/src/main/kotlin/builder/message/EmbedBuilder.kt
+++ b/rest/src/main/kotlin/builder/message/EmbedBuilder.kt
@@ -9,8 +9,7 @@ import dev.kord.common.entity.optional.map
 import dev.kord.common.entity.optional.mapList
 import dev.kord.rest.builder.RequestBuilder
 import dev.kord.rest.json.request.*
-import java.time.Instant
-import java.time.format.DateTimeFormatter
+import kotlinx.datetime.Instant
 
 /**
  * A builder for discord embeds.
@@ -152,7 +151,7 @@ class EmbedBuilder : RequestBuilder<EmbedRequest> {
         Optional.Value("embed"),
         _description,
         _url,
-        _timestamp.map { DateTimeFormatter.ISO_INSTANT.format(it) },
+        _timestamp.map { it.toString() },
         _color,
         _footer.map { it.toRequest() },
         _image.map { EmbedImageRequest(it) },
diff --git a/rest/src/main/kotlin/builder/message/MessageCreateBuilder.kt b/rest/src/main/kotlin/builder/message/MessageCreateBuilder.kt
index 2485190ca5f..127e0a2dd5c 100644
--- a/rest/src/main/kotlin/builder/message/MessageCreateBuilder.kt
+++ b/rest/src/main/kotlin/builder/message/MessageCreateBuilder.kt
@@ -1,16 +1,16 @@
 package dev.kord.rest.builder.message
 
 import dev.kord.common.annotation.KordDsl
-import dev.kord.common.entity.AllowedMentionType
-import dev.kord.common.entity.AllowedMentions
-import dev.kord.common.entity.DiscordMessageReference
-import dev.kord.common.entity.Snowflake
+import dev.kord.common.annotation.KordPreview
+import 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 dev.kord.common.entity.optional.delegate.delegate
 import dev.kord.common.entity.optional.map
 import dev.kord.rest.builder.RequestBuilder
+import dev.kord.rest.builder.components.ActionRowContainerBuilder
+import dev.kord.rest.builder.components.MessageComponentBuilder
 import dev.kord.rest.json.request.MessageCreateRequest
 import dev.kord.rest.json.request.MultipartMessageCreateRequest
 import kotlinx.coroutines.Dispatchers
@@ -40,6 +40,9 @@ class MessageCreateBuilder : RequestBuilder<MultipartMessageCreateRequest> {
     private var _allowedMentions: Optional<AllowedMentionsBuilder> = Optional.Missing()
     var allowedMentions: AllowedMentionsBuilder? by ::_allowedMentions.delegate()
 
+    @KordPreview
+    val components: MutableList<MessageComponentBuilder> = mutableListOf()
+
     val files: MutableList<Pair<String, InputStream>> = mutableListOf()
 
     private var _messageReference: OptionalSnowflake = OptionalSnowflake.Missing
@@ -82,6 +85,17 @@ class MessageCreateBuilder : RequestBuilder<MultipartMessageCreateRequest> {
         allowedMentions = (allowedMentions ?: AllowedMentionsBuilder()).apply(block)
     }
 
+    @OptIn(ExperimentalContracts::class)
+    @KordPreview
+    inline fun components(builder: ActionRowContainerBuilder.() -> Unit) {
+        contract {
+            callsInPlace(builder, InvocationKind.EXACTLY_ONCE)
+        }
+
+        components.addAll(ActionRowContainerBuilder().apply(builder).components)
+    }
+
+    @OptIn(KordPreview::class)
     override fun toRequest(): MultipartMessageCreateRequest = MultipartMessageCreateRequest(
         MessageCreateRequest(
             _content,
@@ -94,7 +108,8 @@ class MessageCreateBuilder : RequestBuilder<MultipartMessageCreateRequest> {
                     id = OptionalSnowflake.Value(it),
                     failIfNotExists = _failIfNotExists
                 )
-            }
+            },
+            Optional.missingOnEmpty(components.map(MessageComponentBuilder::build))
         ),
         files
     )
diff --git a/rest/src/main/kotlin/builder/message/MessageModifyBuilder.kt b/rest/src/main/kotlin/builder/message/MessageModifyBuilder.kt
index a2933a1a957..31488d7b96d 100644
--- a/rest/src/main/kotlin/builder/message/MessageModifyBuilder.kt
+++ b/rest/src/main/kotlin/builder/message/MessageModifyBuilder.kt
@@ -1,13 +1,15 @@
 package dev.kord.rest.builder.message
 
-import dev.kord.common.entity.UserFlags
 import dev.kord.common.annotation.KordDsl
+import dev.kord.common.annotation.KordPreview
+import dev.kord.common.entity.DiscordComponent
 import dev.kord.common.entity.MessageFlags
 import dev.kord.common.entity.optional.Optional
 import dev.kord.common.entity.optional.delegate.delegate
-import dev.kord.common.entity.optional.map
 import dev.kord.common.entity.optional.mapNullable
 import dev.kord.rest.builder.RequestBuilder
+import dev.kord.rest.builder.components.ActionRowContainerBuilder
+import dev.kord.rest.builder.components.MessageComponentBuilder
 import dev.kord.rest.json.request.MessageEditPatchRequest
 import kotlin.contracts.ExperimentalContracts
 import kotlin.contracts.InvocationKind
@@ -28,6 +30,9 @@ class MessageModifyBuilder : RequestBuilder<MessageEditPatchRequest> {
     private var _allowedMentions: Optional<AllowedMentionsBuilder?> = Optional.Missing()
     var allowedMentions: AllowedMentionsBuilder? by ::_allowedMentions.delegate()
 
+    @KordPreview
+    var components: MutableList<MessageComponentBuilder> = mutableListOf()
+
     @OptIn(ExperimentalContracts::class)
     inline fun embed(block: EmbedBuilder.() -> Unit) {
         contract {
@@ -47,8 +52,22 @@ class MessageModifyBuilder : RequestBuilder<MessageEditPatchRequest> {
         allowedMentions = (allowedMentions ?: AllowedMentionsBuilder()).apply(block)
     }
 
+    @OptIn(ExperimentalContracts::class)
+    @KordPreview
+    inline fun components(builder: ActionRowContainerBuilder.() -> Unit) {
+        contract {
+            callsInPlace(builder, InvocationKind.EXACTLY_ONCE)
+        }
+
+        components.addAll(ActionRowContainerBuilder().apply(builder).components)
+    }
 
+    @OptIn(KordPreview::class)
     override fun toRequest(): MessageEditPatchRequest = MessageEditPatchRequest(
-        _content, _embed.mapNullable { it?.toRequest() }, _flags, _allowedMentions.mapNullable { it?.build() }
+        _content,
+        _embed.mapNullable { it?.toRequest() },
+        _flags,
+        _allowedMentions.mapNullable { it?.build() },
+        Optional.missingOnEmpty(components.map(MessageComponentBuilder::build))
     )
 }
diff --git a/rest/src/main/kotlin/json/OptionalSerializer.kt b/rest/src/main/kotlin/json/OptionalSerializer.kt
deleted file mode 100644
index 207dd74b69c..00000000000
--- a/rest/src/main/kotlin/json/OptionalSerializer.kt
+++ /dev/null
@@ -1,35 +0,0 @@
-package dev.kord.rest.json
-
-import kotlinx.serialization.*
-import kotlinx.serialization.descriptors.SerialDescriptor
-import kotlinx.serialization.encoding.Decoder
-import kotlinx.serialization.encoding.Encoder
-
-/**
- * This is a very stupid serializer and you should feel ashamed for calling this.
- * Essentially, there's a use case where a [dev.kord.rest.route.Route] may *sometimes* return
- * a value, and sometimes nothing.
- *
- * `nullable` doesn't save you here since it'll expect at least something, and thus throws on an empty input.
- * Thus this crime against control flow was born. This will try to serialize the type as if it wasn't null, and
- * swallow any exceptions while doing so, returning null instead. This is incredibly bad because we won't propagate any
- * actual bugs.
- */
-@OptIn(ExperimentalSerializationApi::class)
-internal val <T> KSerializer<T>.optional: KSerializer<T?>
-    get() = object : KSerializer<T?> {
-
-        override val descriptor: SerialDescriptor
-            get() = this@optional.descriptor
-
-        override fun deserialize(decoder: Decoder): T? = try {
-            decoder.decodeSerializableValue(this@optional)
-        } catch (e: Exception) {
-            null
-        }
-
-        override fun serialize(encoder: Encoder, value: T?) {
-            if (value == null) return encoder.encodeNull()
-            else encoder.encodeSerializableValue<T>(this@optional, value)
-        }
-    }
\ No newline at end of file
diff --git a/rest/src/main/kotlin/json/request/ChannelRequests.kt b/rest/src/main/kotlin/json/request/ChannelRequests.kt
index 421a6a5f175..bc3abe81114 100644
--- a/rest/src/main/kotlin/json/request/ChannelRequests.kt
+++ b/rest/src/main/kotlin/json/request/ChannelRequests.kt
@@ -3,6 +3,7 @@ package dev.kord.rest.json.request
 import dev.kord.common.entity.Overwrite
 import dev.kord.common.entity.OverwriteType
 import dev.kord.common.entity.Permissions
+import dev.kord.common.entity.Snowflake
 import dev.kord.common.entity.optional.Optional
 import dev.kord.common.entity.optional.OptionalBoolean
 import dev.kord.common.entity.optional.OptionalInt
diff --git a/rest/src/main/kotlin/json/request/InteractionsRequests.kt b/rest/src/main/kotlin/json/request/InteractionsRequests.kt
index 9a99fa34a5f..7207d871c12 100644
--- a/rest/src/main/kotlin/json/request/InteractionsRequests.kt
+++ b/rest/src/main/kotlin/json/request/InteractionsRequests.kt
@@ -35,7 +35,8 @@ data class InteractionResponseModifyRequest(
     val embeds: Optional<List<EmbedRequest>> = Optional.Missing(),
     @SerialName("allowed_mentions")
     val allowedMentions: Optional<AllowedMentions> = Optional.Missing(),
-    val flags: Optional<MessageFlags> = Optional.Missing()
+    val flags: Optional<MessageFlags> = Optional.Missing(),
+    val components: Optional<List<DiscordComponent>> = Optional.Missing()
 )
 
 @KordPreview
@@ -84,7 +85,8 @@ class FollowupMessageCreateRequest(
     val avatar: Optional<String> = Optional.Missing(),
     val tts: OptionalBoolean = OptionalBoolean.Missing,
     val embeds: Optional<List<EmbedRequest>> = Optional.Missing(),
-    val allowedMentions: Optional<AllowedMentions> = Optional.Missing()
+    val allowedMentions: Optional<AllowedMentions> = Optional.Missing(),
+    val components: Optional<List<DiscordComponent>> = Optional.Missing()
 )
 
 @Serializable
@@ -94,6 +96,7 @@ data class FollowupMessageModifyRequest(
     val embeds: Optional<List<EmbedRequest>> = Optional.Missing(),
     @SerialName("allowed_mentions")
     val allowedMentions: Optional<AllowedMentions> = Optional.Missing(),
+    val components: Optional<List<DiscordComponent>> = Optional.Missing()
 )
 
 @KordPreview
diff --git a/rest/src/main/kotlin/json/request/MessageRequests.kt b/rest/src/main/kotlin/json/request/MessageRequests.kt
index 3016a506fa8..6b6edc1525e 100644
--- a/rest/src/main/kotlin/json/request/MessageRequests.kt
+++ b/rest/src/main/kotlin/json/request/MessageRequests.kt
@@ -5,14 +5,10 @@ import dev.kord.common.entity.*
 import dev.kord.common.entity.optional.Optional
 import dev.kord.common.entity.optional.OptionalBoolean
 import dev.kord.common.entity.optional.OptionalInt
+import kotlinx.datetime.Instant
 import kotlinx.serialization.KSerializer
 import kotlinx.serialization.SerialName
 import kotlinx.serialization.Serializable
-import kotlinx.serialization.descriptors.PrimitiveKind
-import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor
-import kotlinx.serialization.descriptors.SerialDescriptor
-import kotlinx.serialization.encoding.Decoder
-import kotlinx.serialization.encoding.Encoder
 
 @Serializable
 data class MessageCreateRequest(
@@ -23,7 +19,8 @@ data class MessageCreateRequest(
     @SerialName("allowed_mentions")
     val allowedMentions: Optional<AllowedMentions> = Optional.Missing(),
     @SerialName("message_reference")
-    val messageReference: Optional<DiscordMessageReference> = Optional.Missing()
+    val messageReference: Optional<DiscordMessageReference> = Optional.Missing(),
+    val components: Optional<List<DiscordComponent>> = Optional.Missing()
 )
 
 
@@ -83,6 +80,7 @@ data class MessageEditPatchRequest(
     val flags: Optional<MessageFlags?> = Optional.Missing(),
     @SerialName("allowed_mentions")
     val allowedMentions: Optional<AllowedMentions?> = Optional.Missing(),
+    val components: Optional<List<DiscordComponent>> = Optional.Missing()
 )
 
 @Serializable
diff --git a/rest/src/main/kotlin/json/request/StageInstanceRequests.kt b/rest/src/main/kotlin/json/request/StageInstanceRequests.kt
new file mode 100644
index 00000000000..bab42ad0592
--- /dev/null
+++ b/rest/src/main/kotlin/json/request/StageInstanceRequests.kt
@@ -0,0 +1,15 @@
+package dev.kord.rest.json.request
+
+import dev.kord.common.entity.Snowflake
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class StageInstanceCreateRequest(
+    @SerialName("channel_id")
+    val channelId: Snowflake,
+    val topic: String
+)
+
+@Serializable
+data class StageInstanceUpdateRequest(val topic: String)
diff --git a/rest/src/main/kotlin/json/response/Gateway.kt b/rest/src/main/kotlin/json/response/Gateway.kt
index 4a77abb7617..4a81033e106 100644
--- a/rest/src/main/kotlin/json/response/Gateway.kt
+++ b/rest/src/main/kotlin/json/response/Gateway.kt
@@ -19,5 +19,7 @@ data class SessionStartLimitResponse(
     val total: Int,
     val remaining: Int,
     @SerialName("reset_after")
-    val resetAfter: Int
-)
\ No newline at end of file
+    val resetAfter: Int,
+    @SerialName("max_concurrency")
+    val maxConcurrency: Int
+)
diff --git a/rest/src/main/kotlin/ratelimit/AbstractRateLimiter.kt b/rest/src/main/kotlin/ratelimit/AbstractRateLimiter.kt
index 4e612be6b4f..ba676267ad4 100644
--- a/rest/src/main/kotlin/ratelimit/AbstractRateLimiter.kt
+++ b/rest/src/main/kotlin/ratelimit/AbstractRateLimiter.kt
@@ -10,17 +10,16 @@ import kotlinx.coroutines.CompletableDeferred
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.sync.Mutex
 import mu.KLogger
-import java.time.Clock
-import java.time.Duration
+import kotlinx.datetime.Clock
+import kotlin.time.Duration as KDuration
 import java.util.concurrent.ConcurrentHashMap
-import kotlin.time.minutes
 
 
 abstract class AbstractRateLimiter internal constructor(val clock: Clock) : RequestRateLimiter {
     internal abstract val logger: KLogger
 
-    internal val autoBanRateLimiter = BucketRateLimiter(25000, 10.minutes)
-    internal val globalSuspensionPoint = atomic(Reset(clock.instant()))
+    internal val autoBanRateLimiter = BucketRateLimiter(25000, KDuration.minutes(10))
+    internal val globalSuspensionPoint = atomic(Reset(clock.now()))
     internal val buckets = ConcurrentHashMap<BucketKey, Bucket>()
     internal val routeBuckets = ConcurrentHashMap<RequestIdentifier, MutableSet<BucketKey>>()
 
@@ -29,9 +28,9 @@ abstract class AbstractRateLimiter internal constructor(val clock: Clock) : Requ
     internal fun RequestIdentifier.addBucket(id: BucketKey) = routeBuckets.getOrPut(this) { mutableSetOf() }.add(id)
 
     internal suspend fun Reset.await() {
-        val duration = Duration.between(clock.instant(), value)
-        if (duration.isNegative) return
-        delay(duration.toMillis())
+        val duration = value - clock.now()
+        if (duration.isNegative()) return
+        delay(duration)
     }
 
     open override suspend fun await(request: Request<*, *>): RequestToken {
@@ -45,7 +44,8 @@ abstract class AbstractRateLimiter internal constructor(val clock: Clock) : Requ
 
     internal abstract fun newToken(request: Request<*, *>, buckets: List<Bucket>): RequestToken
 
-    internal abstract inner class AbstractRequestToken(
+    internal abstract class AbstractRequestToken(
+        val rateLimiter: AbstractRateLimiter,
         val identity: RequestIdentifier,
         val requestBuckets: List<Bucket>
     ) : RequestToken {
@@ -54,33 +54,36 @@ abstract class AbstractRateLimiter internal constructor(val clock: Clock) : Requ
         override val completed: Boolean
             get() = completableDeferred.isCompleted
 
-        open override suspend fun complete(response: RequestResponse) {
-            response.bucketKey?.let { key ->
-                if (identity.addBucket(key)) {
-                    logger.trace { "[DISCOVERED]:[BUCKET]:Bucket ${response.bucketKey?.value} discovered for $identity" }
-                    buckets[key] = key.bucket
-                }
-            }
+        override suspend fun complete(response: RequestResponse) {
+            with(rateLimiter) {
+                val key = response.bucketKey
+                if (key != null) {
+                    if (identity.addBucket(key)) {
 
-            when (response) {
-                is RequestResponse.GlobalRateLimit -> {
-                    logger.trace { "[RATE LIMIT]:[GLOBAL]:exhausted until ${response.reset.value}" }
-                    globalSuspensionPoint.update { response.reset }
+                        logger.trace { "[DISCOVERED]:[BUCKET]:Bucket discovered for" }
+                        buckets[key] = key.bucket
+                    }
                 }
-                is RequestResponse.BucketRateLimit -> {
-                    logger.trace { "[RATE LIMIT]:[BUCKET]:Bucket ${response.bucketKey.value} was exhausted until ${response.reset.value}" }
-                    response.bucketKey.bucket.updateReset(response.reset)
+
+                when (response) {
+                    is RequestResponse.GlobalRateLimit -> {
+                        logger.trace { "[RATE LIMIT]:[GLOBAL]:exhausted until ${response.reset.value}" }
+                        globalSuspensionPoint.update { response.reset }
+                    }
+                    is RequestResponse.BucketRateLimit -> {
+                        logger.trace { "[RATE LIMIT]:[BUCKET]:Bucket ${response.bucketKey.value} was exhausted until ${response.reset.value}" }
+                        response.bucketKey.bucket.updateReset(response.reset)
+                    }
                 }
-            }
 
-            completableDeferred.complete(Unit)
-            requestBuckets.forEach { it.unlock() }
+                completableDeferred.complete(Unit)
+                requestBuckets.forEach { it.unlock() }
+            }
         }
-
     }
 
     internal inner class Bucket(val id: BucketKey) {
-        val reset = atomic(Reset(clock.instant()))
+        val reset = atomic(Reset(clock.now()))
         val mutex = Mutex()
 
         suspend fun awaitAndLock() {
diff --git a/rest/src/main/kotlin/ratelimit/ExclusionRequestRateLimiter.kt b/rest/src/main/kotlin/ratelimit/ExclusionRequestRateLimiter.kt
index 1a0d1331622..087efd7d0e4 100644
--- a/rest/src/main/kotlin/ratelimit/ExclusionRequestRateLimiter.kt
+++ b/rest/src/main/kotlin/ratelimit/ExclusionRequestRateLimiter.kt
@@ -3,13 +3,10 @@ package dev.kord.rest.ratelimit
 import dev.kord.rest.request.Request
 import dev.kord.rest.request.RequestIdentifier
 import dev.kord.rest.request.identifier
-import kotlinx.coroutines.delay
 import kotlinx.coroutines.sync.Mutex
 import mu.KLogger
 import mu.KotlinLogging
-import java.time.Clock
-import java.time.Duration
-import java.time.Instant
+import kotlinx.datetime.Clock
 
 private val requestLogger = KotlinLogging.logger {}
 
@@ -20,7 +17,7 @@ private val requestLogger = KotlinLogging.logger {}
  *
  * @param clock a [Clock] used for calculating suspension times, present for testing purposes.
  */
-class ExclusionRequestRateLimiter(clock: Clock = Clock.systemUTC()) : AbstractRateLimiter(clock) {
+class ExclusionRequestRateLimiter(clock: Clock = Clock.System) : AbstractRateLimiter(clock) {
 
     override val logger: KLogger get() = requestLogger
     private val sequentialLock = Mutex()
@@ -31,11 +28,15 @@ class ExclusionRequestRateLimiter(clock: Clock = Clock.systemUTC()) : AbstractRa
     }
 
     override fun newToken(request: Request<*, *>, buckets: List<Bucket>): RequestToken {
-        return ExclusionRequestToken(request.identifier, buckets)
+        return ExclusionRequestToken(this, request.identifier, buckets)
     }
 
-    private inner class ExclusionRequestToken(identity: RequestIdentifier, requestBuckets: List<Bucket>) :
-        AbstractRequestToken(identity, requestBuckets) {
+    private inner class ExclusionRequestToken(
+        rateLimiter: ExclusionRequestRateLimiter,
+        identity: RequestIdentifier,
+        requestBuckets: List<Bucket>
+    ) :
+        AbstractRequestToken(rateLimiter, identity, requestBuckets) {
 
         override suspend fun complete(response: RequestResponse) {
             super.complete(response)
diff --git a/rest/src/main/kotlin/ratelimit/ParallelRequestRateLimiter.kt b/rest/src/main/kotlin/ratelimit/ParallelRequestRateLimiter.kt
index 54e5f61b760..e096f950ea0 100644
--- a/rest/src/main/kotlin/ratelimit/ParallelRequestRateLimiter.kt
+++ b/rest/src/main/kotlin/ratelimit/ParallelRequestRateLimiter.kt
@@ -6,7 +6,7 @@ import dev.kord.rest.request.RequestIdentifier
 import dev.kord.rest.request.identifier
 import mu.KLogger
 import mu.KotlinLogging
-import java.time.Clock
+import kotlinx.datetime.Clock
 
 private val parallelLogger = KotlinLogging.logger {}
 
@@ -24,15 +24,15 @@ private val parallelLogger = KotlinLogging.logger {}
  * @param clock a [Clock] used for calculating suspension times, present for testing purposes.
  */
 @KordUnsafe
-class ParallelRequestRateLimiter(clock: Clock = Clock.systemUTC()) : AbstractRateLimiter(clock) {
+class ParallelRequestRateLimiter(clock: Clock = Clock.System) : AbstractRateLimiter(clock) {
 
     override val logger: KLogger
         get() = parallelLogger
 
     override fun newToken(request: Request<*, *>, buckets: List<Bucket>): RequestToken =
-        ParallelRequestToken(request.identifier, buckets)
+        ParallelRequestToken(this, request.identifier, buckets)
 
-    private inner class ParallelRequestToken(identity: RequestIdentifier, requestBuckets: List<Bucket>) :
-        AbstractRequestToken(identity, requestBuckets)
+    private inner class ParallelRequestToken(rateLimiter: ParallelRequestRateLimiter, identity: RequestIdentifier, requestBuckets: List<Bucket>) :
+        AbstractRequestToken(rateLimiter, identity, requestBuckets)
 
 }
\ No newline at end of file
diff --git a/rest/src/main/kotlin/ratelimit/RequestRateLimiter.kt b/rest/src/main/kotlin/ratelimit/RequestRateLimiter.kt
index 106f5ee951a..0d21e3b36e0 100644
--- a/rest/src/main/kotlin/ratelimit/RequestRateLimiter.kt
+++ b/rest/src/main/kotlin/ratelimit/RequestRateLimiter.kt
@@ -1,8 +1,7 @@
 package dev.kord.rest.ratelimit
 
 import dev.kord.rest.request.Request
-import java.lang.Exception
-import java.time.Instant
+import kotlinx.datetime.Instant
 import kotlin.contracts.ExperimentalContracts
 import kotlin.contracts.InvocationKind
 import kotlin.contracts.contract
@@ -54,26 +53,30 @@ data class RateLimit(val total: Total, val remaining: Remaining) {
     companion object
 }
 
-inline class Total(val value: Long) {
+@JvmInline
+value class Total(val value: Long) {
     companion object
 }
 
 
-inline class Remaining(val value: Long) {
+@JvmInline
+value class Remaining(val value: Long) {
     companion object
 }
 
 /**
  * The unique identifier of this bucket.
  */
-inline class BucketKey(val value: String) {
+@JvmInline
+value class BucketKey(val value: String) {
     companion object
 }
 
 /**
  * The [instant][value] when the current bucket gets reset.
  */
-inline class Reset(val value: Instant) {
+@JvmInline
+value class Reset(val value: Instant) {
     companion object
 }
 
diff --git a/rest/src/main/kotlin/request/HttpUtils.kt b/rest/src/main/kotlin/request/HttpUtils.kt
index 4684faba40c..3a1947a4caf 100644
--- a/rest/src/main/kotlin/request/HttpUtils.kt
+++ b/rest/src/main/kotlin/request/HttpUtils.kt
@@ -5,9 +5,9 @@ package dev.kord.rest.request
 import dev.kord.rest.ratelimit.BucketKey
 import io.ktor.client.statement.HttpResponse
 import io.ktor.client.statement.readBytes
-import java.time.Clock
-import java.time.Duration
-import java.time.Instant
+import kotlinx.datetime.Clock
+import kotlinx.datetime.Instant
+import kotlin.time.Duration
 
 private const val rateLimitGlobalHeader = "X-RateLimit-Global"
 private const val retryAfterHeader = "Retry-After"
@@ -19,13 +19,13 @@ private const val rateLimitResetAfter = "X-RateLimit-Reset-After"
 
 val HttpResponse.channelResetPoint: Instant
     get() {
-        val unixSeconds = headers[resetTimeHeader]?.toDouble() ?: return Instant.now()
-        return Instant.ofEpochMilli(unixSeconds.times(1000).toLong())
+        val unixSeconds = headers[resetTimeHeader]?.toDouble() ?: return Clock.System.now()
+        return Instant.fromEpochMilliseconds(unixSeconds.times(1000).toLong())
     }
 
 fun HttpResponse.channelResetPoint(clock: Clock): Instant {
-    val seconds = headers[rateLimitResetAfter]?.toDouble() ?: return clock.instant()
-    return clock.instant().plus(Duration.ofMillis(seconds.times(1000).toLong()))
+    val seconds = headers[rateLimitResetAfter]?.toDouble() ?: return clock.now()
+    return clock.now().plus(Duration.milliseconds(seconds.times(1000).toLong()))
 }
 
 val HttpResponse.isRateLimit get() = status.value == 429
@@ -41,8 +41,8 @@ val HttpResponse.bucket: BucketKey? get() = headers[bucketRateLimitKey]?.let { B
  * The unix time (in ms) when the global rate limit gets reset.
  */
 fun HttpResponse.globalSuspensionPoint(clock: Clock): Long {
-    val secondsWait = headers[retryAfterHeader]?.toLong() ?: return clock.millis()
-    return (secondsWait * 1000) + clock.millis()
+    val secondsWait = headers[retryAfterHeader]?.toLong() ?: return clock.now().toEpochMilliseconds()
+    return (secondsWait * 1000) + clock.now().toEpochMilliseconds()
 }
 
 fun HttpResponse.logString(body: String) =
diff --git a/rest/src/main/kotlin/request/KtorRequestHandler.kt b/rest/src/main/kotlin/request/KtorRequestHandler.kt
index a3d9643bd37..162dbf875f2 100644
--- a/rest/src/main/kotlin/request/KtorRequestHandler.kt
+++ b/rest/src/main/kotlin/request/KtorRequestHandler.kt
@@ -1,8 +1,8 @@
 package dev.kord.rest.request
 
-import dev.kord.rest.json.optional
 import dev.kord.rest.json.response.DiscordErrorResponse
 import dev.kord.rest.ratelimit.*
+import dev.kord.rest.route.optional
 import io.ktor.client.*
 import io.ktor.client.engine.cio.*
 import io.ktor.client.features.*
@@ -14,7 +14,7 @@ import io.ktor.http.*
 import io.ktor.http.content.*
 import kotlinx.serialization.json.Json
 import mu.KotlinLogging
-import java.time.Clock
+import kotlinx.datetime.Clock
 
 internal val jsonDefault = Json {
     encodeDefaults = false
@@ -35,7 +35,7 @@ internal val jsonDefault = Json {
 class KtorRequestHandler(
     private val client: HttpClient,
     private val requestRateLimiter: RequestRateLimiter = ExclusionRequestRateLimiter(),
-    private val clock: Clock = Clock.systemUTC(),
+    private val clock: Clock = Clock.System,
     private val parser: Json = jsonDefault,
 ) : RequestHandler {
     private val logger = KotlinLogging.logger("[R]:[KTOR]:[${requestRateLimiter.javaClass.simpleName}]")
@@ -61,13 +61,13 @@ class KtorRequestHandler(
                 if (response.contentType() == ContentType.Application.Json)
                     throw KtorRequestException(
                         response,
-                        parser.decodeFromString(DiscordErrorResponse.serializer().optional, body)
+                        DiscordErrorResponse.serializer().optional.deserialize(parser, body)
                     )
                 else throw KtorRequestException(response, null)
             }
             else -> {
                 logger.debug { response.logString(body) }
-                parser.decodeFromString(request.route.strategy, body)
+                request.route.mapper.deserialize(parser, body)
             }
         }
     }
@@ -107,7 +107,7 @@ class KtorRequestHandler(
 fun KtorRequestHandler(
     token: String,
     requestRateLimiter: RequestRateLimiter = ExclusionRequestRateLimiter(),
-    clock: Clock = Clock.systemUTC(),
+    clock: Clock = Clock.System,
     parser: Json = jsonDefault,
 ): KtorRequestHandler {
     val client = HttpClient(CIO) {
diff --git a/rest/src/main/kotlin/route/Route.kt b/rest/src/main/kotlin/route/Route.kt
index 38fb000d9e3..0cd5858b360 100644
--- a/rest/src/main/kotlin/route/Route.kt
+++ b/rest/src/main/kotlin/route/Route.kt
@@ -4,7 +4,6 @@ import dev.kord.common.annotation.DeprecatedSinceKord
 import dev.kord.common.annotation.KordExperimental
 import dev.kord.common.annotation.KordPreview
 import dev.kord.common.entity.*
-import dev.kord.rest.json.optional
 import dev.kord.rest.json.response.*
 import io.ktor.http.*
 import kotlinx.serialization.DeserializationStrategy
@@ -15,21 +14,48 @@ import kotlinx.serialization.descriptors.SerialDescriptor
 import kotlinx.serialization.descriptors.StructureKind
 import kotlinx.serialization.descriptors.buildSerialDescriptor
 import kotlinx.serialization.encoding.Decoder
+import kotlinx.serialization.json.Json
 import kotlinx.serialization.serializer
 import dev.kord.common.entity.DiscordEmoji as EmojiEntity
 
 internal const val REST_VERSION_PROPERTY_NAME = "dev.kord.rest.version"
 internal val restVersion get() = System.getenv(REST_VERSION_PROPERTY_NAME) ?: "v8"
 
+sealed interface ResponseMapper<T> {
+    fun deserialize(json: Json, body: String): T
+}
+
+internal class ValueJsonMapper<T>(val strategy: DeserializationStrategy<T>) : ResponseMapper<T> {
+    override fun deserialize(json: Json, body: String): T = json.decodeFromString(strategy, body)
+    override fun toString(): String = "ValueJsonMapper(strategy=$strategy)"
+}
+
+internal class NullAwareMapper<T>(val strategy: DeserializationStrategy<T>) : ResponseMapper<T?> {
+    override fun deserialize(json: Json, body: String): T? {
+        if (body.isBlank()) return null
+        return json.decodeFromString(strategy, body)
+    }
+
+    override fun toString(): String = "NullAwareMapper(strategy=$strategy)"
+}
+
+internal val <T> DeserializationStrategy<T>.optional: ResponseMapper<T?>
+    get() = NullAwareMapper(this)
+
 sealed class Route<T>(
     val method: HttpMethod,
     val path: String,
-    val strategy: DeserializationStrategy<T>
+    val mapper: ResponseMapper<T>
 ) {
+    constructor(
+        method: HttpMethod,
+        path: String,
+        strategy: DeserializationStrategy<T>
+    ) : this(method, path, ValueJsonMapper(strategy))
 
     @OptIn(ExperimentalSerializationApi::class)
     override fun toString(): String =
-        "Route(method:${method.value},path:$path,strategy:${strategy.descriptor.serialName})"
+        "Route(method:${method.value},path:$path,mapper:$mapper)"
 
     object GatewayGet
         : Route<GatewayResponse>(HttpMethod.Get, "/gateway", GatewayResponse.serializer())
@@ -425,7 +451,7 @@ sealed class Route<T>(
         : Route<Unit>(HttpMethod.Post, "/webhooks/$WebhookId/$WebhookToken/slack", NoStrategy)
 
     object ExecuteGithubWebhookPost
-        : Route<Unit>(HttpMethod.Post, "/webhooks/$WebhookId/$WebhookToken", NoStrategy)
+        : Route<Unit>(HttpMethod.Post, "/webhooks/$WebhookId/$WebhookToken/github", NoStrategy)
 
     object EditWebhookMessage : Route<DiscordMessage>(
         HttpMethod.Patch,
@@ -591,33 +617,33 @@ sealed class Route<T>(
     @KordPreview
     object GuildApplicationCommandPermissionsGet
         : Route<DiscordGuildApplicationCommandPermissions>(
-            HttpMethod.Get,
-            "/applications/${ApplicationId}/guilds/$GuildId/commands/permissions",
-            DiscordGuildApplicationCommandPermissions.serializer()
+        HttpMethod.Get,
+        "/applications/${ApplicationId}/guilds/$GuildId/commands/permissions",
+        DiscordGuildApplicationCommandPermissions.serializer()
     )
 
     @KordPreview
     object ApplicationCommandPermissionsGet
         : Route<DiscordGuildApplicationCommandPermissions>(
-            HttpMethod.Get,
-            "/applications/${ApplicationId}/guilds/$GuildId/commands/$CommandId/permissions",
-            DiscordGuildApplicationCommandPermissions.serializer()
+        HttpMethod.Get,
+        "/applications/${ApplicationId}/guilds/$GuildId/commands/$CommandId/permissions",
+        DiscordGuildApplicationCommandPermissions.serializer()
     )
 
     @KordPreview
     object ApplicationCommandPermissionsPut
         : Route<DiscordGuildApplicationCommandPermissions>(
-            HttpMethod.Put,
-            "/applications/$ApplicationId/guilds/$GuildId/commands/$CommandId/permissions",
-            DiscordGuildApplicationCommandPermissions.serializer()
+        HttpMethod.Put,
+        "/applications/$ApplicationId/guilds/$GuildId/commands/$CommandId/permissions",
+        DiscordGuildApplicationCommandPermissions.serializer()
     )
 
     @KordPreview
     object ApplicationCommandPermissionsBatchPut
         : Route<List<DiscordGuildApplicationCommandPermissions>>(
-            HttpMethod.Put,
-            "/applications/$ApplicationId/guilds/$GuildId/commands/permissions",
-            serializer()
+        HttpMethod.Put,
+        "/applications/$ApplicationId/guilds/$GuildId/commands/permissions",
+        serializer()
     )
 
     object FollowupMessageCreate : Route<DiscordMessage>(
@@ -646,6 +672,18 @@ sealed class Route<T>(
     object OthersVoiceStatePatch:
         Route<Unit>(HttpMethod.Patch, "/guilds/${GuildId}/voice-states/${UserId}", NoStrategy)
 
+    object StageInstanceGet :
+        Route<DiscordStageInstance>(HttpMethod.Get, "/stage-instances/$ChannelId", DiscordStageInstance.serializer())
+
+    object StageInstancePost :
+        Route<DiscordStageInstance>(HttpMethod.Post, "/stage-instances", DiscordStageInstance.serializer())
+
+    object StageInstancePatch :
+        Route<DiscordStageInstance>(HttpMethod.Patch, "/stage-instances/$ChannelId", DiscordStageInstance.serializer())
+
+    object StageInstanceDelete :
+        Route<Unit>(HttpMethod.Delete, "/stage-instances/$ChannelId", NoStrategy)
+
     companion object {
         val baseUrl = "https://discord.com/api/$restVersion"
     }
diff --git a/rest/src/main/kotlin/service/GuildService.kt b/rest/src/main/kotlin/service/GuildService.kt
index ffafff1770f..f958ede5302 100644
--- a/rest/src/main/kotlin/service/GuildService.kt
+++ b/rest/src/main/kotlin/service/GuildService.kt
@@ -393,7 +393,7 @@ class GuildService(requestHandler: RequestHandler) : RestService(requestHandler)
 
 
     suspend fun modifyVoiceState(guildId: Snowflake, userId: Snowflake, request: VoiceStateModifyRequest) =
-        call(Route.SelfVoiceStatePatch) {
+        call(Route.OthersVoiceStatePatch) {
             keys[Route.GuildId] = guildId
             keys[Route.UserId] = userId
             body(VoiceStateModifyRequest.serializer(), request)
diff --git a/rest/src/main/kotlin/service/RestClient.kt b/rest/src/main/kotlin/service/RestClient.kt
index 8828a168a69..f3a68e551db 100644
--- a/rest/src/main/kotlin/service/RestClient.kt
+++ b/rest/src/main/kotlin/service/RestClient.kt
@@ -22,6 +22,7 @@ class RestClient(requestHandler: RequestHandler) : RestService(requestHandler) {
     val application: ApplicationService = ApplicationService(requestHandler)
     val template: TemplateService = TemplateService(requestHandler)
     val interaction: InteractionService = InteractionService(requestHandler)
+    val stageInstance: StageInstanceService = StageInstanceService(requestHandler)
 
     /**
      * Sends a request to the given [route]. This function exposes a direct call to the Discord api and allows
diff --git a/rest/src/main/kotlin/service/StageInstanceService.kt b/rest/src/main/kotlin/service/StageInstanceService.kt
new file mode 100644
index 00000000000..2bb66354cbf
--- /dev/null
+++ b/rest/src/main/kotlin/service/StageInstanceService.kt
@@ -0,0 +1,39 @@
+package dev.kord.rest.service
+
+import dev.kord.common.entity.DiscordStageInstance
+import dev.kord.common.entity.Snowflake
+import dev.kord.rest.json.request.StageInstanceCreateRequest
+import dev.kord.rest.json.request.StageInstanceUpdateRequest
+import dev.kord.rest.request.RequestHandler
+import dev.kord.rest.route.Route
+
+class StageInstanceService(requestHandler: RequestHandler) : RestService(requestHandler) {
+    suspend fun getStageInstance(channelId: Snowflake): DiscordStageInstance = call(Route.StageInstanceGet) {
+        keys[Route.ChannelId] = channelId
+    }
+
+    suspend fun createStageInstance(request: StageInstanceCreateRequest): DiscordStageInstance =
+        call(Route.StageInstancePost) {
+            body(StageInstanceCreateRequest.serializer(), request)
+        }
+
+    suspend fun updateStageInstance(channelId: Snowflake, request: StageInstanceUpdateRequest): DiscordStageInstance =
+        call(Route.StageInstancePost) {
+            keys[Route.ChannelId] = channelId
+
+            body(StageInstanceUpdateRequest.serializer(), request)
+        }
+
+    suspend fun deleteStageInstance(channelId: Snowflake): Unit = call(Route.StageInstanceDelete) {
+        keys[Route.ChannelId] = channelId
+    }
+}
+
+suspend fun StageInstanceService.createStageInstance(channelId: Snowflake, topic: String) = createStageInstance(
+    StageInstanceCreateRequest(channelId, topic)
+)
+
+suspend fun StageInstanceService.updateStageInstance(channelId: Snowflake, topic: String) = updateStageInstance(
+    channelId,
+    StageInstanceUpdateRequest(topic)
+)
diff --git a/rest/src/test/kotlin/ratelimit/AbstractRequestRateLimiterTest.kt b/rest/src/test/kotlin/ratelimit/AbstractRequestRateLimiterTest.kt
index 8d860a982ba..2bf09c07ee4 100644
--- a/rest/src/test/kotlin/ratelimit/AbstractRequestRateLimiterTest.kt
+++ b/rest/src/test/kotlin/ratelimit/AbstractRequestRateLimiterTest.kt
@@ -8,15 +8,13 @@ import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.test.runBlockingTest
 import kotlinx.coroutines.withTimeout
 import kotlinx.coroutines.withTimeoutOrNull
-import java.time.Clock
-import java.time.Instant
-import java.time.ZoneOffset
+import kotlinx.datetime.Clock
+import kotlinx.datetime.Instant
 import kotlin.IllegalStateException
 import kotlin.test.Test
 import kotlin.test.assertEquals
+import kotlin.time.Duration
 import kotlin.time.ExperimentalTime
-import kotlin.time.seconds
-import kotlin.time.toJavaDuration
 
 @ExperimentalTime
 @ExperimentalCoroutinesApi
@@ -24,16 +22,16 @@ abstract class AbstractRequestRateLimiterTest {
 
     abstract fun newRequestRateLimiter(clock: Clock) : RequestRateLimiter
 
-    private val timeout = 1000.seconds
-    private val instant = Instant.EPOCH
+    private val timeout = Duration.seconds(1000)
+    private val instant = Instant.fromEpochMilliseconds(0)
     private val RateLimit.Companion.exhausted get() = RateLimit(Total(5), Remaining(0))
 
     private suspend fun RequestRateLimiter.sendRequest(clock: TestClock, guildId: Long, bucketKey: Long = guildId, rateLimit: RateLimit) {
         val request = JsonRequest<Unit, DiscordGuild>(Route.GuildGet, mapOf(Route.GuildId to guildId.toString()), StringValues.Empty, StringValues.Empty, null)
         val token = await(request)
         when (rateLimit.isExhausted) {
-            true -> token.complete(RequestResponse.BucketRateLimit(BucketKey(bucketKey.toString()), rateLimit, Reset(clock.instant().plus(timeout.toJavaDuration()))))
-            else -> token.complete(RequestResponse.Accepted(BucketKey(bucketKey.toString()), rateLimit, Reset(clock.instant().plus(timeout.toJavaDuration()))))
+            true -> token.complete(RequestResponse.BucketRateLimit(BucketKey(bucketKey.toString()), rateLimit, Reset(clock.now().plus(timeout))))
+            else -> token.complete(RequestResponse.Accepted(BucketKey(bucketKey.toString()), rateLimit, Reset(clock.now().plus(timeout))))
         }
     }
 
@@ -44,14 +42,14 @@ abstract class AbstractRequestRateLimiterTest {
 
     private suspend fun RequestToken.complete(clock: TestClock, bucketKey: Long, rateLimit: RateLimit) {
         when (rateLimit.isExhausted) {
-            true -> complete(RequestResponse.BucketRateLimit(BucketKey(bucketKey.toString()), rateLimit, Reset(clock.instant().plus(timeout.toJavaDuration()))))
-            else -> complete(RequestResponse.Accepted(BucketKey(bucketKey.toString()), rateLimit, Reset(clock.instant().plus(timeout.toJavaDuration()))))
+            true -> complete(RequestResponse.BucketRateLimit(BucketKey(bucketKey.toString()), rateLimit, Reset(clock.now().plus(timeout))))
+            else -> complete(RequestResponse.Accepted(BucketKey(bucketKey.toString()), rateLimit, Reset(clock.now().plus(timeout))))
         }
     }
 
     @Test
     fun `concurrent requests on the same route are handled sequentially`() = runBlockingTest {
-        val clock = TestClock(instant, this, ZoneOffset.UTC)
+        val clock = TestClock(instant, this)
         val rateLimiter = newRequestRateLimiter(clock)
 
         rateLimiter.sendRequest(1).complete(clock, 1, RateLimit.exhausted) //discovery
@@ -68,30 +66,30 @@ abstract class AbstractRequestRateLimiterTest {
 
     @Test
     fun `a RequestRateLimiter will suspend for rate limited requests with the same identifier`() = runBlockingTest {
-        val clock = TestClock(instant, this, ZoneOffset.UTC)
+        val clock = TestClock(instant, this)
         val rateLimiter = newRequestRateLimiter(clock)
 
         rateLimiter.sendRequest(clock, 1, rateLimit = RateLimit.exhausted)
         rateLimiter.sendRequest(clock, 1, rateLimit = RateLimit(Total(5), Remaining(5)))
 
-        assertEquals(timeout.inMilliseconds.toLong(), currentTime)
+        assertEquals(timeout.inWholeMilliseconds, currentTime)
     }
 
     @Test
     fun `a RequestRateLimiter will suspend for rate limited requests with the same bucket`() = runBlockingTest {
-        val clock = TestClock(instant, this, ZoneOffset.UTC)
+        val clock = TestClock(instant, this)
         val rateLimiter = newRequestRateLimiter(clock)
 
         rateLimiter.sendRequest(clock, 1, 1, rateLimit = RateLimit.exhausted)
         rateLimiter.sendRequest(clock, 2, 1 , rateLimit = RateLimit(Total(5), Remaining(5))) //discovery
         rateLimiter.sendRequest(clock, 2, 1, rateLimit = RateLimit(Total(5), Remaining(5)))
 
-        assertEquals(timeout.inMilliseconds.toLong(), currentTime)
+        assertEquals(timeout.inWholeMilliseconds, currentTime)
     }
 
     @Test
     fun `a RequestRateLimiter will not suspend for rate limited requests that don't share an identifier`() = runBlockingTest {
-        val clock = TestClock(instant, this, ZoneOffset.UTC)
+        val clock = TestClock(instant, this)
         val rateLimiter = newRequestRateLimiter(clock)
 
         rateLimiter.sendRequest(clock, 1, rateLimit = RateLimit.exhausted)
@@ -103,7 +101,7 @@ abstract class AbstractRequestRateLimiterTest {
 
     @Test
     fun `an exception during the handling won't lock the handler`() = runBlockingTest {
-        val clock = TestClock(instant, this, ZoneOffset.UTC)
+        val clock = TestClock(instant, this)
         val rateLimiter = newRequestRateLimiter(clock)
 
         rateLimiter.sendRequest(clock, 1, rateLimit = RateLimit(Total(5), Remaining(5)))
@@ -122,7 +120,7 @@ abstract class AbstractRequestRateLimiterTest {
 
     @Test
     fun `REGRESSION a RequestRateLimiter encountering a non 429 error response will not throw`() = runBlockingTest {
-        val clock = TestClock(instant, this, ZoneOffset.UTC)
+        val clock = TestClock(instant, this)
         val rateLimiter = newRequestRateLimiter(clock)
 
         rateLimiter.sendRequest(clock, 1, rateLimit = RateLimit(Total(5), Remaining(5))) //discovery
diff --git a/rest/src/test/kotlin/ratelimit/ExclusionRequestRateLimiterTest.kt b/rest/src/test/kotlin/ratelimit/ExclusionRequestRateLimiterTest.kt
index dc7ab179b99..861bc1c9df1 100644
--- a/rest/src/test/kotlin/ratelimit/ExclusionRequestRateLimiterTest.kt
+++ b/rest/src/test/kotlin/ratelimit/ExclusionRequestRateLimiterTest.kt
@@ -1,7 +1,7 @@
 package dev.kord.rest.ratelimit
 
 import kotlinx.coroutines.ExperimentalCoroutinesApi
-import java.time.Clock
+import kotlinx.datetime.Clock
 import kotlin.time.ExperimentalTime
 
 @ExperimentalTime
diff --git a/rest/src/test/kotlin/ratelimit/ParallelRequestRateLimiterTest.kt b/rest/src/test/kotlin/ratelimit/ParallelRequestRateLimiterTest.kt
index 7af216fc304..f39e2313b5b 100644
--- a/rest/src/test/kotlin/ratelimit/ParallelRequestRateLimiterTest.kt
+++ b/rest/src/test/kotlin/ratelimit/ParallelRequestRateLimiterTest.kt
@@ -1,7 +1,7 @@
 package dev.kord.rest.ratelimit
 
 import kotlinx.coroutines.ExperimentalCoroutinesApi
-import java.time.Clock
+import kotlinx.datetime.Clock
 import kotlin.time.ExperimentalTime
 
 @ExperimentalTime
diff --git a/rest/src/test/kotlin/ratelimit/TestClock.kt b/rest/src/test/kotlin/ratelimit/TestClock.kt
index d0fdd9def7a..b3808691434 100644
--- a/rest/src/test/kotlin/ratelimit/TestClock.kt
+++ b/rest/src/test/kotlin/ratelimit/TestClock.kt
@@ -2,13 +2,11 @@ package dev.kord.rest.ratelimit
 
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.test.TestCoroutineScope
-import java.time.Clock
-import java.time.Instant
-import java.time.ZoneId
+import kotlinx.datetime.Clock
+import kotlinx.datetime.Instant
+import kotlin.time.Duration
 
 @ExperimentalCoroutinesApi
-class TestClock(val instant: Instant, val scope: TestCoroutineScope, val zoneId: ZoneId) : Clock() {
-    override fun getZone(): ZoneId = zoneId
-    override fun instant(): Instant = instant.plusMillis(scope.currentTime)
-    override fun withZone(zone: ZoneId): Clock = TestClock(instant, scope, zone)
+class TestClock(val instant: Instant, val scope: TestCoroutineScope) : Clock {
+    override fun now(): Instant = instant + Duration.milliseconds(scope.currentTime)
 }
diff --git a/settings.gradle.kts b/settings.gradle.kts
index 5c776ef82f6..cae69e5d4c9 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -8,6 +8,7 @@ pluginManagement {
     }
     repositories {
         mavenLocal()
+        mavenCentral()
         maven(url = "https://dl.bintray.com/kotlin/kotlin-dev")
         gradlePluginPortal()
     }

From d64c7d335d213c14582b91d895f564f6a5744657 Mon Sep 17 00:00:00 2001
From: BartArys <mysterybtdn@gmail.com>
Date: Fri, 11 Jun 2021 11:11:27 +0200
Subject: [PATCH 11/22] Add core versions of components

---
 .../main/kotlin/cache/data/ComponentData.kt   | 40 +++++++++++
 .../src/main/kotlin/cache/data/MessageData.kt |  4 +-
 core/src/main/kotlin/entity/Message.kt        |  8 +--
 .../entity/component/ActionRowComponent.kt    | 28 ++++++++
 .../entity/component/ButtonComponent.kt       | 67 +++++++++++++++++++
 .../main/kotlin/entity/component/Component.kt | 36 ++++++++++
 .../entity/component/UnknownComponent.kt      | 14 ++++
 7 files changed, 191 insertions(+), 6 deletions(-)
 create mode 100644 core/src/main/kotlin/cache/data/ComponentData.kt
 create mode 100644 core/src/main/kotlin/entity/component/ActionRowComponent.kt
 create mode 100644 core/src/main/kotlin/entity/component/ButtonComponent.kt
 create mode 100644 core/src/main/kotlin/entity/component/Component.kt
 create mode 100644 core/src/main/kotlin/entity/component/UnknownComponent.kt

diff --git a/core/src/main/kotlin/cache/data/ComponentData.kt b/core/src/main/kotlin/cache/data/ComponentData.kt
new file mode 100644
index 00000000000..8d53f3c391e
--- /dev/null
+++ b/core/src/main/kotlin/cache/data/ComponentData.kt
@@ -0,0 +1,40 @@
+package dev.kord.core.cache.data
+
+import dev.kord.common.entity.ButtonStyle
+import dev.kord.common.entity.ComponentType
+import dev.kord.common.entity.DiscordComponent
+import dev.kord.common.entity.DiscordPartialEmoji
+import dev.kord.common.entity.optional.Optional
+import dev.kord.common.entity.optional.OptionalBoolean
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class ComponentData(
+    val type: ComponentType,
+    val style: Optional<ButtonStyle> = Optional.Missing(),
+    val label: Optional<String> = Optional.Missing(),
+    //TODO: turn this emoji into a EmojiData, it's lacking the guild id
+    val emoji: Optional<DiscordPartialEmoji> = Optional.Missing(),
+    val customId: Optional<String> = Optional.Missing(),
+    val url: Optional<String> = Optional.Missing(),
+    val disabled: OptionalBoolean = OptionalBoolean.Missing,
+    val components: Optional<List<ComponentData>> = Optional.Missing()
+) {
+
+    companion object {
+
+        fun from(entity: DiscordComponent) = with(entity) {
+            ComponentData(
+                type,
+                style,
+                label,
+                emoji,
+                customId,
+                url,
+                disabled
+            )
+        }
+
+    }
+
+}
diff --git a/core/src/main/kotlin/cache/data/MessageData.kt b/core/src/main/kotlin/cache/data/MessageData.kt
index dd0e619ad99..0607a90a7eb 100644
--- a/core/src/main/kotlin/cache/data/MessageData.kt
+++ b/core/src/main/kotlin/cache/data/MessageData.kt
@@ -37,7 +37,7 @@ data class MessageData(
     val stickers: Optional<List<MessageStickerData>> = Optional.Missing(),
     val referencedMessage: Optional<MessageData?> = Optional.Missing(),
     val interaction: Optional<MessageInteractionData> = Optional.Missing(),
-    val components: Optional<List<DiscordComponent>> = Optional.Missing()
+    val components: Optional<List<ComponentData>> = Optional.Missing()
 ) {
 
     fun plus(selfId: Snowflake, reaction: MessageReactionAddData): MessageData {
@@ -141,7 +141,7 @@ data class MessageData(
                 stickers.mapList { MessageStickerData.from(it) },
                 referencedMessage.mapNotNull { from(it) },
                 interaction.map { MessageInteractionData.from(it) },
-                components = components
+                components = components.mapList { ComponentData.from(it) }
             )
         }
     }
diff --git a/core/src/main/kotlin/entity/Message.kt b/core/src/main/kotlin/entity/Message.kt
index f3a53dda558..cadb15a09e1 100644
--- a/core/src/main/kotlin/entity/Message.kt
+++ b/core/src/main/kotlin/entity/Message.kt
@@ -1,10 +1,8 @@
 package dev.kord.core.entity
 
 import dev.kord.common.annotation.KordPreview
-import dev.kord.common.entity.DiscordComponent
 import dev.kord.common.entity.MessageType
 import dev.kord.common.entity.Snowflake
-import dev.kord.common.entity.optional.map
 import dev.kord.common.entity.optional.mapNullable
 import dev.kord.common.entity.optional.orEmpty
 import dev.kord.common.entity.optional.unwrap
@@ -18,8 +16,9 @@ import dev.kord.core.entity.channel.Channel
 import dev.kord.core.entity.channel.GuildChannel
 import dev.kord.core.entity.channel.GuildMessageChannel
 import dev.kord.core.entity.channel.MessageChannel
-import dev.kord.core.entity.interaction.MessageInteraction
+import dev.kord.core.entity.component.Component
 import dev.kord.core.entity.interaction.Interaction
+import dev.kord.core.entity.interaction.MessageInteraction
 import dev.kord.core.exception.EntityNotFoundException
 import dev.kord.core.supplier.EntitySupplier
 import dev.kord.core.supplier.EntitySupplyStrategy
@@ -235,7 +234,8 @@ class Message(
     val webhookId: Snowflake? get() = data.webhookId.value
 
     @KordPreview
-    val components: List<DiscordComponent> get() = data.components.orEmpty()
+    val components: List<Component>
+        get() = data.components.orEmpty().map { Component(it) }
 
     /**
      * Returns itself.
diff --git a/core/src/main/kotlin/entity/component/ActionRowComponent.kt b/core/src/main/kotlin/entity/component/ActionRowComponent.kt
new file mode 100644
index 00000000000..98a10f5f1d0
--- /dev/null
+++ b/core/src/main/kotlin/entity/component/ActionRowComponent.kt
@@ -0,0 +1,28 @@
+package dev.kord.core.entity.component
+
+import dev.kord.common.annotation.KordPreview
+import dev.kord.common.entity.ComponentType
+import dev.kord.common.entity.optional.orEmpty
+import dev.kord.core.cache.data.ComponentData
+
+/**
+ * A non-interactive container component for other types of component.
+ */
+@KordPreview
+class ActionRowComponent(override val data: ComponentData) : Component {
+
+    override val type: ComponentType
+        get() = ComponentType.ActionRow
+
+
+    /**
+     * The buttons that are nested inside this component
+     */
+    val buttons: List<ButtonComponent>
+        get() = data.components.orEmpty()
+            .filter { it.type == ComponentType.Button }
+            .map { ButtonComponent(it) }
+
+    override fun toString(): String = "ActionRowComponent(data=$data)"
+
+}
diff --git a/core/src/main/kotlin/entity/component/ButtonComponent.kt b/core/src/main/kotlin/entity/component/ButtonComponent.kt
new file mode 100644
index 00000000000..52b66516bc4
--- /dev/null
+++ b/core/src/main/kotlin/entity/component/ButtonComponent.kt
@@ -0,0 +1,67 @@
+package dev.kord.core.entity.component
+
+import dev.kord.common.annotation.KordPreview
+import dev.kord.common.entity.ButtonStyle
+import dev.kord.common.entity.ComponentType
+import dev.kord.common.entity.optional.value
+import dev.kord.core.cache.data.ComponentData
+import dev.kord.core.entity.ReactionEmoji
+import dev.kord.core.entity.interaction.ComponentInteraction
+import dev.kord.core.event.interaction.InteractionCreateEvent
+
+/**
+ * An interactive component rendered on a Message.
+ * If this button contains a [customId] and is clicked by a user,
+ * a [InteractionCreateEvent] with a [ComponentInteraction] will fire.
+ */
+@KordPreview
+class ButtonComponent(override val data: ComponentData) : Component {
+
+    override val type: ComponentType
+        get() = ComponentType.Button
+
+    /**
+     * The style of this button, [ButtonStyle.Link] buttons will always
+     * have a [url].
+     */
+    val style: ButtonStyle get() = data.style.value!!
+
+    /**
+     * The text that appears on the button, if present.
+     */
+    val label: String? get() = data.label.value
+
+    /**
+     * The emoji that appears on the button, if present.
+     */
+    val emoji: ReactionEmoji?
+        get() = with(data.emoji.value) {
+            if (this == null) return@with null
+
+            when (id) {
+                null -> ReactionEmoji.Unicode(name!!)
+                else -> ReactionEmoji.Custom(
+                    id!!, name ?: "", animated.value!!
+                )
+            }
+        }
+
+    /**
+     * The custom identifier for any [ComponentInteractions][ComponentInteraction]
+     * this button will trigger. Present if this button is not a link button.
+     */
+    val customId: String? get() = data.customId.value
+
+    /**
+     * The url the button will link to. Present if this button is a link button.
+     */
+    val url: String? get() = data.url.value
+
+    /**
+     * Whether this button can be clicked.
+     */
+    val disabled: Boolean get() = data.disabled.discordBoolean
+
+    override fun toString(): String = "ButtonComponent(data=$data)"
+
+}
diff --git a/core/src/main/kotlin/entity/component/Component.kt b/core/src/main/kotlin/entity/component/Component.kt
new file mode 100644
index 00000000000..e32f80ea8d3
--- /dev/null
+++ b/core/src/main/kotlin/entity/component/Component.kt
@@ -0,0 +1,36 @@
+package dev.kord.core.entity.component
+
+import dev.kord.common.annotation.KordPreview
+import dev.kord.common.entity.ComponentType
+import dev.kord.core.cache.data.ComponentData
+import dev.kord.core.entity.Message
+
+/**
+ * An interactive element inside a [Message].
+ */
+@KordPreview
+sealed interface Component {
+
+    /**
+     * The type of component.
+     * @see ButtonComponent
+     * @see ActionRowComponent
+     * @see UnknownComponent
+     */
+    val type: ComponentType get() = data.type
+
+    val data: ComponentData
+}
+
+/**
+ * Creates a [Component] from the [data].
+ * @see ActionRowComponent
+ * @see ButtonComponent
+ * @see UnknownComponent
+ */
+@KordPreview
+fun Component(data: ComponentData): Component = when (data.type) {
+    ComponentType.ActionRow -> ActionRowComponent(data)
+    ComponentType.Button -> ButtonComponent(data)
+    is ComponentType.Unknown -> UnknownComponent(data)
+}
diff --git a/core/src/main/kotlin/entity/component/UnknownComponent.kt b/core/src/main/kotlin/entity/component/UnknownComponent.kt
new file mode 100644
index 00000000000..c867b43db6f
--- /dev/null
+++ b/core/src/main/kotlin/entity/component/UnknownComponent.kt
@@ -0,0 +1,14 @@
+package dev.kord.core.entity.component
+
+import dev.kord.common.annotation.KordPreview
+import dev.kord.core.cache.data.ComponentData
+
+/**
+ * A component type unknown to Kord.
+ */
+@KordPreview
+class UnknownComponent(override val data: ComponentData) : Component {
+
+    override fun toString(): String = "UnknownComponent(data=$data)"
+
+}

From 5237de5b4f2c832666b0785431b25a6e38d6de17 Mon Sep 17 00:00:00 2001
From: BartArys <mysterybtdn@gmail.com>
Date: Fri, 11 Jun 2021 11:12:19 +0200
Subject: [PATCH 12/22] Restructure and document ButtonBuilder

---
 .../builder/components/ActionRowBuilder.kt    | 23 ++---
 .../builder/components/ButtonBuilder.kt       | 94 ++++++++++++++-----
 2 files changed, 79 insertions(+), 38 deletions(-)

diff --git a/rest/src/main/kotlin/builder/components/ActionRowBuilder.kt b/rest/src/main/kotlin/builder/components/ActionRowBuilder.kt
index 3a3f40664a7..bb0f02f5437 100644
--- a/rest/src/main/kotlin/builder/components/ActionRowBuilder.kt
+++ b/rest/src/main/kotlin/builder/components/ActionRowBuilder.kt
@@ -25,26 +25,23 @@ class ActionRowBuilder : MessageComponentBuilder {
             callsInPlace(builder, InvocationKind.EXACTLY_ONCE)
         }
 
-        components.add(ButtonBuilder.InteractionButtonBuilder()
-            .apply {
-                this.style = style
-                this.customId = customId
-            }
-            .apply(builder))
+        components.add(
+            ButtonBuilder.InteractionButtonBuilder(style, customId).apply(builder)
+        )
     }
 
     @OptIn(ExperimentalContracts::class)
-    inline fun linkButton(label: String, url: String, builder: ButtonBuilder.LinkButtonBuilder.() -> Unit = {}) {
+    inline fun linkButton(
+        url: String,
+        builder: ButtonBuilder.LinkButtonBuilder.() -> Unit
+    ) {
         contract {
             callsInPlace(builder, InvocationKind.EXACTLY_ONCE)
         }
 
-        components.add(ButtonBuilder.LinkButtonBuilder()
-            .apply {
-                this.url = url
-                this.label = label
-            }
-            .apply(builder))
+        components.add(
+            ButtonBuilder.LinkButtonBuilder(url).apply(builder)
+        )
     }
 
     override fun build(): DiscordComponent =
diff --git a/rest/src/main/kotlin/builder/components/ButtonBuilder.kt b/rest/src/main/kotlin/builder/components/ButtonBuilder.kt
index ef10e6cb218..60e17afcdd8 100644
--- a/rest/src/main/kotlin/builder/components/ButtonBuilder.kt
+++ b/rest/src/main/kotlin/builder/components/ButtonBuilder.kt
@@ -9,38 +9,82 @@ import dev.kord.common.entity.DiscordPartialEmoji
 import dev.kord.common.entity.optional.Optional
 import dev.kord.common.entity.optional.OptionalBoolean
 import dev.kord.common.entity.optional.delegate.delegate
-import dev.kord.common.entity.optional.optional
-import kotlin.contracts.ExperimentalContracts
-import kotlin.contracts.InvocationKind
-import kotlin.contracts.contract
 
 @KordDsl
 @KordPreview
 sealed class ButtonBuilder : ActionRowComponentBuilder {
 
-    @PublishedApi
-    internal open var _style: Optional<ButtonStyle> = Optional.Missing()
-    private var _label: Optional<String> = Optional.Missing()
-    var label by ::_label.delegate()
-    private var _emoji: Optional<DiscordPartialEmoji> = Optional.Missing()
-    var emoji by ::_emoji.delegate()
-    internal var _customId: Optional<String> = Optional.Missing()
-    internal var _url: Optional<String> = Optional.Missing()
-    private var _disabled: OptionalBoolean = OptionalBoolean.Missing
-    var disabled by ::_disabled.delegate()
-
-
-    class InteractionButtonBuilder : ButtonBuilder() {
-        var style by ::_style.delegate()
-        var customId by ::_customId.delegate()
+    /**
+     * The text that appears on the button, either this and/or [emoji] need to be set
+     * for the button to be valid.
+     */
+    abstract var label: String?
+
+    /**
+     * The emoji that appears on the button, either this and/or [label] need to be set
+     * for the button to be valid.
+     */
+    abstract var emoji: DiscordPartialEmoji?
+
+    /**
+     * Whether the button is clickable.
+     */
+    var disabled: Boolean = false
+
+    /**
+     * A builder for a button that can create Interactions when clicked.
+     *
+     * @param style the style of this button, [ButtonStyle.Link] is not valid.
+     * @param customId the ID of this button, used to identify component interactions.
+     */
+    class InteractionButtonBuilder(
+        var style: ButtonStyle,
+        var customId: String
+    ) : ButtonBuilder() {
+
+        private var _emoji: Optional<DiscordPartialEmoji> = Optional.Missing()
+        override var emoji: DiscordPartialEmoji? by ::_emoji.delegate()
+
+        private var _label: Optional<String> = Optional.Missing()
+        override var label: String? by ::_label.delegate()
+
+        override fun build(): DiscordComponent = DiscordComponent(
+            ComponentType.Button,
+            Optional(style),
+            _label,
+            _emoji,
+            Optional(customId),
+            Optional.Missing(),
+            OptionalBoolean.Value(disabled),
+        )
+
     }
 
-    class LinkButtonBuilder : ButtonBuilder() {
-        var url by ::_url.delegate()
-        override var _style: Optional<ButtonStyle> = ButtonStyle.Link.optional()
+    /**
+     * A button that links to the [url].
+     *
+     * @param url The url to open when clicked.
+     */
+    class LinkButtonBuilder(
+        var url: String
+    ) : ButtonBuilder() {
+
+        private var _emoji: Optional<DiscordPartialEmoji> = Optional.Missing()
+        override var emoji: DiscordPartialEmoji? by ::_emoji.delegate()
+
+        private var _label: Optional<String> = Optional.Missing()
+        override var label: String? by ::_label.delegate()
+
+        override fun build(): DiscordComponent = DiscordComponent(
+            ComponentType.Button,
+            Optional(ButtonStyle.Link),
+            _label,
+            _emoji,
+            Optional.Missing(),
+            Optional.Value(url),
+            OptionalBoolean.Value(disabled),
+        )
+
     }
 
-    override fun build(): DiscordComponent = DiscordComponent(
-        ComponentType.Button, _style, _label, _emoji, _customId, _url, _disabled
-    )
 }

From 50ec6e8a7f847a7fa492e334cb85d19b5e6e75fa Mon Sep 17 00:00:00 2001
From: BartArys <mysterybtdn@gmail.com>
Date: Fri, 11 Jun 2021 11:17:56 +0200
Subject: [PATCH 13/22] Remove ActionRowContainerBuilder

---
 .../components/ActionRowContainerBuilder.kt   | 23 -------------------
 .../builder/message/MessageCreateBuilder.kt   |  6 ++---
 .../builder/message/MessageModifyBuilder.kt   |  7 +++---
 3 files changed, 6 insertions(+), 30 deletions(-)
 delete mode 100644 rest/src/main/kotlin/builder/components/ActionRowContainerBuilder.kt

diff --git a/rest/src/main/kotlin/builder/components/ActionRowContainerBuilder.kt b/rest/src/main/kotlin/builder/components/ActionRowContainerBuilder.kt
deleted file mode 100644
index 9d983ca0794..00000000000
--- a/rest/src/main/kotlin/builder/components/ActionRowContainerBuilder.kt
+++ /dev/null
@@ -1,23 +0,0 @@
-package dev.kord.rest.builder.components
-
-import dev.kord.common.annotation.KordDsl
-import dev.kord.common.annotation.KordPreview
-import dev.kord.common.entity.DiscordComponent
-import kotlin.contracts.ExperimentalContracts
-import kotlin.contracts.InvocationKind
-import kotlin.contracts.contract
-
-@KordDsl
-@KordPreview
-class ActionRowContainerBuilder {
-    val components = mutableListOf<ActionRowBuilder>()
-
-    @OptIn(ExperimentalContracts::class)
-    inline fun actionRow(builder: ActionRowBuilder.() -> Unit = {}) {
-        contract {
-            callsInPlace(builder, InvocationKind.EXACTLY_ONCE)
-        }
-
-        components.add(ActionRowBuilder().apply(builder))
-    }
-}
diff --git a/rest/src/main/kotlin/builder/message/MessageCreateBuilder.kt b/rest/src/main/kotlin/builder/message/MessageCreateBuilder.kt
index 127e0a2dd5c..eaeaaa0f5ec 100644
--- a/rest/src/main/kotlin/builder/message/MessageCreateBuilder.kt
+++ b/rest/src/main/kotlin/builder/message/MessageCreateBuilder.kt
@@ -9,7 +9,7 @@ import dev.kord.common.entity.optional.OptionalSnowflake
 import dev.kord.common.entity.optional.delegate.delegate
 import dev.kord.common.entity.optional.map
 import dev.kord.rest.builder.RequestBuilder
-import dev.kord.rest.builder.components.ActionRowContainerBuilder
+import dev.kord.rest.builder.components.ActionRowBuilder
 import dev.kord.rest.builder.components.MessageComponentBuilder
 import dev.kord.rest.json.request.MessageCreateRequest
 import dev.kord.rest.json.request.MultipartMessageCreateRequest
@@ -87,12 +87,12 @@ class MessageCreateBuilder : RequestBuilder<MultipartMessageCreateRequest> {
 
     @OptIn(ExperimentalContracts::class)
     @KordPreview
-    inline fun components(builder: ActionRowContainerBuilder.() -> Unit) {
+    inline fun actionRow(builder: ActionRowBuilder.() -> Unit) {
         contract {
             callsInPlace(builder, InvocationKind.EXACTLY_ONCE)
         }
 
-        components.addAll(ActionRowContainerBuilder().apply(builder).components)
+        components.add(ActionRowBuilder().apply(builder))
     }
 
     @OptIn(KordPreview::class)
diff --git a/rest/src/main/kotlin/builder/message/MessageModifyBuilder.kt b/rest/src/main/kotlin/builder/message/MessageModifyBuilder.kt
index 31488d7b96d..6971895acca 100644
--- a/rest/src/main/kotlin/builder/message/MessageModifyBuilder.kt
+++ b/rest/src/main/kotlin/builder/message/MessageModifyBuilder.kt
@@ -2,13 +2,12 @@ package dev.kord.rest.builder.message
 
 import dev.kord.common.annotation.KordDsl
 import dev.kord.common.annotation.KordPreview
-import dev.kord.common.entity.DiscordComponent
 import dev.kord.common.entity.MessageFlags
 import dev.kord.common.entity.optional.Optional
 import dev.kord.common.entity.optional.delegate.delegate
 import dev.kord.common.entity.optional.mapNullable
 import dev.kord.rest.builder.RequestBuilder
-import dev.kord.rest.builder.components.ActionRowContainerBuilder
+import dev.kord.rest.builder.components.ActionRowBuilder
 import dev.kord.rest.builder.components.MessageComponentBuilder
 import dev.kord.rest.json.request.MessageEditPatchRequest
 import kotlin.contracts.ExperimentalContracts
@@ -54,12 +53,12 @@ class MessageModifyBuilder : RequestBuilder<MessageEditPatchRequest> {
 
     @OptIn(ExperimentalContracts::class)
     @KordPreview
-    inline fun components(builder: ActionRowContainerBuilder.() -> Unit) {
+    inline fun actionRow(builder: ActionRowBuilder.() -> Unit) {
         contract {
             callsInPlace(builder, InvocationKind.EXACTLY_ONCE)
         }
 
-        components.addAll(ActionRowContainerBuilder().apply(builder).components)
+        components.add(ActionRowBuilder().apply(builder))
     }
 
     @OptIn(KordPreview::class)

From 5958cabf502f218ba89a0cfbf90c1f207a258604 Mon Sep 17 00:00:00 2001
From: BartArys <mysterybtdn@gmail.com>
Date: Fri, 11 Jun 2021 11:22:31 +0200
Subject: [PATCH 14/22] Make ComponentInteraction message nullable

ephemeral messages in the interaction contain a id, which is not a message id, and the flags.

We can't construct a behaviour from this (since the id isn't real), so I decided to drop the data if the message is ephemeral.
---
 common/src/main/kotlin/entity/Interactions.kt | 34 +++++++++++++++++--
 .../kotlin/entity/interaction/Interaction.kt  | 34 ++++++++++++++-----
 2 files changed, 57 insertions(+), 11 deletions(-)

diff --git a/common/src/main/kotlin/entity/Interactions.kt b/common/src/main/kotlin/entity/Interactions.kt
index a26e4984497..f13f85c7fc3 100644
--- a/common/src/main/kotlin/entity/Interactions.kt
+++ b/common/src/main/kotlin/entity/Interactions.kt
@@ -169,9 +169,40 @@ class DiscordInteraction(
     val user: Optional<DiscordUser> = Optional.Missing(),
     val token: String,
     val version: Int,
+    @Serializable(with = MaybeMessageSerializer::class)
     val message: Optional<DiscordMessage> = Optional.Missing(),
     val type: InteractionType
-)
+) {
+
+    /**
+     * Serializer that handles incomplete messages in [DiscordInteraction.message]. Discards
+     * any incomplete messages as missing optionals.
+     */
+    private object MaybeMessageSerializer :
+        KSerializer<Optional<DiscordMessage>> by Optional.serializer(DiscordMessage.serializer()) {
+
+        override fun deserialize(decoder: Decoder): Optional<DiscordMessage> {
+            decoder as JsonDecoder
+
+            val element = decoder.decodeJsonElement().jsonObject
+
+            //check if required fields are present, if not, discard the data
+            return if (
+                element["channel_id"] == null ||
+                element["author"] == null
+            ) {
+                Optional.Missing()
+            } else {
+                decoder.json.decodeFromJsonElement(
+                    Optional.serializer(DiscordMessage.serializer()), element
+                )
+            }
+        }
+
+
+    }
+}
+
 
 @Serializable(InteractionType.Serializer::class)
 @KordPreview
@@ -633,4 +664,3 @@ data class DiscordGuildApplicationCommandPermission(
         }
     }
 }
-
diff --git a/core/src/main/kotlin/entity/interaction/Interaction.kt b/core/src/main/kotlin/entity/interaction/Interaction.kt
index daa3fb0ebb1..b522bf35fd5 100644
--- a/core/src/main/kotlin/entity/interaction/Interaction.kt
+++ b/core/src/main/kotlin/entity/interaction/Interaction.kt
@@ -10,15 +10,25 @@ import dev.kord.core.behavior.GuildInteractionBehavior
 import dev.kord.core.behavior.MemberBehavior
 import dev.kord.core.behavior.UserBehavior
 import dev.kord.core.behavior.channel.GuildMessageChannelBehavior
+import dev.kord.core.behavior.interaction.EphemeralInteractionResponseBehavior
 import dev.kord.core.behavior.interaction.InteractionBehavior
+import dev.kord.core.behavior.interaction.PublicInteractionResponseBehavior
 import dev.kord.core.cache.data.ApplicationInteractionData
 import dev.kord.core.cache.data.InteractionData
 import dev.kord.core.cache.data.ResolvedObjectsData
 import dev.kord.core.entity.*
 import dev.kord.core.entity.channel.DmChannel
 import dev.kord.core.entity.channel.ResolvedChannel
+import dev.kord.core.entity.component.ButtonComponent
+import dev.kord.core.entity.component.Component
 import dev.kord.core.supplier.EntitySupplier
 import dev.kord.core.supplier.EntitySupplyStrategy
+import dev.kord.rest.builder.interaction.UpdateMessageInteractionResponseCreateBuilder
+import dev.kord.rest.json.request.InteractionApplicationCommandCallbackData
+import dev.kord.rest.json.request.InteractionResponseCreateRequest
+import kotlin.contracts.ExperimentalContracts
+import kotlin.contracts.InvocationKind
+import kotlin.contracts.contract
 
 /**
  * An instance of [Interaction] (https://discord.com/developers/docs/interactions/slash-commands#interaction)
@@ -344,7 +354,7 @@ class DmInteraction(
 }
 
 /**
- * An [Interaction] that was made with a [DiscordComponent].
+ * An [Interaction] that was made with a [Component].
  */
 @KordPreview
 class ComponentInteraction(
@@ -353,25 +363,31 @@ class ComponentInteraction(
     override val kord: Kord,
     override val supplier: EntitySupplier
 ) : Interaction(), InteractionBehavior {
+
     override val user: UserBehavior = UserBehavior(data.member.value!!.userId, kord)
 
-    val message: Message
+    /**
+     * The message that contains the interacted component, null if the message is ephemeral.
+     */
+    val message: Message?
         get() = data.message.unwrap {
             Message(it, kord, supplier)
-        }!!
+        }
 
     /**
-     * The [components][DiscordComponent] of the message that was interacted with.
+     * The [ButtonComponent.customId] that triggered the interaction.
      */
-    val components: List<DiscordComponent> get() = message.components
+    val componentId: String get() = data.data.customId.value!!
 
     /**
-     * The [DiscordComponent] the user interacted with.
+     * The [ButtonComponent] the user interacted with, null if the message is ephemeral.
      *
-     * @see components
-     * @see DiscordComponent
+     * @see Component
      */
-    val component: DiscordComponent get() = message.components.first { it.customId == data.data.customId }
+    val component: ButtonComponent
+        get() = message?.components.orEmpty()
+            .filterIsInstance<ButtonComponent>().first { it.customId == componentId }
+
 
     override fun withStrategy(strategy: EntitySupplyStrategy<*>): Interaction = ComponentInteraction(
         data, applicationId, kord, strategy.supply(kord)

From 7c68dc273f30103d887c01c949387fc44ff2cd9b Mon Sep 17 00:00:00 2001
From: BartArys <mysterybtdn@gmail.com>
Date: Fri, 11 Jun 2021 12:32:50 +0200
Subject: [PATCH 15/22] Add missing components to interaction builders

---
 .../EphemeralInteractionBuilders.kt           | 20 +++++++++++++++--
 .../interaction/FollowupMessageBuilders.kt    | 22 ++++++++++++++++++-
 .../interaction/PublicInteractionBuilder.kt   |  7 +++---
 .../json/request/InteractionsRequests.kt      |  4 ++--
 4 files changed, 44 insertions(+), 9 deletions(-)

diff --git a/rest/src/main/kotlin/builder/interaction/EphemeralInteractionBuilders.kt b/rest/src/main/kotlin/builder/interaction/EphemeralInteractionBuilders.kt
index 7774f8d3005..b73e1687c44 100644
--- a/rest/src/main/kotlin/builder/interaction/EphemeralInteractionBuilders.kt
+++ b/rest/src/main/kotlin/builder/interaction/EphemeralInteractionBuilders.kt
@@ -10,6 +10,8 @@ import dev.kord.common.entity.optional.Optional
 import dev.kord.common.entity.optional.delegate.delegate
 import dev.kord.common.entity.optional.optional
 import dev.kord.rest.builder.RequestBuilder
+import dev.kord.rest.builder.components.ActionRowBuilder
+import dev.kord.rest.builder.components.MessageComponentBuilder
 import dev.kord.rest.builder.message.AllowedMentionsBuilder
 import dev.kord.rest.json.request.InteractionApplicationCommandCallbackData
 import dev.kord.rest.json.request.InteractionResponseCreateRequest
@@ -28,6 +30,7 @@ class EphemeralInteractionResponseModifyBuilder : RequestBuilder<InteractionResp
     private var _allowedMentions: Optional<AllowedMentions> = Optional.Missing()
     var allowedMentions: AllowedMentions? by ::_allowedMentions.delegate()
 
+    val components: MutableList<MessageComponentBuilder> = mutableListOf()
 
     @OptIn(ExperimentalContracts::class)
     inline fun allowedMentions(builder: AllowedMentionsBuilder.() -> Unit) {
@@ -35,9 +38,22 @@ class EphemeralInteractionResponseModifyBuilder : RequestBuilder<InteractionResp
         allowedMentions = AllowedMentionsBuilder().apply(builder).build()
     }
 
+    @OptIn(ExperimentalContracts::class)
+    @KordPreview
+    inline fun actionRow(builder: ActionRowBuilder.() -> Unit) {
+        contract {
+            callsInPlace(builder, InvocationKind.EXACTLY_ONCE)
+        }
+
+        components.add(ActionRowBuilder().apply(builder))
+    }
 
     override fun toRequest(): InteractionResponseModifyRequest {
-        return InteractionResponseModifyRequest(content = _content, allowedMentions = _allowedMentions)
+        return InteractionResponseModifyRequest(
+            content = _content,
+            allowedMentions = _allowedMentions,
+            components = Optional.missingOnEmpty(components.map { it.build() })
+        )
 
     }
 }
@@ -69,4 +85,4 @@ class EphemeralInteractionResponseCreateBuilder : RequestBuilder<InteractionResp
         return InteractionResponseCreateRequest(type, data.optional())
 
     }
-}
\ No newline at end of file
+}
diff --git a/rest/src/main/kotlin/builder/interaction/FollowupMessageBuilders.kt b/rest/src/main/kotlin/builder/interaction/FollowupMessageBuilders.kt
index 51796c16d25..5ccd63c60d4 100644
--- a/rest/src/main/kotlin/builder/interaction/FollowupMessageBuilders.kt
+++ b/rest/src/main/kotlin/builder/interaction/FollowupMessageBuilders.kt
@@ -172,6 +172,16 @@ class PublicFollowupMessageCreateBuilder : RequestBuilder<MultipartFollowupMessa
         allowedMentions = (allowedMentions ?: AllowedMentionsBuilder()).apply(block)
     }
 
+    @OptIn(ExperimentalContracts::class)
+    @KordPreview
+    inline fun actionRow(builder: ActionRowBuilder.() -> Unit) {
+        contract {
+            callsInPlace(builder, InvocationKind.EXACTLY_ONCE)
+        }
+
+        components.add(ActionRowBuilder().apply(builder))
+    }
+
     @OptIn(ExperimentalContracts::class)
     inline fun embed(builder: EmbedBuilder.() -> Unit) {
         contract {
@@ -206,6 +216,8 @@ class EphemeralFollowupMessageCreateBuilder(var content: String) :
     private var _allowedMentions: Optional<AllowedMentionsBuilder> = Optional.Missing()
     var allowedMentions: AllowedMentionsBuilder? by ::_allowedMentions.delegate()
 
+    val components: MutableList<MessageComponentBuilder> = mutableListOf()
+
     /**
      * Configures the mentions that should trigger a mention (aka ping). Not calling this function will result in the default behavior
      * (ping everything), calling this function but not configuring it before the request is build will result in all
@@ -217,7 +229,15 @@ class EphemeralFollowupMessageCreateBuilder(var content: String) :
         allowedMentions = (allowedMentions ?: AllowedMentionsBuilder()).apply(block)
     }
 
-    val components: MutableList<MessageComponentBuilder> = mutableListOf()
+    @OptIn(ExperimentalContracts::class)
+    @KordPreview
+    inline fun actionRow(builder: ActionRowBuilder.() -> Unit) {
+        contract {
+            callsInPlace(builder, InvocationKind.EXACTLY_ONCE)
+        }
+
+        components.add(ActionRowBuilder().apply(builder))
+    }
 
     override fun toRequest(): MultipartFollowupMessageCreateRequest =
         MultipartFollowupMessageCreateRequest(
diff --git a/rest/src/main/kotlin/builder/interaction/PublicInteractionBuilder.kt b/rest/src/main/kotlin/builder/interaction/PublicInteractionBuilder.kt
index 0a28859abf7..f640e1de9f9 100644
--- a/rest/src/main/kotlin/builder/interaction/PublicInteractionBuilder.kt
+++ b/rest/src/main/kotlin/builder/interaction/PublicInteractionBuilder.kt
@@ -2,13 +2,11 @@ package dev.kord.rest.builder.interaction
 
 import dev.kord.common.annotation.KordDsl
 import dev.kord.common.annotation.KordPreview
-import dev.kord.common.entity.DiscordComponent
 import dev.kord.common.entity.InteractionResponseType
 import dev.kord.common.entity.optional.*
 import dev.kord.common.entity.optional.delegate.delegate
 import dev.kord.rest.builder.RequestBuilder
 import dev.kord.rest.builder.components.ActionRowBuilder
-import dev.kord.rest.builder.components.ActionRowContainerBuilder
 import dev.kord.rest.builder.components.MessageComponentBuilder
 import dev.kord.rest.builder.message.AllowedMentionsBuilder
 import dev.kord.rest.builder.message.EmbedBuilder
@@ -89,12 +87,13 @@ class PublicInteractionResponseCreateBuilder :
 
         return MultipartInteractionResponseCreateRequest(
             InteractionResponseCreateRequest(
-                type,
+                    type,
                 InteractionApplicationCommandCallbackData(
                     content = _content,
                     embeds = _embeds.mapList { it.toRequest() },
                     allowedMentions = _allowedMentions.map { it.build() },
-                    tts = _tts
+                    tts = _tts,
+                    components = Optional.missingOnEmpty(components.map { it.build() })
                 ).optional()
             ),
             files
diff --git a/rest/src/main/kotlin/json/request/InteractionsRequests.kt b/rest/src/main/kotlin/json/request/InteractionsRequests.kt
index 7207d871c12..fa597213f9b 100644
--- a/rest/src/main/kotlin/json/request/InteractionsRequests.kt
+++ b/rest/src/main/kotlin/json/request/InteractionsRequests.kt
@@ -66,8 +66,8 @@ class InteractionApplicationCommandCallbackData(
     val embeds: Optional<List<EmbedRequest>> = Optional.Missing(),
     @SerialName("allowed_mentions")
     val allowedMentions: Optional<AllowedMentions> = Optional.Missing(),
-    val flags: Optional<MessageFlags> = Optional.Missing()
-
+    val flags: Optional<MessageFlags> = Optional.Missing(),
+    val components: Optional<List<DiscordComponent>> = Optional.Missing()
 )
 
 @KordPreview

From 22c8a170571115b48bbb66be457cb1b103080bff Mon Sep 17 00:00:00 2001
From: BartArys <mysterybtdn@gmail.com>
Date: Fri, 11 Jun 2021 12:37:31 +0200
Subject: [PATCH 16/22] Add missing ComponentInteraction behavior

---
 .../kotlin/entity/interaction/Interaction.kt  | 102 ++++++++++++++++++
 ...MessageInteractionResponseCreateBuilder.kt |  99 +++++++++++++++++
 2 files changed, 201 insertions(+)
 create mode 100644 rest/src/main/kotlin/builder/interaction/UpdateMessageInteractionResponseCreateBuilder.kt

diff --git a/core/src/main/kotlin/entity/interaction/Interaction.kt b/core/src/main/kotlin/entity/interaction/Interaction.kt
index b522bf35fd5..f6501fac330 100644
--- a/core/src/main/kotlin/entity/interaction/Interaction.kt
+++ b/core/src/main/kotlin/entity/interaction/Interaction.kt
@@ -388,10 +388,112 @@ class ComponentInteraction(
         get() = message?.components.orEmpty()
             .filterIsInstance<ButtonComponent>().first { it.customId == componentId }
 
+    /**
+     * Acknowledges a component interaction publicly with the intent of updating it later.
+     *
+     * There is no requirement to actually update the message later, calling this is
+     * sufficient to handle the interaction and stops any 'loading' animations in the client.
+     *
+     * There is no noticeable difference between this and [acknowledgeEphemeralDeferredMessageUpdate]
+     * when it comes to acknowledging the interaction, both functions can be called
+     * on public and ephemeral messages. The only difference is in the **followUp** calls,
+     * which will become public or ephemeral respectively.
+     */
+    @OptIn(ExperimentalContracts::class)
+    suspend fun acknowledgePublicDeferredMessageUpdate(): PublicInteractionResponseBehavior {
+        val request = InteractionResponseCreateRequest(
+            type = InteractionResponseType.DeferredUpdateMessage
+        )
+
+        kord.rest.interaction.createInteractionResponse(id, token, request)
+
+        return PublicInteractionResponseBehavior(applicationId, token, kord)
+    }
+
+    /**
+     * Acknowledges a component interaction ephemerally with the intent of updating it later.
+     *
+     * There is no requirement to actually update the message later, calling this is
+     * sufficient to handle the interaction and stops any 'loading' state in the client.
+     *
+     * There is no noticeable difference between this and [acknowledgePublicDeferredMessageUpdate]
+     * when it comes to acknowledging the interaction, both functions can be called
+     * on public and ephemeral messages. The only difference is in the **followUp** calls,
+     * which will become ephemeral or public respectively.
+     */
+    @OptIn(ExperimentalContracts::class)
+    suspend fun acknowledgeEphemeralDeferredMessageUpdate(): EphemeralInteractionResponseBehavior {
+        val request = InteractionResponseCreateRequest(
+            data = Optional.Value(
+                InteractionApplicationCommandCallbackData(
+                    flags = Optional(MessageFlags(MessageFlag.Ephemeral))
+                )
+            ),
+            type = InteractionResponseType.DeferredUpdateMessage
+        )
+
+        kord.rest.interaction.createInteractionResponse(id, token, request)
+
+        return EphemeralInteractionResponseBehavior(applicationId, token, kord)
+    }
+
+    /**
+     * Acknowledges a component interaction publicly and updates the message with the [builder].
+     *
+     * There is no noticeable difference between this and [acknowledgeEphemeralUpdateMessage]
+     * when it comes to acknowledging the interaction, both functions can be called
+     * on public and ephemeral messages. The only difference is in the **followUp** calls,
+     * which will become public or ephemeral respectively.
+     */
+    @OptIn(ExperimentalContracts::class)
+    suspend fun acknowledgePublicUpdateMessage(builder: UpdateMessageInteractionResponseCreateBuilder.() -> Unit): PublicInteractionResponseBehavior {
+        contract { callsInPlace(builder, InvocationKind.EXACTLY_ONCE) }
+
+        val request = UpdateMessageInteractionResponseCreateBuilder().apply(builder).toRequest()
+
+        kord.rest.interaction.createInteractionResponse(
+            id,
+            token,
+            request.copy(request = request.request.copy(InteractionResponseType.UpdateMessage))
+        )
+
+        return PublicInteractionResponseBehavior(applicationId, token, kord)
+    }
+
+    /**
+     * Acknowledges a component interaction ephemerally and updates the message with the [builder].
+     *
+     * There is no noticeable difference between this and [acknowledgeEphemeralUpdateMessage]
+     * when it comes to acknowledging the interaction, both functions can be called
+     * on public and ephemeral messages. The only difference is in the **followUp** calls,
+     * which will become ephemeral or public respectively.
+     */
+    @OptIn(ExperimentalContracts::class)
+    suspend fun acknowledgeEphemeralUpdateMessage(builder: UpdateMessageInteractionResponseCreateBuilder.() -> Unit): EphemeralInteractionResponseBehavior {
+        contract { callsInPlace(builder, InvocationKind.EXACTLY_ONCE) }
+
+        val request = UpdateMessageInteractionResponseCreateBuilder(
+            flags = MessageFlags(MessageFlag.Ephemeral)
+        ).apply(builder).toRequest()
+
+        kord.rest.interaction.createInteractionResponse(
+            id,
+            token,
+            request
+        )
+
+        return EphemeralInteractionResponseBehavior(applicationId, token, kord)
+    }
+
 
     override fun withStrategy(strategy: EntitySupplyStrategy<*>): Interaction = ComponentInteraction(
         data, applicationId, kord, strategy.supply(kord)
     )
+
+    override fun toString(): String {
+        return "ComponentInteraction(data=$data, applicationId=$applicationId, kord=$kord, supplier=$supplier, user=$user)"
+    }
+
 }
 
 @KordPreview
diff --git a/rest/src/main/kotlin/builder/interaction/UpdateMessageInteractionResponseCreateBuilder.kt b/rest/src/main/kotlin/builder/interaction/UpdateMessageInteractionResponseCreateBuilder.kt
new file mode 100644
index 00000000000..1782e37f360
--- /dev/null
+++ b/rest/src/main/kotlin/builder/interaction/UpdateMessageInteractionResponseCreateBuilder.kt
@@ -0,0 +1,99 @@
+package dev.kord.rest.builder.interaction
+
+import dev.kord.common.annotation.KordPreview
+import dev.kord.common.entity.InteractionResponseType
+import dev.kord.common.entity.MessageFlag
+import dev.kord.common.entity.MessageFlags
+import dev.kord.common.entity.optional.*
+import dev.kord.common.entity.optional.delegate.delegate
+import dev.kord.rest.builder.RequestBuilder
+import dev.kord.rest.builder.components.ActionRowBuilder
+import dev.kord.rest.builder.components.MessageComponentBuilder
+import dev.kord.rest.builder.message.AllowedMentionsBuilder
+import dev.kord.rest.builder.message.EmbedBuilder
+import dev.kord.rest.json.request.InteractionApplicationCommandCallbackData
+import dev.kord.rest.json.request.InteractionResponseCreateRequest
+import dev.kord.rest.json.request.MultipartInteractionResponseCreateRequest
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import java.io.InputStream
+import java.nio.file.Files
+import java.nio.file.Path
+import kotlin.contracts.ExperimentalContracts
+import kotlin.contracts.InvocationKind
+import kotlin.contracts.contract
+
+@KordPreview
+class UpdateMessageInteractionResponseCreateBuilder(
+    private val flags: MessageFlags? = null
+) : RequestBuilder<MultipartInteractionResponseCreateRequest> {
+
+    private var _content: Optional<String> = Optional.Missing()
+    var content: String? by ::_content.delegate()
+
+    val embeds: MutableList<EmbedBuilder> = mutableListOf()
+
+    private var _allowedMentions: Optional<AllowedMentionsBuilder> = Optional.Missing()
+    var allowedMentions: AllowedMentionsBuilder? by ::_allowedMentions.delegate()
+
+    private var _tts: OptionalBoolean = OptionalBoolean.Missing
+    var tts: Boolean? by ::_tts.delegate()
+
+    val components: MutableList<MessageComponentBuilder> = mutableListOf()
+
+    val files: MutableList<Pair<String, InputStream>> = mutableListOf()
+
+    /**
+     * Configures the mentions that should trigger a mention (aka ping). Not calling this function will result in the default behavior
+     * (ping everything), calling this function but not configuring it before the request is build will result in all
+     * pings being ignored.
+     */
+    @OptIn(ExperimentalContracts::class)
+    inline fun allowedMentions(block: AllowedMentionsBuilder.() -> Unit = {}) {
+        contract { callsInPlace(block, InvocationKind.EXACTLY_ONCE) }
+        allowedMentions = (allowedMentions ?: AllowedMentionsBuilder()).apply(block)
+    }
+
+    @OptIn(ExperimentalContracts::class)
+    inline fun embed(builder: EmbedBuilder.() -> Unit) {
+        contract { callsInPlace(builder, InvocationKind.EXACTLY_ONCE) }
+        embeds.add(EmbedBuilder().apply(builder))
+    }
+
+    @OptIn(ExperimentalContracts::class)
+    @KordPreview
+    inline fun actionRow(builder: ActionRowBuilder.() -> Unit) {
+        contract {
+            callsInPlace(builder, InvocationKind.EXACTLY_ONCE)
+        }
+
+        components.add(ActionRowBuilder().apply(builder))
+    }
+
+    fun addFile(name: String, content: InputStream) {
+        files += name to content
+    }
+
+    suspend fun addFile(path: Path) = withContext(Dispatchers.IO) {
+        addFile(path.fileName.toString(), Files.newInputStream(path))
+    }
+
+    override fun toRequest(): MultipartInteractionResponseCreateRequest {
+        return MultipartInteractionResponseCreateRequest(
+            InteractionResponseCreateRequest(
+                InteractionResponseType.UpdateMessage,
+                InteractionApplicationCommandCallbackData(
+                    content = _content,
+                    embeds = Optional.missingOnEmpty(embeds.map { it.toRequest() }),
+                    allowedMentions = _allowedMentions.map { it.build() },
+                    flags = flags.optional().coerceToMissing(),
+                    tts = _tts,
+                    components = Optional.missingOnEmpty(components.map { it.build() })
+                ).optional()
+            ),
+            files
+        )
+
+    }
+
+}

From fa3adbb913a3e767d73a752e6813994d58c211fa Mon Sep 17 00:00:00 2001
From: BartArys <mysterybtdn@gmail.com>
Date: Fri, 11 Jun 2021 14:00:33 +0200
Subject: [PATCH 17/22] Fix withStrategy for ComponentInteractionBehavior

---
 core/src/main/kotlin/entity/interaction/Interaction.kt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/core/src/main/kotlin/entity/interaction/Interaction.kt b/core/src/main/kotlin/entity/interaction/Interaction.kt
index f6501fac330..e891b6c52d0 100644
--- a/core/src/main/kotlin/entity/interaction/Interaction.kt
+++ b/core/src/main/kotlin/entity/interaction/Interaction.kt
@@ -486,7 +486,7 @@ class ComponentInteraction(
     }
 
 
-    override fun withStrategy(strategy: EntitySupplyStrategy<*>): Interaction = ComponentInteraction(
+    override fun withStrategy(strategy: EntitySupplyStrategy<*>): ComponentInteraction = ComponentInteraction(
         data, applicationId, kord, strategy.supply(kord)
     )
 

From 79938e8c996c7be9961fea63fea56479df8af18e Mon Sep 17 00:00:00 2001
From: BartArys <mysterybtdn@gmail.com>
Date: Fri, 11 Jun 2021 14:00:52 +0200
Subject: [PATCH 18/22] Implement ComponentInteractionBehavior

---
 core/src/main/kotlin/Unsafe.kt                |  17 +-
 .../ComponentInteractionBehavior.kt           | 162 ++++++++++++++++++
 .../kotlin/entity/interaction/Interaction.kt  | 100 +----------
 3 files changed, 179 insertions(+), 100 deletions(-)
 create mode 100644 core/src/main/kotlin/behavior/interaction/ComponentInteractionBehavior.kt

diff --git a/core/src/main/kotlin/Unsafe.kt b/core/src/main/kotlin/Unsafe.kt
index c949920656d..4db516cc811 100644
--- a/core/src/main/kotlin/Unsafe.kt
+++ b/core/src/main/kotlin/Unsafe.kt
@@ -2,10 +2,10 @@ package dev.kord.core
 
 import dev.kord.common.annotation.KordExperimental
 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.interaction.ComponentInteractionBehavior
 import dev.kord.rest.service.InteractionService
 
 /**
@@ -91,4 +91,17 @@ class Unsafe(private val kord: Kord) {
     ): GlobalApplicationCommandBehavior =
         GlobalApplicationCommandBehavior(applicationId, commandId, service)
 
-}
\ No newline at end of file
+    /**
+     * Creates a ComponentInteractionBehavior with the given [id], [channelId],
+     * [token] and [applicationId].
+     */
+    fun componentInteraction(
+        id: Snowflake,
+        channelId: Snowflake,
+        token: String,
+        applicationId: Snowflake = kord.selfId,
+    ): ComponentInteractionBehavior = ComponentInteractionBehavior(
+        id, channelId, token, applicationId, kord
+    )
+
+}
diff --git a/core/src/main/kotlin/behavior/interaction/ComponentInteractionBehavior.kt b/core/src/main/kotlin/behavior/interaction/ComponentInteractionBehavior.kt
new file mode 100644
index 00000000000..238f23dc982
--- /dev/null
+++ b/core/src/main/kotlin/behavior/interaction/ComponentInteractionBehavior.kt
@@ -0,0 +1,162 @@
+package dev.kord.core.behavior.interaction
+
+import dev.kord.common.annotation.KordPreview
+import dev.kord.common.entity.InteractionResponseType
+import dev.kord.common.entity.MessageFlag
+import dev.kord.common.entity.MessageFlags
+import dev.kord.common.entity.Snowflake
+import dev.kord.common.entity.optional.Optional
+import dev.kord.core.Kord
+import dev.kord.core.supplier.EntitySupplier
+import dev.kord.core.supplier.EntitySupplyStrategy
+import dev.kord.rest.builder.interaction.UpdateMessageInteractionResponseCreateBuilder
+import dev.kord.rest.json.request.InteractionApplicationCommandCallbackData
+import dev.kord.rest.json.request.InteractionResponseCreateRequest
+import kotlin.contracts.ExperimentalContracts
+import kotlin.contracts.InvocationKind
+import kotlin.contracts.contract
+
+@KordPreview
+interface ComponentInteractionBehavior : InteractionBehavior {
+
+    /**
+     * Acknowledges a component interaction publicly with the intent of updating it later.
+     *
+     * There is no requirement to actually update the message later, calling this is
+     * sufficient to handle the interaction and stops any 'loading' animations in the client.
+     *
+     * There is no noticeable difference between this and [acknowledgeEphemeralDeferredMessageUpdate]
+     * when it comes to acknowledging the interaction, both functions can be called
+     * on public and ephemeral messages. The only difference is in the **followUp** calls,
+     * which will become public or ephemeral respectively.
+     */
+    @OptIn(ExperimentalContracts::class)
+    suspend fun acknowledgePublicDeferredMessageUpdate(): PublicInteractionResponseBehavior {
+        val request = InteractionResponseCreateRequest(
+            type = InteractionResponseType.DeferredUpdateMessage
+        )
+
+        kord.rest.interaction.createInteractionResponse(id, token, request)
+
+        return PublicInteractionResponseBehavior(applicationId, token, kord)
+    }
+
+    /**
+     * Acknowledges a component interaction ephemerally with the intent of updating it later.
+     *
+     * There is no requirement to actually update the message later, calling this is
+     * sufficient to handle the interaction and stops any 'loading' state in the client.
+     *
+     * There is no noticeable difference between this and [acknowledgePublicDeferredMessageUpdate]
+     * when it comes to acknowledging the interaction, both functions can be called
+     * on public and ephemeral messages. The only difference is in the **followUp** calls,
+     * which will become ephemeral or public respectively.
+     */
+    @OptIn(ExperimentalContracts::class)
+    suspend fun acknowledgeEphemeralDeferredMessageUpdate(): EphemeralInteractionResponseBehavior {
+        val request = InteractionResponseCreateRequest(
+            data = Optional.Value(
+                InteractionApplicationCommandCallbackData(
+                    flags = Optional(MessageFlags(MessageFlag.Ephemeral))
+                )
+            ),
+            type = InteractionResponseType.DeferredUpdateMessage
+        )
+
+        kord.rest.interaction.createInteractionResponse(id, token, request)
+
+        return EphemeralInteractionResponseBehavior(applicationId, token, kord)
+    }
+
+
+    override fun withStrategy(strategy: EntitySupplyStrategy<*>): ComponentInteractionBehavior {
+        return ComponentInteractionBehavior(id, channelId, token, applicationId, kord, strategy)
+    }
+
+}
+
+/**
+ * Creates a ComponentInteractionBehavior with the given [id], [channelId],
+ * [token], [applicationId], [kord] and [strategy].
+ */
+@KordPreview
+fun ComponentInteractionBehavior(
+    id: Snowflake,
+    channelId: Snowflake,
+    token: String,
+    applicationId: Snowflake,
+    kord: Kord,
+    strategy: EntitySupplyStrategy<*> = kord.resources.defaultStrategy
+): ComponentInteractionBehavior = object : ComponentInteractionBehavior {
+    override val applicationId: Snowflake
+        get() = applicationId
+
+    override val token: String
+        get() = token
+
+    override val channelId: Snowflake
+        get() = channelId
+
+    override val kord: Kord
+        get() = kord
+
+    override val id: Snowflake
+        get() = id
+
+    override val supplier: EntitySupplier = strategy.supply(kord)
+
+}
+
+/**
+ * Acknowledges a component interaction publicly and updates the message with the [builder].
+ *
+ * There is no noticeable difference between this and [acknowledgeEphemeralUpdateMessage]
+ * when it comes to acknowledging the interaction, both functions can be called
+ * on public and ephemeral messages. The only difference is in the **followUp** calls,
+ * which will become public or ephemeral respectively.
+ */
+@KordPreview
+@OptIn(ExperimentalContracts::class)
+suspend fun ComponentInteractionBehavior.acknowledgePublicUpdateMessage(
+    builder: UpdateMessageInteractionResponseCreateBuilder.() -> Unit
+): PublicInteractionResponseBehavior {
+    contract { callsInPlace(builder, InvocationKind.EXACTLY_ONCE) }
+
+    val request = UpdateMessageInteractionResponseCreateBuilder().apply(builder).toRequest()
+
+    kord.rest.interaction.createInteractionResponse(
+        id,
+        token,
+        request.copy(request = request.request.copy(InteractionResponseType.UpdateMessage))
+    )
+
+    return PublicInteractionResponseBehavior(applicationId, token, kord)
+}
+
+/**
+ * Acknowledges a component interaction ephemerally and updates the message with the [builder].
+ *
+ * There is no noticeable difference between this and [acknowledgeEphemeralUpdateMessage]
+ * when it comes to acknowledging the interaction, both functions can be called
+ * on public and ephemeral messages. The only difference is in the **followUp** calls,
+ * which will become ephemeral or public respectively.
+ */
+@KordPreview
+@OptIn(ExperimentalContracts::class)
+suspend fun ComponentInteractionBehavior.acknowledgeEphemeralUpdateMessage(
+    builder: UpdateMessageInteractionResponseCreateBuilder.() -> Unit
+): EphemeralInteractionResponseBehavior {
+    contract { callsInPlace(builder, InvocationKind.EXACTLY_ONCE) }
+
+    val request = UpdateMessageInteractionResponseCreateBuilder(
+        flags = MessageFlags(MessageFlag.Ephemeral)
+    ).apply(builder).toRequest()
+
+    kord.rest.interaction.createInteractionResponse(
+        id,
+        token,
+        request
+    )
+
+    return EphemeralInteractionResponseBehavior(applicationId, token, kord)
+}
diff --git a/core/src/main/kotlin/entity/interaction/Interaction.kt b/core/src/main/kotlin/entity/interaction/Interaction.kt
index e891b6c52d0..a399fa2acf3 100644
--- a/core/src/main/kotlin/entity/interaction/Interaction.kt
+++ b/core/src/main/kotlin/entity/interaction/Interaction.kt
@@ -10,6 +10,7 @@ import dev.kord.core.behavior.GuildInteractionBehavior
 import dev.kord.core.behavior.MemberBehavior
 import dev.kord.core.behavior.UserBehavior
 import dev.kord.core.behavior.channel.GuildMessageChannelBehavior
+import dev.kord.core.behavior.interaction.ComponentInteractionBehavior
 import dev.kord.core.behavior.interaction.EphemeralInteractionResponseBehavior
 import dev.kord.core.behavior.interaction.InteractionBehavior
 import dev.kord.core.behavior.interaction.PublicInteractionResponseBehavior
@@ -362,7 +363,7 @@ class ComponentInteraction(
     override val applicationId: Snowflake,
     override val kord: Kord,
     override val supplier: EntitySupplier
-) : Interaction(), InteractionBehavior {
+) : Interaction(), ComponentInteractionBehavior {
 
     override val user: UserBehavior = UserBehavior(data.member.value!!.userId, kord)
 
@@ -388,103 +389,6 @@ class ComponentInteraction(
         get() = message?.components.orEmpty()
             .filterIsInstance<ButtonComponent>().first { it.customId == componentId }
 
-    /**
-     * Acknowledges a component interaction publicly with the intent of updating it later.
-     *
-     * There is no requirement to actually update the message later, calling this is
-     * sufficient to handle the interaction and stops any 'loading' animations in the client.
-     *
-     * There is no noticeable difference between this and [acknowledgeEphemeralDeferredMessageUpdate]
-     * when it comes to acknowledging the interaction, both functions can be called
-     * on public and ephemeral messages. The only difference is in the **followUp** calls,
-     * which will become public or ephemeral respectively.
-     */
-    @OptIn(ExperimentalContracts::class)
-    suspend fun acknowledgePublicDeferredMessageUpdate(): PublicInteractionResponseBehavior {
-        val request = InteractionResponseCreateRequest(
-            type = InteractionResponseType.DeferredUpdateMessage
-        )
-
-        kord.rest.interaction.createInteractionResponse(id, token, request)
-
-        return PublicInteractionResponseBehavior(applicationId, token, kord)
-    }
-
-    /**
-     * Acknowledges a component interaction ephemerally with the intent of updating it later.
-     *
-     * There is no requirement to actually update the message later, calling this is
-     * sufficient to handle the interaction and stops any 'loading' state in the client.
-     *
-     * There is no noticeable difference between this and [acknowledgePublicDeferredMessageUpdate]
-     * when it comes to acknowledging the interaction, both functions can be called
-     * on public and ephemeral messages. The only difference is in the **followUp** calls,
-     * which will become ephemeral or public respectively.
-     */
-    @OptIn(ExperimentalContracts::class)
-    suspend fun acknowledgeEphemeralDeferredMessageUpdate(): EphemeralInteractionResponseBehavior {
-        val request = InteractionResponseCreateRequest(
-            data = Optional.Value(
-                InteractionApplicationCommandCallbackData(
-                    flags = Optional(MessageFlags(MessageFlag.Ephemeral))
-                )
-            ),
-            type = InteractionResponseType.DeferredUpdateMessage
-        )
-
-        kord.rest.interaction.createInteractionResponse(id, token, request)
-
-        return EphemeralInteractionResponseBehavior(applicationId, token, kord)
-    }
-
-    /**
-     * Acknowledges a component interaction publicly and updates the message with the [builder].
-     *
-     * There is no noticeable difference between this and [acknowledgeEphemeralUpdateMessage]
-     * when it comes to acknowledging the interaction, both functions can be called
-     * on public and ephemeral messages. The only difference is in the **followUp** calls,
-     * which will become public or ephemeral respectively.
-     */
-    @OptIn(ExperimentalContracts::class)
-    suspend fun acknowledgePublicUpdateMessage(builder: UpdateMessageInteractionResponseCreateBuilder.() -> Unit): PublicInteractionResponseBehavior {
-        contract { callsInPlace(builder, InvocationKind.EXACTLY_ONCE) }
-
-        val request = UpdateMessageInteractionResponseCreateBuilder().apply(builder).toRequest()
-
-        kord.rest.interaction.createInteractionResponse(
-            id,
-            token,
-            request.copy(request = request.request.copy(InteractionResponseType.UpdateMessage))
-        )
-
-        return PublicInteractionResponseBehavior(applicationId, token, kord)
-    }
-
-    /**
-     * Acknowledges a component interaction ephemerally and updates the message with the [builder].
-     *
-     * There is no noticeable difference between this and [acknowledgeEphemeralUpdateMessage]
-     * when it comes to acknowledging the interaction, both functions can be called
-     * on public and ephemeral messages. The only difference is in the **followUp** calls,
-     * which will become ephemeral or public respectively.
-     */
-    @OptIn(ExperimentalContracts::class)
-    suspend fun acknowledgeEphemeralUpdateMessage(builder: UpdateMessageInteractionResponseCreateBuilder.() -> Unit): EphemeralInteractionResponseBehavior {
-        contract { callsInPlace(builder, InvocationKind.EXACTLY_ONCE) }
-
-        val request = UpdateMessageInteractionResponseCreateBuilder(
-            flags = MessageFlags(MessageFlag.Ephemeral)
-        ).apply(builder).toRequest()
-
-        kord.rest.interaction.createInteractionResponse(
-            id,
-            token,
-            request
-        )
-
-        return EphemeralInteractionResponseBehavior(applicationId, token, kord)
-    }
-
 
     override fun withStrategy(strategy: EntitySupplyStrategy<*>): ComponentInteraction = ComponentInteraction(
         data, applicationId, kord, strategy.supply(kord)

From f1573a6b00a31831e44e2ff71aa9585f644f5299 Mon Sep 17 00:00:00 2001
From: BartArys <mysterybtdn@gmail.com>
Date: Fri, 11 Jun 2021 15:21:01 +0200
Subject: [PATCH 19/22] Move component builders directory

We use singular for package names
---
 .../{components => component}/ButtonBuilderExtensions.kt     | 2 +-
 .../builder/{components => component}/ActionRowBuilder.kt    | 2 +-
 .../builder/{components => component}/ButtonBuilder.kt       | 2 +-
 .../builder/{components => component}/ComponentBuilders.kt   | 2 +-
 .../builder/interaction/EphemeralInteractionBuilders.kt      | 4 ++--
 .../kotlin/builder/interaction/FollowupMessageBuilders.kt    | 4 ++--
 .../kotlin/builder/interaction/PublicInteractionBuilder.kt   | 4 ++--
 .../UpdateMessageInteractionResponseCreateBuilder.kt         | 5 ++---
 rest/src/main/kotlin/builder/message/MessageCreateBuilder.kt | 4 ++--
 rest/src/main/kotlin/builder/message/MessageModifyBuilder.kt | 4 ++--
 10 files changed, 16 insertions(+), 17 deletions(-)
 rename core/src/main/kotlin/builder/{components => component}/ButtonBuilderExtensions.kt (89%)
 rename rest/src/main/kotlin/builder/{components => component}/ActionRowBuilder.kt (97%)
 rename rest/src/main/kotlin/builder/{components => component}/ButtonBuilder.kt (98%)
 rename rest/src/main/kotlin/builder/{components => component}/ComponentBuilders.kt (88%)

diff --git a/core/src/main/kotlin/builder/components/ButtonBuilderExtensions.kt b/core/src/main/kotlin/builder/component/ButtonBuilderExtensions.kt
similarity index 89%
rename from core/src/main/kotlin/builder/components/ButtonBuilderExtensions.kt
rename to core/src/main/kotlin/builder/component/ButtonBuilderExtensions.kt
index 1fec49064e3..05cd6eb80dd 100644
--- a/core/src/main/kotlin/builder/components/ButtonBuilderExtensions.kt
+++ b/core/src/main/kotlin/builder/component/ButtonBuilderExtensions.kt
@@ -4,7 +4,7 @@ import dev.kord.common.annotation.KordPreview
 import dev.kord.common.entity.DiscordPartialEmoji
 import dev.kord.core.entity.GuildEmoji
 import dev.kord.core.entity.ReactionEmoji
-import dev.kord.rest.builder.components.ButtonBuilder
+import dev.kord.rest.builder.component.ButtonBuilder
 
 @KordPreview
 fun ButtonBuilder.emoji(emoji: ReactionEmoji) {
diff --git a/rest/src/main/kotlin/builder/components/ActionRowBuilder.kt b/rest/src/main/kotlin/builder/component/ActionRowBuilder.kt
similarity index 97%
rename from rest/src/main/kotlin/builder/components/ActionRowBuilder.kt
rename to rest/src/main/kotlin/builder/component/ActionRowBuilder.kt
index bb0f02f5437..074b1a5bea3 100644
--- a/rest/src/main/kotlin/builder/components/ActionRowBuilder.kt
+++ b/rest/src/main/kotlin/builder/component/ActionRowBuilder.kt
@@ -1,4 +1,4 @@
-package dev.kord.rest.builder.components
+package dev.kord.rest.builder.component
 
 import dev.kord.common.annotation.KordDsl
 import dev.kord.common.annotation.KordPreview
diff --git a/rest/src/main/kotlin/builder/components/ButtonBuilder.kt b/rest/src/main/kotlin/builder/component/ButtonBuilder.kt
similarity index 98%
rename from rest/src/main/kotlin/builder/components/ButtonBuilder.kt
rename to rest/src/main/kotlin/builder/component/ButtonBuilder.kt
index 60e17afcdd8..e3e1d1e3f46 100644
--- a/rest/src/main/kotlin/builder/components/ButtonBuilder.kt
+++ b/rest/src/main/kotlin/builder/component/ButtonBuilder.kt
@@ -1,4 +1,4 @@
-package dev.kord.rest.builder.components
+package dev.kord.rest.builder.component
 
 import dev.kord.common.annotation.KordDsl
 import dev.kord.common.annotation.KordPreview
diff --git a/rest/src/main/kotlin/builder/components/ComponentBuilders.kt b/rest/src/main/kotlin/builder/component/ComponentBuilders.kt
similarity index 88%
rename from rest/src/main/kotlin/builder/components/ComponentBuilders.kt
rename to rest/src/main/kotlin/builder/component/ComponentBuilders.kt
index 2f842d0af55..1dff82e5345 100644
--- a/rest/src/main/kotlin/builder/components/ComponentBuilders.kt
+++ b/rest/src/main/kotlin/builder/component/ComponentBuilders.kt
@@ -1,4 +1,4 @@
-package dev.kord.rest.builder.components
+package dev.kord.rest.builder.component
 
 import dev.kord.common.annotation.KordPreview
 import dev.kord.common.entity.DiscordComponent
diff --git a/rest/src/main/kotlin/builder/interaction/EphemeralInteractionBuilders.kt b/rest/src/main/kotlin/builder/interaction/EphemeralInteractionBuilders.kt
index b73e1687c44..557f66604f3 100644
--- a/rest/src/main/kotlin/builder/interaction/EphemeralInteractionBuilders.kt
+++ b/rest/src/main/kotlin/builder/interaction/EphemeralInteractionBuilders.kt
@@ -10,8 +10,8 @@ import dev.kord.common.entity.optional.Optional
 import dev.kord.common.entity.optional.delegate.delegate
 import dev.kord.common.entity.optional.optional
 import dev.kord.rest.builder.RequestBuilder
-import dev.kord.rest.builder.components.ActionRowBuilder
-import dev.kord.rest.builder.components.MessageComponentBuilder
+import dev.kord.rest.builder.component.ActionRowBuilder
+import dev.kord.rest.builder.component.MessageComponentBuilder
 import dev.kord.rest.builder.message.AllowedMentionsBuilder
 import dev.kord.rest.json.request.InteractionApplicationCommandCallbackData
 import dev.kord.rest.json.request.InteractionResponseCreateRequest
diff --git a/rest/src/main/kotlin/builder/interaction/FollowupMessageBuilders.kt b/rest/src/main/kotlin/builder/interaction/FollowupMessageBuilders.kt
index 5ccd63c60d4..4f6676b20e3 100644
--- a/rest/src/main/kotlin/builder/interaction/FollowupMessageBuilders.kt
+++ b/rest/src/main/kotlin/builder/interaction/FollowupMessageBuilders.kt
@@ -8,8 +8,8 @@ import dev.kord.common.entity.optional.delegate.delegate
 import dev.kord.common.entity.optional.map
 import dev.kord.common.entity.optional.mapList
 import dev.kord.rest.builder.RequestBuilder
-import dev.kord.rest.builder.components.ActionRowBuilder
-import dev.kord.rest.builder.components.MessageComponentBuilder
+import dev.kord.rest.builder.component.ActionRowBuilder
+import dev.kord.rest.builder.component.MessageComponentBuilder
 import dev.kord.rest.builder.message.AllowedMentionsBuilder
 import dev.kord.rest.builder.message.EmbedBuilder
 import dev.kord.rest.json.request.EmbedRequest
diff --git a/rest/src/main/kotlin/builder/interaction/PublicInteractionBuilder.kt b/rest/src/main/kotlin/builder/interaction/PublicInteractionBuilder.kt
index f640e1de9f9..6d74df7f813 100644
--- a/rest/src/main/kotlin/builder/interaction/PublicInteractionBuilder.kt
+++ b/rest/src/main/kotlin/builder/interaction/PublicInteractionBuilder.kt
@@ -6,8 +6,8 @@ import dev.kord.common.entity.InteractionResponseType
 import dev.kord.common.entity.optional.*
 import dev.kord.common.entity.optional.delegate.delegate
 import dev.kord.rest.builder.RequestBuilder
-import dev.kord.rest.builder.components.ActionRowBuilder
-import dev.kord.rest.builder.components.MessageComponentBuilder
+import dev.kord.rest.builder.component.ActionRowBuilder
+import dev.kord.rest.builder.component.MessageComponentBuilder
 import dev.kord.rest.builder.message.AllowedMentionsBuilder
 import dev.kord.rest.builder.message.EmbedBuilder
 import dev.kord.rest.json.request.*
diff --git a/rest/src/main/kotlin/builder/interaction/UpdateMessageInteractionResponseCreateBuilder.kt b/rest/src/main/kotlin/builder/interaction/UpdateMessageInteractionResponseCreateBuilder.kt
index 1782e37f360..ffacccbc147 100644
--- a/rest/src/main/kotlin/builder/interaction/UpdateMessageInteractionResponseCreateBuilder.kt
+++ b/rest/src/main/kotlin/builder/interaction/UpdateMessageInteractionResponseCreateBuilder.kt
@@ -2,13 +2,12 @@ package dev.kord.rest.builder.interaction
 
 import dev.kord.common.annotation.KordPreview
 import dev.kord.common.entity.InteractionResponseType
-import dev.kord.common.entity.MessageFlag
 import dev.kord.common.entity.MessageFlags
 import dev.kord.common.entity.optional.*
 import dev.kord.common.entity.optional.delegate.delegate
 import dev.kord.rest.builder.RequestBuilder
-import dev.kord.rest.builder.components.ActionRowBuilder
-import dev.kord.rest.builder.components.MessageComponentBuilder
+import dev.kord.rest.builder.component.ActionRowBuilder
+import dev.kord.rest.builder.component.MessageComponentBuilder
 import dev.kord.rest.builder.message.AllowedMentionsBuilder
 import dev.kord.rest.builder.message.EmbedBuilder
 import dev.kord.rest.json.request.InteractionApplicationCommandCallbackData
diff --git a/rest/src/main/kotlin/builder/message/MessageCreateBuilder.kt b/rest/src/main/kotlin/builder/message/MessageCreateBuilder.kt
index eaeaaa0f5ec..f5924cf31f4 100644
--- a/rest/src/main/kotlin/builder/message/MessageCreateBuilder.kt
+++ b/rest/src/main/kotlin/builder/message/MessageCreateBuilder.kt
@@ -9,8 +9,8 @@ import dev.kord.common.entity.optional.OptionalSnowflake
 import dev.kord.common.entity.optional.delegate.delegate
 import dev.kord.common.entity.optional.map
 import dev.kord.rest.builder.RequestBuilder
-import dev.kord.rest.builder.components.ActionRowBuilder
-import dev.kord.rest.builder.components.MessageComponentBuilder
+import dev.kord.rest.builder.component.ActionRowBuilder
+import dev.kord.rest.builder.component.MessageComponentBuilder
 import dev.kord.rest.json.request.MessageCreateRequest
 import dev.kord.rest.json.request.MultipartMessageCreateRequest
 import kotlinx.coroutines.Dispatchers
diff --git a/rest/src/main/kotlin/builder/message/MessageModifyBuilder.kt b/rest/src/main/kotlin/builder/message/MessageModifyBuilder.kt
index 6971895acca..d1bba58cabf 100644
--- a/rest/src/main/kotlin/builder/message/MessageModifyBuilder.kt
+++ b/rest/src/main/kotlin/builder/message/MessageModifyBuilder.kt
@@ -7,8 +7,8 @@ import dev.kord.common.entity.optional.Optional
 import dev.kord.common.entity.optional.delegate.delegate
 import dev.kord.common.entity.optional.mapNullable
 import dev.kord.rest.builder.RequestBuilder
-import dev.kord.rest.builder.components.ActionRowBuilder
-import dev.kord.rest.builder.components.MessageComponentBuilder
+import dev.kord.rest.builder.component.ActionRowBuilder
+import dev.kord.rest.builder.component.MessageComponentBuilder
 import dev.kord.rest.json.request.MessageEditPatchRequest
 import kotlin.contracts.ExperimentalContracts
 import kotlin.contracts.InvocationKind

From 89ee61fae356df901197799ddb54919618dfc411 Mon Sep 17 00:00:00 2001
From: BartArys <mysterybtdn@gmail.com>
Date: Sat, 12 Jun 2021 14:54:13 +0200
Subject: [PATCH 20/22] Fix interaction embeds optionality

---
 .../kotlin/builder/interaction/EphemeralInteractionBuilders.kt  | 2 +-
 .../main/kotlin/builder/interaction/PublicInteractionBuilder.kt | 2 +-
 rest/src/main/kotlin/json/request/InteractionsRequests.kt       | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/rest/src/main/kotlin/builder/interaction/EphemeralInteractionBuilders.kt b/rest/src/main/kotlin/builder/interaction/EphemeralInteractionBuilders.kt
index 5c6a903def7..beee94c5584 100644
--- a/rest/src/main/kotlin/builder/interaction/EphemeralInteractionBuilders.kt
+++ b/rest/src/main/kotlin/builder/interaction/EphemeralInteractionBuilders.kt
@@ -81,7 +81,7 @@ class EphemeralInteractionResponseCreateBuilder : BaseInteractionResponseCreateB
         val data = InteractionApplicationCommandCallbackData(
             content = _content,
             flags = flags,
-            embeds = embeds.map { it.toRequest() }
+            embeds = Optional.missingOnEmpty(embeds.map { it.toRequest() })
         )
         return MultipartInteractionResponseCreateRequest(
             InteractionResponseCreateRequest(type, data.optional())
diff --git a/rest/src/main/kotlin/builder/interaction/PublicInteractionBuilder.kt b/rest/src/main/kotlin/builder/interaction/PublicInteractionBuilder.kt
index a30c54fd32b..b3d6f591015 100644
--- a/rest/src/main/kotlin/builder/interaction/PublicInteractionBuilder.kt
+++ b/rest/src/main/kotlin/builder/interaction/PublicInteractionBuilder.kt
@@ -90,7 +90,7 @@ class PublicInteractionResponseCreateBuilder :
                     type,
                 InteractionApplicationCommandCallbackData(
                     content = _content,
-                    embeds = embeds.map { it.toRequest() },
+                    embeds = Optional.missingOnEmpty(embeds.map { it.toRequest() }),
                     allowedMentions = _allowedMentions.map { it.build() },
                     tts = _tts,
                     components = Optional.missingOnEmpty(components.map { it.build() })
diff --git a/rest/src/main/kotlin/json/request/InteractionsRequests.kt b/rest/src/main/kotlin/json/request/InteractionsRequests.kt
index 5a675ef7646..1917588a566 100644
--- a/rest/src/main/kotlin/json/request/InteractionsRequests.kt
+++ b/rest/src/main/kotlin/json/request/InteractionsRequests.kt
@@ -63,7 +63,7 @@ data class MultipartInteractionResponseCreateRequest(
 class InteractionApplicationCommandCallbackData(
     val tts: OptionalBoolean = OptionalBoolean.Missing,
     val content: Optional<String> = Optional.Missing(),
-    val embeds: List<EmbedRequest> = emptyList(),
+    val embeds: Optional<List<EmbedRequest>> = Optional.Missing(),
     @SerialName("allowed_mentions")
     val allowedMentions: Optional<AllowedMentions> = Optional.Missing(),
     val flags: Optional<MessageFlags> = Optional.Missing(),

From 175e06ec90748f45805acbbf5a7df8c55c47ebcb Mon Sep 17 00:00:00 2001
From: BartArys <mysterybtdn@gmail.com>
Date: Sat, 12 Jun 2021 16:51:02 +0200
Subject: [PATCH 21/22] Make CommandInteraction#guildId optional

---
 common/src/main/kotlin/entity/Interactions.kt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/common/src/main/kotlin/entity/Interactions.kt b/common/src/main/kotlin/entity/Interactions.kt
index f13f85c7fc3..571e4c11e09 100644
--- a/common/src/main/kotlin/entity/Interactions.kt
+++ b/common/src/main/kotlin/entity/Interactions.kt
@@ -162,7 +162,7 @@ class DiscordInteraction(
     val applicationId: Snowflake,
     val data: InteractionCallbackData,
     @SerialName("guild_id")
-    val guildId: OptionalSnowflake,
+    val guildId: OptionalSnowflake = OptionalSnowflake.Missing,
     @SerialName("channel_id")
     val channelId: Snowflake,
     val member: Optional<DiscordInteractionGuildMember> = Optional.Missing(),

From f1e310ea6d4a7f107c13a281ece2061e0fb3bd8b Mon Sep 17 00:00:00 2001
From: BartArys <mysterybtdn@gmail.com>
Date: Sat, 12 Jun 2021 17:13:13 +0200
Subject: [PATCH 22/22] Make MessageModifyBuilder components vals

---
 rest/src/main/kotlin/builder/message/MessageModifyBuilder.kt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rest/src/main/kotlin/builder/message/MessageModifyBuilder.kt b/rest/src/main/kotlin/builder/message/MessageModifyBuilder.kt
index d1bba58cabf..b75b7721655 100644
--- a/rest/src/main/kotlin/builder/message/MessageModifyBuilder.kt
+++ b/rest/src/main/kotlin/builder/message/MessageModifyBuilder.kt
@@ -30,7 +30,7 @@ class MessageModifyBuilder : RequestBuilder<MessageEditPatchRequest> {
     var allowedMentions: AllowedMentionsBuilder? by ::_allowedMentions.delegate()
 
     @KordPreview
-    var components: MutableList<MessageComponentBuilder> = mutableListOf()
+    val components: MutableList<MessageComponentBuilder> = mutableListOf()
 
     @OptIn(ExperimentalContracts::class)
     inline fun embed(block: EmbedBuilder.() -> Unit) {