Application Commands Documentation

docs/api.rst

@@ -40,11 +40,20 @@ Client
 
 .. autoclass:: Client
     :members:
-    :exclude-members: fetch_guilds, event
+    :exclude-members: fetch_guilds, event, slash_command, user_command, message_command
 
     .. automethod:: Client.event()
         :decorator:
 
+    .. automethod:: Client.slash_command
+        :decorator:
+
+    .. automethod:: Client.user_command
+        :decorator:
+
+    .. automethod:: Client.message_command
+        :decorator:
+
     .. automethod:: Client.fetch_guilds
         :async-for:
 
@@ -4178,6 +4187,46 @@ Select
 .. autofunction:: nextcord.ui.select
 
 
+Application Commands
+--------------------
+
+.. attributetable:: ApplicationCommand
+
+.. autoclass:: ApplicationCommand
+    :members:
+
+.. attributetable:: ApplicationSubcommand
+
+.. autoclass:: ApplicationSubcommand
+    :members:
+
+Options
+~~~~~~~
+
+.. attributetable:: CommandOption
+
+.. autoclass:: CommandOption
+    :members:
+
+.. attributetable:: SlashOption
+
+.. autoclass:: SlashOption
+    :members:
+
+Cogs
+~~~~
+
+.. autoclass:: ClientCog
+    :members:
+Decorators
+~~~~~~~~~~
+
+.. autoclass:: message_command
+
+.. autoclass:: slash_command
+
+.. autoclass:: user_command
+
 Exceptions
 ------------
 

docs/index.rst

@@ -74,6 +74,6 @@ If you're looking for something related to the project itself, it's here.
 
   whats_new
   version_guarantees
+  interactions
   migrating
-  migrating_2
-  migrating_to_nextcord
+  migrating_to_slash_commands

docs/interactions.rst

@@ -0,0 +1,131 @@
+:orphan:
+
+.. currentmodule:: nextcord
+
+.. _interactions:
+
+Slash Commands
+==============
+
+Since Discord has added interaction commands a feature with many possibilities, we at Nextcord have decided to add them to our fleet of features.
+
+This doc will explain the innerworkings and how to use interaction commmands.
+
+We suggest you learn how to make regular commands before looking through here, we suggest looking at the :doc:`quickstart`
+
+How To Make A Simple Slash Command
+----------------------------------
+
+This right here is a simple ping pong command made with Nextcords slash feature.
+
+.. code-block:: python3
+
+    @bot.slash_command(name="ping")
+    async def ping(interaction):
+        await interaction.response.send_message("Pong!")
+
+The way it works is that you use the :meth:`~Client.slash_command` function to interact with the Discord API. The ``name`` parameter is the name of your slash command.
+
+``guild_ids`` is used to limit the guilds that the slash command is available to. This is also useful for testing, as global slash commands can take up to an hour to register.
+
+Example:
+
+.. code-block:: python3
+
+    @bot.slash_command(guild_ids=[id1, id2])
+
+How To Use Sub-Commands
+-----------------------
+
+The way sub-commands work is that you make a normal slash command that will never be called, and then make the sub-commands and have them do the work of real slash commands. There is no difference with slash commands and sub-commands. The only thing you will need to change is functions.
+
+As shown in the demonstration below you make a main slash command or a dummy slash command and build sub-commands off it.
+
+.. code-block:: python3
+
+        @bot.slash_command(guild_ids=[...])  # Making the command and limiting the guilds
+        async def main(interaction):  
+        # passing through interaction and indentifing the sub-command group name
+        await interaction.response.send_message(
+        "This will never get called if this has subcommands."
+            )  # a function never called
+
+
+        @main.subcommand()  # Identifying The Sub-Command
+        async def sub1(interaction):  # Making The Sub Command Name And Passing Through Interaction
+        await interaction.response.send_message(
+            "This is subcommand 1!"
+            )  # Sending A Response
+
+
+        @main.subcommand(description="Aha! Another subcommand")  
+        # Identifying The Sub-Command And Adding A Descripton
+        async def subcommand_two(interaction: Interaction):  # Passing in interaction
+
+        await interaction.response.send_message(
+            "This is subcommand 2!"
+            )       # Responding With The Args/Fields
+
+Fields And Requirements
+-----------------------
+Fields are meant to facilitate an easier way to fill info, letting people using your slash command get a different response for each answer.
+
+Nextcord's implementation of slash commands has fields and is very simple. in the example below is a field.
+
+.. code-block:: python3
+
+     @bot.slash_command(name="help")
+     async def help(
+         interaction: Interaction,
+         setting: str = SlashOption(name="settings", description="Configure Your Settings")
+     ):
+         if setting == "music":
+             await interaction.response.send_message(f"Sorry we aren't connected to lavalink currently")
+         elif setting == "moderation":
+             await interaction.response.send_message(f"Moderation?")
+         else:
+             await interaction.response.send_message("Odd, I don't know that setting")
+
+
+How To Make Slash Commands In Cogs
+----------------------------------
+Show below is an example of a simple command running in a cog.
+
+.. code-block:: python3
+
+    class ExampleCog(commands.Cog):
+        def __init__(self):
+            self.count = 0
+
+        @slash_command(name="cogexample")
+        async def slash_example_cog_command(self, interaction):
+            await interaction.response.send_message("Hello i am a slash command in a cog!")
+
+The example shown above responds to a user when they do a slash command. It is identical to a normal slash command and to normal commands in general.
+
+How To Make Context Menu Commands
+---------------------------------
+Context Menu commands display commands on a menu of a message/user.
+
+User Commands
+~~~~~~~~~~~~~~
+What you see below is a example of a simple user command.
+It is a user dump command that dumps user data.
+
+.. code-block:: python3
+
+    @bot.user_command(name="dump")
+    async def userdump(interaction, member):
+        await interaction.response.send_message(f"Member: {member}, Data Dump: {interaction.data}")
+
+Message Commands
+~~~~~~~~~~~~~~~~~
+What you see below is a example of a simple message command, 
+It's a message dump command that dumps message data.
+
+.. code-block:: python3
+
+    @bot.message_command(name="dump")
+    async def messagedump(interaction, message: Message):
+        await interaction.response.send_message(f"Data Dump: {interaction.data}")
+