diff --git a/buildSrc/build.gradle.kts b/buildSrc/build.gradle.kts
index 240797827ad..35ff91e53c9 100644
--- a/buildSrc/build.gradle.kts
+++ b/buildSrc/build.gradle.kts
@@ -14,4 +14,4 @@ dependencies {
     implementation(kotlin("gradle-plugin-api", version = "1.5.0"))
     implementation(gradleApi())
     implementation(localGroovy())
-}
\ No newline at end of file
+}
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/DiscordMessage.kt b/common/src/main/kotlin/entity/DiscordMessage.kt
index 9fc5d7f3a2f..dfaca152950 100644
--- a/common/src/main/kotlin/entity/DiscordMessage.kt
+++ b/common/src/main/kotlin/entity/DiscordMessage.kt
@@ -63,6 +63,7 @@ import kotlin.contracts.contract
  * @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(
@@ -103,6 +104,11 @@ data class DiscordMessage(
     val stickers: Optional<List<DiscordMessageSticker>> = Optional.Missing(),
     @SerialName("referenced_message")
     val referencedMessage: Optional<DiscordMessage?> = 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(),
     val interaction: Optional<DiscordMessageInteraction> = Optional.Missing()
 )
 
diff --git a/common/src/main/kotlin/entity/Interactions.kt b/common/src/main/kotlin/entity/Interactions.kt
index 80f4130d371..571e4c11e09 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;
@@ -157,12 +156,11 @@ 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,
     @SerialName("channel_id")
@@ -171,18 +169,59 @@ data 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
 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)"
     }
 
@@ -196,6 +235,7 @@ sealed class InteractionType(val type: Int) {
             return when (val type = decoder.decodeInt()) {
                 1 -> Ping
                 2 -> ApplicationCommand
+                3 -> Component
                 else -> Unknown(type)
             }
         }
@@ -208,18 +248,22 @@ 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)
 @KordPreview
 sealed class Option {
     abstract val name: String
+    abstract val type: ApplicationCommandOptionType
 
     internal object Serializer : KSerializer<Option> {
 
@@ -227,6 +271,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 +279,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 +297,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())
-            }
+            requireNotNull(type) { "'type' expected for $name but was absent" }
 
-            //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()
+            return when (type) {
+                ApplicationCommandOptionType.SubCommand -> {
+                    val options = if (jsonOptions == null) Optional.Missing()
+                    else Optional.Value(jsonOptions!!.map {
+                        json.decodeFromJsonElement(serializer(), it) as CommandArgument<*>
+                    })
 
-            if (nestedOptions.isEmpty()) { //only subcommands can have no children
-                return SubCommand(name, Optional(emptyList()))
-            }
-
-            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,97 +366,232 @@ 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)"
+    }
+
+    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)"
+    }
+
+    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)"
     }
 
-    internal class OptionValueSerializer<T>(serializer: KSerializer<T>) : KSerializer<DiscordOptionValue<*>> {
-        override val descriptor: SerialDescriptor = PrimitiveSerialDescriptor("OptionValue", PrimitiveKind.STRING)
+    class RoleArgument(
+        override val name: String,
+        override val value: Snowflake
+    ) : CommandArgument<Snowflake>() {
+        override val type: ApplicationCommandOptionType
+            get() = ApplicationCommandOptionType.Role
 
-        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)
+        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)
 }
 
-
 @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;
@@ -389,6 +606,8 @@ sealed class InteractionResponseType(val type: Int) {
                 1 -> Pong
                 4 -> ChannelMessageWithSource
                 5 -> DeferredChannelMessageWithSource
+                6 -> DeferredUpdateMessage
+                7 -> UpdateMessage
                 else -> Unknown(type)
             }
         }
@@ -396,11 +615,9 @@ sealed class InteractionResponseType(val type: Int) {
         override fun serialize(encoder: Encoder, value: InteractionResponseType) {
             encoder.encodeInt(value.type)
         }
-
     }
 }
 
-
 @KordPreview
 @Serializable
 data class DiscordGuildApplicationCommandPermissions(
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/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/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))
             }
         }
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/GlobalApplicationCommandBehavior.kt b/core/src/main/kotlin/behavior/GlobalApplicationCommandBehavior.kt
index 72a0d953b6e..e5c433e6fc4 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)
     }
