Slash commands

[HopeBaron]

What this PR should Implement

• Gateways related to slash commands.
• REST endpoints
• Core representations

Issues encountered

Slash Commands and Interactions bring something entirely new to the table: the ability to interact with an application without needing a bot user in the guild. As you read through this documentation, you'll see that bot tokens are only referenced as a helpful alternative to doing a client credentials auth flow. Slash Commands do not depend on a bot user in the guild; responding to interactions does not require a bot token.

As the Discord docs states , neither a slash command doesn't depend on a bot user, nor a bot user requires a slash commands to work.

Solutions proposed

One simple solution to the problem, is to allow applicationId be nullable as follows:

    suspend fun createGlobalApplicationCommand(
        name: String,
        description: String,
        builder: GlobalApplicationCommandCreateBuilder.() -> Unit
    ) {
        if(resources.applicationId == null) throw IllegalArgumentException("applicationId must not be null")
        val request = GlobalApplicationCommandCreateBuilder(name, description).apply(builder).toRequest()
        rest.interaction.createGlobalApplicationCommand(applicationId, request)
    }

But this wouldn't provide the user with a useful message or warning if the applicationId was null. In addition, this would require to validate applicationId each time we work with it.

---

Provide an annotation warning the same way we did for intents.
However annotations can be ignored and do not provide a strict message as well.

---

Move interactions into their own class that works along side Kord e.g: SlashCommands

This is the best solution we have at the moment.
The problem is that this solution limts Kord's control over slash commands overall.

val commands: SlashCommands = Kord.toSlashCommand(appId: String)

if we were going to use this object to create a command from message, or any other context we will need to keep a reference and limits the flexibility of code writing.

[HopeBaron]

The team agreed on the following solution:

• A rest-only entity which is responsible for application commands created (currently named SlashCommands)
  This would allow creating, editing, or deleting slash command's related records without a gateway.

• Kord will allow a nullable appId

• Two versions of Interaction events will be created.

Interaction - offers data from the INTERACTION_CREATE event with no functionality (Kord will use this if appId is null)
InteractionBehavior - offers data, with functionality, and derives from Interaction

How does this solve the problem

Kord will introduce a event handler for the interaction create event, which keeps track of the nullity of the appId. In-case the appId was null, the event handler won't emit an InteractionBehavior object. A filtered flow for that event will always be empty. Otherwise, the user will be able to pick both events from the event flow.

Below are some code samples

val kord = Kord(bot_id) { appid = null }
kord.on<InteractionBehavior> {  // flow will always be empty since `appId` is null

}

val kord = Kord(bot_id) { appid = null }
kord.on<Interaction> {  // flow emits even if appId is null

}

val kord = Kord(bot_id) { appid = appId }
kord.on<InteractionBehavior> {  // flow emits since appId is not null

}

[BartArys]

Looks good for the most part, missed quite a few @KordPreview in the gateway module though.