@@ -99,7 +111,6 @@ fun GuildApplicationCommandBehavior(
         get() = id
 }
 
-
 @KordPreview
 fun GlobalApplicationCommandBehavior(
     applicationId: Snowflake,
@@ -112,4 +123,4 @@ fun GlobalApplicationCommandBehavior(
         get() = service
     override val id: Snowflake
         get() = id
-}
\ No newline at end of file
+}
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/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)
 
 }
 
diff --git a/core/src/main/kotlin/builder/component/ButtonBuilderExtensions.kt b/core/src/main/kotlin/builder/component/ButtonBuilderExtensions.kt
new file mode 100644
index 00000000000..05cd6eb80dd
--- /dev/null
+++ b/core/src/main/kotlin/builder/component/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.component.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/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/InteractionData.kt b/core/src/main/kotlin/cache/data/InteractionData.kt
index 18a0b562298..4884442ee9d 100644
--- a/core/src/main/kotlin/cache/data/InteractionData.kt
+++ b/core/src/main/kotlin/cache/data/InteractionData.kt
@@ -2,10 +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 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
@@ -18,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 {
@@ -34,14 +49,18 @@ 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!!) },
-                    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
+                    version,
+                    message.map {
+                        MessageData.from(it)
+                    }
                 )
             }
         }
@@ -68,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
                 )
-
             }
         }
     }
@@ -100,15 +121,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/cache/data/MessageData.kt b/core/src/main/kotlin/cache/data/MessageData.kt
index c85ff39b828..0607a90a7eb 100644
--- a/core/src/main/kotlin/cache/data/MessageData.kt
+++ b/core/src/main/kotlin/cache/data/MessageData.kt
@@ -36,7 +36,8 @@ data class MessageData(
     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 interaction: Optional<MessageInteractionData> = Optional.Missing(),
+    val components: Optional<List<ComponentData>> = Optional.Missing()
 ) {
 
     fun plus(selfId: Snowflake, reaction: MessageReactionAddData): MessageData {
@@ -103,7 +104,8 @@ data class MessageData(
             flags,
             stickers = stickers,
             referencedMessage = referencedMessage,
-            interaction = interaction
+            interaction = interaction,
+            components = components
         )
     }
 
@@ -138,10 +140,11 @@ data class MessageData(
                 flags,
                 stickers.mapList { MessageStickerData.from(it) },
                 referencedMessage.mapNotNull { from(it) },
-                interaction.map { MessageInteractionData.from(it) }
+                interaction.map { MessageInteractionData.from(it) },
+                components = components.mapList { ComponentData.from(it) }
             )
         }
     }
 }
 
-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/entity/Message.kt b/core/src/main/kotlin/entity/Message.kt
index 96bd7debbfd..cadb15a09e1 100644
--- a/core/src/main/kotlin/entity/Message.kt
+++ b/core/src/main/kotlin/entity/Message.kt
@@ -3,9 +3,9 @@ package dev.kord.core.entity
 import dev.kord.common.annotation.KordPreview
 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
@@ -16,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
@@ -108,7 +109,7 @@ class Message(
     /**
      * If the message is a response to an [Interaction], this is the id of the interaction's application
      */
-    val applicationId: Snowflake? get() = data.applicationId.value
+    val applicationId: Snowflake? get() = data.application.unwrap { it.id }
 
     /**
      * The message being replied to.
@@ -232,6 +233,10 @@ class Message(
      */
     val webhookId: Snowflake? get() = data.webhookId.value
 
+    @KordPreview
+    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)"
+
+}
diff --git a/core/src/main/kotlin/entity/interaction/Interaction.kt b/core/src/main/kotlin/entity/interaction/Interaction.kt
index 714acf4dcc9..a399fa2acf3 100644
--- a/core/src/main/kotlin/entity/interaction/Interaction.kt
+++ b/core/src/main/kotlin/entity/interaction/Interaction.kt
@@ -1,11 +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.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,18 +10,26 @@ 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.cache.data.ApplicationCommandInteractionData
+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
+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.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.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.core.toSnowflakeOrNull
+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)
@@ -52,35 +56,53 @@ 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
      */
     val version: Int get() = data.version
 
+    abstract override fun withStrategy(strategy: EntitySupplyStrategy<*>): Interaction
+
     companion object {
         fun from(
             data: InteractionData,
             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.
  */
@@ -105,7 +127,7 @@ sealed class InteractionCommand : KordObject {
 }
 
 fun InteractionCommand(
-    data: ApplicationCommandInteractionData,
+    data: ApplicationInteractionData,
     kord: Kord
 ): InteractionCommand {
     val firstLevelOptions = data.options.orEmpty()
@@ -129,14 +151,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()
@@ -152,16 +174,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.
@@ -170,7 +192,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?
@@ -184,7 +206,7 @@ class SubCommand(
  */
 @KordPreview
 class GroupCommand(
-    val data: ApplicationCommandInteractionData,
+    val data: ApplicationInteractionData,
     override val kord: Kord
 ) : InteractionCommand() {
 
@@ -192,9 +214,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.
@@ -208,7 +230,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?
@@ -229,49 +251,85 @@ 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)
         }
     }
 }
@@ -286,11 +344,60 @@ class DmInteraction(
     override val applicationId: Snowflake,
     override val kord: Kord,
     override val supplier: EntitySupplier = kord.defaultSupplier,
-) : Interaction() {
+) : CommandInteraction() {
     /**
      * 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))
+}
+
+/**
+ * An [Interaction] that was made with a [Component].
+ */
+@KordPreview
+class ComponentInteraction(
+    override val data: InteractionData,
+    override val applicationId: Snowflake,
+    override val kord: Kord,
+    override val supplier: EntitySupplier
+) : Interaction(), ComponentInteractionBehavior {
+
+    override val user: UserBehavior = UserBehavior(data.member.value!!.userId, kord)
+
+    /**
+     * 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 [ButtonComponent.customId] that triggered the interaction.
+     */
+    val componentId: String get() = data.data.customId.value!!
+
+    /**
+     * The [ButtonComponent] the user interacted with, null if the message is ephemeral.
+     *
+     * @see Component
+     */
+    val component: ButtonComponent
+        get() = message?.components.orEmpty()
+            .filterIsInstance<ButtonComponent>().first { it.customId == componentId }
+
+
+    override fun withStrategy(strategy: EntitySupplyStrategy<*>): ComponentInteraction = ComponentInteraction(
+        data, applicationId, kord, strategy.supply(kord)
+    )
+
+    override fun toString(): String {
+        return "ComponentInteraction(data=$data, applicationId=$applicationId, kord=$kord, supplier=$supplier, user=$user)"
+    }
+
 }
 
 @KordPreview
@@ -299,7 +406,7 @@ class GuildInteraction(
     override val applicationId: Snowflake,
     override val kord: Kord,
     override val supplier: EntitySupplier
-) : Interaction(), GuildInteractionBehavior {
+) : CommandInteraction(), GuildInteractionBehavior {
 
     override val guildId: Snowflake
         get() = data.guildId.value!!
@@ -317,7 +424,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)
@@ -325,6 +436,8 @@ class GuildInteraction(
     override val user: UserBehavior
         get() = UserBehavior(member.id, kord)
 
+    override fun withStrategy(strategy: EntitySupplyStrategy<*>): GuildInteraction =
+        GuildInteraction(data, applicationId, kord, supplier)
 
 }
 
diff --git a/core/src/main/kotlin/entity/interaction/MessageInteraction.kt b/core/src/main/kotlin/entity/interaction/MessageInteraction.kt
index 280614b10a6..dbc82e78480 100644
--- a/core/src/main/kotlin/entity/interaction/MessageInteraction.kt
+++ b/core/src/main/kotlin/entity/interaction/MessageInteraction.kt
@@ -31,7 +31,7 @@ class MessageInteraction(
     override val id: Snowflake get() = data.id
 
     /**
-     * 	the [name][ApplicationCommand.name] of the [ApplicationCommand] that triggered this message.
+     * the [name][ApplicationCommand.name] of the [ApplicationCommand] that triggered this message.
      */
     val name: String get() = data.name
 
diff --git a/core/src/test/kotlin/interaction/CommandTypesTest.kt b/core/src/test/kotlin/interaction/CommandTypesTest.kt
index b9af24e79d8..47eb27f2042 100644
--- a/core/src/test/kotlin/interaction/CommandTypesTest.kt
+++ b/core/src/test/kotlin/interaction/CommandTypesTest.kt
@@ -1,8 +1,9 @@
 package interaction
 
 import dev.kord.common.annotation.KordPreview
-import dev.kord.common.entity.DiscordApplicationCommandInteractionData
-import dev.kord.core.cache.data.ApplicationCommandInteractionData
+import dev.kord.common.entity.ApplicationCommandOptionType
+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
@@ -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) }
             }
@@ -44,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
@@ -56,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
@@ -69,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/rest/src/main/kotlin/builder/component/ActionRowBuilder.kt b/rest/src/main/kotlin/builder/component/ActionRowBuilder.kt
new file mode 100644
index 00000000000..074b1a5bea3
--- /dev/null
+++ b/rest/src/main/kotlin/builder/component/ActionRowBuilder.kt
@@ -0,0 +1,52 @@
+package dev.kord.rest.builder.component
+
+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(style, customId).apply(builder)
+        )
+    }
+
+    @OptIn(ExperimentalContracts::class)
+    inline fun linkButton(
+        url: String,
+        builder: ButtonBuilder.LinkButtonBuilder.() -> Unit
+    ) {
+        contract {
+            callsInPlace(builder, InvocationKind.EXACTLY_ONCE)
+        }
+
+        components.add(
+            ButtonBuilder.LinkButtonBuilder(url).apply(builder)
+        )
+    }
+
+    override fun build(): DiscordComponent =
+        DiscordComponent(
+            ComponentType.ActionRow,
+            components = Optional.missingOnEmpty(components.map(ActionRowComponentBuilder::build))
+        )
+}
diff --git a/rest/src/main/kotlin/builder/component/ButtonBuilder.kt b/rest/src/main/kotlin/builder/component/ButtonBuilder.kt
new file mode 100644
index 00000000000..e3e1d1e3f46
--- /dev/null
+++ b/rest/src/main/kotlin/builder/component/ButtonBuilder.kt
@@ -0,0 +1,90 @@
+package dev.kord.rest.builder.component
+
+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
+
+@KordDsl
+@KordPreview
+sealed class ButtonBuilder : ActionRowComponentBuilder {
+
+    /**
+     * 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),
+        )
+
+    }
+
+    /**
+     * 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),
+        )
+
+    }
+
+}
diff --git a/rest/src/main/kotlin/builder/component/ComponentBuilders.kt b/rest/src/main/kotlin/builder/component/ComponentBuilders.kt
new file mode 100644
index 00000000000..1dff82e5345
--- /dev/null
+++ b/rest/src/main/kotlin/builder/component/ComponentBuilders.kt
@@ -0,0 +1,15 @@
+package dev.kord.rest.builder.component
+
+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/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 d131c56964a..beee94c5584 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.InteractionResponseType
 import dev.kord.common.entity.MessageFlag
@@ -7,8 +8,9 @@ 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.mapList
 import dev.kord.common.entity.optional.optional
+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.*
@@ -16,6 +18,7 @@ import kotlin.contracts.ExperimentalContracts
 import kotlin.contracts.InvocationKind
 import kotlin.contracts.contract
 
+@KordDsl
 @KordPreview
 class EphemeralInteractionResponseModifyBuilder : BaseInteractionResponseModifyBuilder {
     private var _content: Optional<String> = Optional.Missing()
@@ -23,23 +26,40 @@ class EphemeralInteractionResponseModifyBuilder : BaseInteractionResponseModifyB
 
     override val embeds: MutableList<EmbedBuilder> = mutableListOf()
 
-
     private var _allowedMentions: Optional<AllowedMentionsBuilder> = Optional.Missing()
     override var allowedMentions: AllowedMentionsBuilder? by ::_allowedMentions.delegate()
 
+    val components: MutableList<MessageComponentBuilder> = mutableListOf()
+
+    @OptIn(ExperimentalContracts::class)
+    inline fun allowedMentions(builder: AllowedMentionsBuilder.() -> Unit) {
+        contract { callsInPlace(builder, InvocationKind.EXACTLY_ONCE) }
+        allowedMentions = (allowedMentions ?: AllowedMentionsBuilder()).apply(builder)
+    }
+
+    @OptIn(ExperimentalContracts::class)
+    @KordPreview
+    inline fun actionRow(builder: ActionRowBuilder.() -> Unit) {
+        contract {
+            callsInPlace(builder, InvocationKind.EXACTLY_ONCE)
+        }
+
+        components.add(ActionRowBuilder().apply(builder))
+    }
+
     override fun toRequest(): MultipartInteractionResponseModifyRequest {
         return MultipartInteractionResponseModifyRequest(
             InteractionResponseModifyRequest(
                 content = _content,
                 allowedMentions = _allowedMentions.map { it.build() },
+                components = Optional.missingOnEmpty(components.map { it.build() }),
                 embeds = embeds.map { it.toRequest() }
             )
         )
-
     }
 }
 
-
+@KordDsl
 @KordPreview
 class EphemeralInteractionResponseCreateBuilder : BaseInteractionResponseCreateBuilder {
     private var _content: Optional<String> = Optional.Missing()
@@ -61,11 +81,11 @@ 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())
         )
 
     }
-}
\ 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 98253461e42..4f6676b20e3 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.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.*
+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))
         )
     }
 }
@@ -123,12 +145,14 @@ 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()
 
+    val components: MutableList<MessageComponentBuilder> = mutableListOf()
+
     fun addFile(name: String, content: InputStream) {
         files += name to content
     }
@@ -137,6 +161,27 @@ 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)
+    @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 {
@@ -151,7 +196,8 @@ class PublicFollowupMessageCreateBuilder : RequestBuilder<MultipartFollowupMessa
                 content = _content,
                 tts = _tts,
                 embeds = Optional.missingOnEmpty(embeds),
-                allowedMentions = _allowedMentions
+                allowedMentions = _allowedMentions.map { it.build() },
+                components = Optional.missingOnEmpty(components.map(MessageComponentBuilder::build))
             ),
             files,
         )
@@ -167,15 +213,39 @@ 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()
+
+    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
+     * 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)
+    @KordPreview
+    inline fun actionRow(builder: ActionRowBuilder.() -> Unit) {
+        contract {
+            callsInPlace(builder, InvocationKind.EXACTLY_ONCE)
+        }
+
+        components.add(ActionRowBuilder().apply(builder))
+    }
 
     override fun toRequest(): MultipartFollowupMessageCreateRequest =
         MultipartFollowupMessageCreateRequest(
             FollowupMessageCreateRequest(
                 content = Optional.Value(content),
                 tts = _tts,
-                allowedMentions = _allowedMentions
+                allowedMentions = _allowedMentions.map { it.build() },
+                components = Optional.missingOnEmpty(components.map(MessageComponentBuilder::build))
             ),
         )
 
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) {
diff --git a/rest/src/main/kotlin/builder/interaction/PublicInteractionBuilder.kt b/rest/src/main/kotlin/builder/interaction/PublicInteractionBuilder.kt
index 5440e66c2e3..b3d6f591015 100644
--- a/rest/src/main/kotlin/builder/interaction/PublicInteractionBuilder.kt
+++ b/rest/src/main/kotlin/builder/interaction/PublicInteractionBuilder.kt
@@ -8,6 +8,8 @@ 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.optional
+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.*
@@ -16,11 +18,14 @@ 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
 @KordDsl
 class PublicInteractionResponseCreateBuilder :
-   BaseInteractionResponseCreateBuilder {
+    BaseInteractionResponseCreateBuilder {
     private var _content: Optional<String> = Optional.Missing()
     override var content: String? by ::_content.delegate()
 
@@ -33,9 +38,40 @@ 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()
 
 
+    /**
+     * 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) }
+        if (embeds == null) embeds = mutableListOf()
+        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
     }
@@ -51,12 +87,13 @@ class PublicInteractionResponseCreateBuilder :
 
         return MultipartInteractionResponseCreateRequest(
             InteractionResponseCreateRequest(
-                type,
+                    type,
                 InteractionApplicationCommandCallbackData(
                     content = _content,
-                    embeds = embeds.map { it.toRequest() },
+                    embeds = Optional.missingOnEmpty(embeds.map { it.toRequest() }),
                     allowedMentions = _allowedMentions.map { it.build() },
-                    tts = _tts
+                    tts = _tts,
+                    components = Optional.missingOnEmpty(components.map { it.build() })
                 ).optional()
             ),
             files
@@ -72,17 +109,29 @@ class PublicInteractionResponseModifyBuilder :
     private var _content: Optional<String> = Optional.Missing()
     override var content: String? by ::_content.delegate()
 
-    override var embeds: MutableList<EmbedBuilder> = mutableListOf()
+    override val embeds: MutableList<EmbedBuilder> = mutableListOf()
 
     private var _allowedMentions: Optional<AllowedMentionsBuilder> = Optional.Missing()
     override var allowedMentions: AllowedMentionsBuilder? by ::_allowedMentions.delegate()
 
     val files: MutableList<Pair<String, InputStream>> = mutableListOf()
 
+    val components: MutableList<MessageComponentBuilder> = mutableListOf()
+
     fun addFile(name: String, content: InputStream) {
         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))
     }
@@ -93,6 +142,7 @@ class PublicInteractionResponseModifyBuilder :
                 content = _content,
                 embeds = embeds.map { it.toRequest() },
                 allowedMentions = _allowedMentions.map { it.build() },
+                components = Optional.missingOnEmpty(components.map(MessageComponentBuilder::build))
             ),
             files
         )
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..ffacccbc147
--- /dev/null
+++ b/rest/src/main/kotlin/builder/interaction/UpdateMessageInteractionResponseCreateBuilder.kt
@@ -0,0 +1,98 @@
+package dev.kord.rest.builder.interaction
+
+import dev.kord.common.annotation.KordPreview
+import dev.kord.common.entity.InteractionResponseType
+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.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
+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
+        )
+
+    }
+
+}
diff --git a/rest/src/main/kotlin/builder/message/MessageCreateBuilder.kt b/rest/src/main/kotlin/builder/message/MessageCreateBuilder.kt
index 2485190ca5f..f5924cf31f4 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.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
@@ -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 actionRow(builder: ActionRowBuilder.() -> Unit) {
+        contract {
+            callsInPlace(builder, InvocationKind.EXACTLY_ONCE)
+        }
+
+        components.add(ActionRowBuilder().apply(builder))
+    }
+
+    @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..b75b7721655 100644
--- a/rest/src/main/kotlin/builder/message/MessageModifyBuilder.kt
+++ b/rest/src/main/kotlin/builder/message/MessageModifyBuilder.kt
@@ -1,13 +1,14 @@
 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.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.component.ActionRowBuilder
+import dev.kord.rest.builder.component.MessageComponentBuilder
 import dev.kord.rest.json.request.MessageEditPatchRequest
 import kotlin.contracts.ExperimentalContracts
 import kotlin.contracts.InvocationKind
@@ -28,6 +29,9 @@ class MessageModifyBuilder : RequestBuilder<MessageEditPatchRequest> {
     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(block: EmbedBuilder.() -> Unit) {
         contract {
@@ -47,8 +51,22 @@ class MessageModifyBuilder : RequestBuilder<MessageEditPatchRequest> {
         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(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/request/InteractionsRequests.kt b/rest/src/main/kotlin/json/request/InteractionsRequests.kt
index 1aff46e043b..1917588a566 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: List<EmbedRequest> = emptyList(),
     @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
@@ -62,11 +63,11 @@ 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()
-
+    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 3621de535ff..2cf1f892d52 100644
--- a/rest/src/main/kotlin/json/request/MessageRequests.kt
+++ b/rest/src/main/kotlin/json/request/MessageRequests.kt
@@ -9,11 +9,6 @@ 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(
@@ -24,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()
 )
 
 
@@ -84,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