Merge branch 'release/3.x' of https://github.com/Discord-Net-Labs/Discord.Net-Labs into v3-final

CONTRIBUTING.md

@@ -17,7 +17,7 @@ any member of the community.
 
 We prefer pull-requests that are descriptive of the changes being made
 and highlight any potential benefits/drawbacks of the change, but these
-types of write-ups are not required. See this [merge request](https://github.com/RogueException/Discord.Net/pull/793)
+types of write-ups are not required. See this [merge request](https://github.com/discord-net/Discord.Net/pull/793)
 for an example of a well-written description.
 
 ## Semantic Versioning
@@ -28,7 +28,7 @@ that are SemVer compliant with the latest version of the library in
 development.
 
 The working release should be the latest build off of the `dev` branch,
-but can also be found on the [development board](https://github.com/RogueException/Discord.Net/projects/1).
+but can also be found on the [development board](https://github.com/discord-net/Discord.Net/projects/1).
 
 We follow the .NET Foundation's [Breaking Change Rules](https://github.com/dotnet/corefx/blob/master/Documentation/coding-guidelines/breaking-change-rules.md)
 when determining the SemVer compliance of a change.
@@ -59,4 +59,4 @@ The length of the documentation should also follow the ruler as suggested by our
 #### Recommended Reads
 
 * [Official Microsoft Documentation](https://docs.microsoft.com)
-* [Sandcastle User Manual](https://ewsoftware.github.io/XMLCommentsGuide/html/4268757F-CE8D-4E6D-8502-4F7F2E22DDA3.htm)
+* [Sandcastle User Manual](https://ewsoftware.github.io/XMLCommentsGuide/html/4268757F-CE8D-4E6D-8502-4F7F2E22DDA3.htm)

README.md

@@ -31,6 +31,10 @@ The individual components may also be installed from NuGet:
 
 Nightly builds are available through our MyGet feed (`https://www.myget.org/F/discord-net/api/v3/index.json`).
 
+### Unstable (Labs)
+
+Labs builds are avaiable on nuget (`https://www.nuget.org/packages/Discord.Net.Labs/`) and myget (`https://www.myget.org/F/discord-net-labs/api/v3/index.json`).
+
 ## Compiling
 
 In order to compile Discord.Net, you require the following:
@@ -64,4 +68,4 @@ Due to the nature of the Discord API, we will oftentimes need to add a property
 
 Furthermore, while we will never break the API (outside of interface changes) on minor builds, we will occasionally need to break the ABI, by introducing parameters to a method to match changes upstream with Discord. As such, a minor version increment may require you to recompile your code, and dependencies, such as addons, may also need to be recompiled and republished on the newer version. When a binary breaking change is made, the change will be noted in the release notes.
 
-An increment of the MAJOR component indicates that breaking changes have been made to the library; consumers should check the release notes to determine what changes need to be made.
+An increment of the MAJOR component indicates that breaking changes have been made to the library; consumers should check the release notes to determine what changes need to be made.

docs/_overwrites/Commands/ICommandContext.Inclusion.md

@@ -1,5 +1,5 @@
 An example of how this class is used the command system can be seen 
 below:
 
-[!code[Sample module](../../guides/commands/samples/intro/empty-module.cs)]
-[!code[Command handler](../../guides/commands/samples/intro/command_handler.cs)]
+[!code[Sample module](../../guides/text_commands/samples/intro/empty-module.cs)]
+[!code[Command handler](../../guides/text_commands/samples/intro/command_handler.cs)]

docs/docfx.json

@@ -1,19 +1,22 @@
 {
-  "metadata": [{
-    "src": [{
-      "src": "../src",
-      "files": [
-        "**.csproj"
-      ]
-    }],
-    "dest": "api",
-    "filter": "filterConfig.yml",
-    "properties": {
-      "TargetFramework": "netstandard2.0"
+  "metadata": [
+    {
+      "src": [
+        {
+          "src": "../src",
+          "files": ["**.csproj"]
+        }
+      ],
+      "dest": "api",
+      "filter": "filterConfig.yml",
+      "properties": {
+        "TargetFramework": "netstandard2.0"
+      }
     }
-  }],
+  ],
   "build": {
-    "content": [{
+    "content": [
+      {
         "files": ["api/**.yml", "api/index.md"]
       },
       {
@@ -27,19 +30,33 @@
       },
       {
         "src": "../",
-        "files": [ "CHANGELOG.md" ]
+        "files": ["CHANGELOG.md"]
+      }
+    ],
+    "resource": [
+      {
+        "files": [
+          "**/images/**",
+          "**/samples/**",
+          "langwordMapping.yml",
+          "marketing/logo/**.svg",
+          "marketing/logo/**.png",
+          "favicon.ico"
+        ]
+      }
+    ],
+    "resource": [
+      {
+        "files": [
+          "**/images/**",
+          "**/samples/**",
+          "langwordMapping.yml",
+          "marketing/logo/**.svg",
+          "marketing/logo/**.png",
+          "favicon.ico"
+        ]
       }
     ],
-    "resource": [{
-      "files": [
-        "**/images/**",
-        "**/samples/**",
-        "langwordMapping.yml",
-        "marketing/logo/**.svg",
-        "marketing/logo/**.png",
-        "favicon.ico"
-      ]
-    }],
     "dest": "_site",
     "template": [
       "default",
@@ -47,17 +64,19 @@
       "_template/last-modified",
       "_template/description-generator"
     ],
-    "postProcessors": ["ExtractSearchIndex", "LastModifiedPostProcessor", "DescriptionPostProcessor"],
+    "postProcessors": [
+      "ExtractSearchIndex",
+      "LastModifiedPostProcessor",
+      "DescriptionPostProcessor"
+    ],
     "overwrite": "_overwrites/**/**.md",
     "globalMetadata": {
       "_appTitle": "Discord.Net Documentation",
-      "_appFooter": "Discord.Net (c) 2015-2020 2.2.0",
+      "_appFooter": "Discord.Net (c) 2015-2021 3.0.0",
       "_enableSearch": true,
       "_appLogoPath": "marketing/logo/SVG/Logomark Purple.svg",
-      "_appFaviconPath":  "favicon.ico"
+      "_appFaviconPath": "favicon.ico"
     },
-    "xrefService": [
-      "https://xref.docs.microsoft.com/query?uid={uid}"
-    ]
+    "xrefService": ["https://xref.docs.microsoft.com/query?uid={uid}"]
   }
 }

docs/faq/basics/basic-operations.md

@@ -13,7 +13,7 @@ language-specific tips when using this library.
 
 > [!WARNING]
 > Direct casting (e.g., `(Type)type`) is **the least recommended**
-> way of casting, as it *can* throw an [InvalidCastException]
+> way of casting, as it _can_ throw an [InvalidCastException]
 > when the object isn't the desired type.
 >
 > Please refer to [this post] for more details.
@@ -26,7 +26,7 @@ A good and safe casting example:
 
 [!code-csharp[Casting](samples/cast.cs)]
 
-[InvalidCastException]: https://docs.microsoft.com/en-us/dotnet/api/system.invalidcastexception
+[invalidcastexception]: https://docs.microsoft.com/en-us/dotnet/api/system.invalidcastexception
 [this post]: https://docs.microsoft.com/en-us/dotnet/csharp/how-to/safely-cast-using-pattern-matching-is-and-as-operators
 
 ## How do I send a message?
@@ -45,15 +45,15 @@ means casting is your friend. You should attempt to cast the channel
 as an [IMessageChannel] or any other entity that implements it to be
 able to message.
 
-[SendMessageAsync]: xref:Discord.IMessageChannel.SendMessageAsync*
-[GetChannel]: xref:Discord.WebSocket.DiscordSocketClient.GetChannel*
+[sendmessageasync]: xref:Discord.IMessageChannel.SendMessageAsync*
+[getchannel]: xref:Discord.WebSocket.DiscordSocketClient.GetChannel*
 
 ## How can I tell if a message is from X, Y, Z channel?
 
 You may check the message channel type. Visit [Glossary] to see the
 various types of channels.
 
-[Glossary]: xref:FAQ.Glossary#message-channels
+[glossary]: xref:FAQ.Glossary#message-channels
 
 ## How can I get the guild from a message?
 
@@ -86,9 +86,9 @@ implement [IEmote] and are valid options.
 
 [!code-csharp[Emoji](samples/emoji-self.cs)]
 
-***
+---
 
-[AddReactionAsync]: xref:Discord.IMessage.AddReactionAsync*
+[addreactionasync]: xref:Discord.IMessage.AddReactionAsync*
 
 ## What is a "preemptive rate limit?"
 
@@ -107,17 +107,17 @@ reactions.
 
 ## Can I opt-out of preemptive rate limits?
 
-Unfortunately, not at the moment. See [#401](https://github.com/RogueException/Discord.Net/issues/401).
-
-[IChannel]: xref:Discord.IChannel
-[ICategoryChannel]: xref:Discord.ICategoryChannel
-[IGuildChannel]: xref:Discord.IGuildChannel
-[ITextChannel]: xref:Discord.ITextChannel
-[IGuild]: xref:Discord.IGuild
-[IVoiceChannel]: xref:Discord.IVoiceChannel
-[IGuildUser]: xref:Discord.IGuildUser
-[IMessageChannel]: xref:Discord.IMessageChannel
-[IUserMessage]: xref:Discord.IUserMessage
-[IEmote]: xref:Discord.IEmote
-[Emote]: xref:Discord.Emote
-[Emoji]: xref:Discord.Emoji
+Unfortunately, not at the moment. See [#401](https://github.com/discord-net/Discord.Net/issues/401).
+
+[ichannel]: xref:Discord.IChannel
+[icategorychannel]: xref:Discord.ICategoryChannel
+[iguildchannel]: xref:Discord.IGuildChannel
+[itextchannel]: xref:Discord.ITextChannel
+[iguild]: xref:Discord.IGuild
+[ivoicechannel]: xref:Discord.IVoiceChannel
+[iguilduser]: xref:Discord.IGuildUser
+[imessagechannel]: xref:Discord.IMessageChannel
+[iusermessage]: xref:Discord.IUserMessage
+[iemote]: xref:Discord.IEmote
+[emote]: xref:Discord.Emote
+[emoji]: xref:Discord.Emoji

docs/faq/basics/client-basics.md

@@ -28,8 +28,8 @@ There are few possible reasons why this may occur.
  mind that a token is **different** from a *client secret*.
 
 [TokenType]: xref:Discord.TokenType
-[827]: https://github.com/RogueException/Discord.Net/issues/827
-[958]: https://github.com/RogueException/Discord.Net/issues/958
+[827]: https://github.com/discord-net/Discord.Net/issues/827
+[958]: https://github.com/discord-net/Discord.Net/issues/958
 [Discord API Terms of Service]: https://discord.com/developers/docs/legal
 
 ## How do I do X, Y, Z when my bot connects/logs on? Why do I get a `NullReferenceException` upon calling any client methods after connect?
@@ -73,7 +73,9 @@ instances, with each one serving a different amount of guilds.
 There are very few differences from the [DiscordSocketClient] class, and it is very straightforward
 to modify your existing code to use a [DiscordShardedClient] when necessary.
 
-1. You need to specify the total amount of shards, or shard ids, via [DiscordShardedClient]'s constructors.
+1. You can specify the total amount of shards, or shard ids, via [DiscordShardedClient]'s constructors.
+If the total shards are not specified then the library will get the recommended shard count via the
+[Get Gateway Bot](https://discord.com/developers/docs/topics/gateway#get-gateway-bot) route.
 2. The [Connected], [Disconnected], [Ready], and [LatencyUpdated] events
  are replaced with [ShardConnected], [ShardDisconnected], [ShardReady], and [ShardLatencyUpdated].
 3. Every event handler you apply/remove to the [DiscordShardedClient] is applied/removed to each shard.

docs/faq/basics/getting-started.md

@@ -79,4 +79,4 @@ Several common ways to do this:
    ![Roles](images/role-copy.png)
 2. Make the role mentionable and mention the role, and escape it
   using the `\` character in front.
-3. Inspect the roles collection within the guild via your debugger.
+3. Inspect the roles collection within the guild via your debugger.

docs/faq/basics/interactions.md

@@ -0,0 +1,84 @@
+---
+uid: FAQ.Basics.InteractionBasics
+title: Basics of interactions, common practice
+---
+
+# Interactions basics, where to get started
+
+This section answers basic questions and common mistakes in handling application commands, and responding to them.
+
+## What's the difference between RespondAsync, DeferAsync and FollowupAsync?
+
+The difference between these 3 functions is in how you handle the command response.
+[RespondAsync] and
+[DeferAsync] let the API know you have succesfully received the command. This is also called 'acknowledging' a command.
+DeferAsync will not send out a response, RespondAsync will.
+[FollowupAsync] follows up on succesful acknowledgement. 
+
+> [!WARNING]
+> If you have not acknowledged the command FollowupAsync will not work! the interaction has not been resonded to, so you cannot follow it up!
+
+[RespondAsync]: xref:Discord.IDiscordInteraction
+[DeferAsync]: xref:Discord.IDiscordInteraction
+[FollowUpAsync]: xref:Discord.IDiscordInteraction
+
+## Bad form Exception when I try to create my commands, why do I get this?
+
+Bad form exceptions are thrown if the slash, user or message command builder has invalid values.
+The following options could resolve your error.
+
+#### Is your command name lowercase?
+
+If your command name is not lowercase, it is not seen as a valid command entry.
+`Avatar` is invalid; `avatar` is valid.
+
+#### Are your values below or above the required amount? (This also applies to message components)
+
+Discord expects all values to be below maximum allowed.
+Going over this maximum amount of characters causes an exception.
+
+> [!NOTE]
+> All maximum and minimum value requirements can be found in the [Discord Developer Docs].
+> For components, structure documentation is found [here].
+
+[Discord Developer Docs]: https://discord.com/developers/docs/interactions/application-commands#application-commands
+[here]: https://discord.com/developers/docs/interactions/message-components#message-components
+
+#### Is your subcommand branching correct?
+
+Branching structure is covered properly here: xref:Guides.SlashCommands.SubCommand
+
+## My interaction commands are not showing up?
+
+If you registered your commands globally, it can take up to 1 hour for them to register.
+Did you register a guild command (should be instant), or waited more than an hour and still don't have them show up?
+
+- Try to check for any errors in the console, there is a good chance something might have been thrown.
+
+- Register your commands after the Ready event in the client. The client is not configured to register commands before this moment.
+
+- Check if no bad form exception is thrown; If so, refer to the above question.
+
+- Do you have the application commands scope checked when adding your bot to guilds?
+
+![Scope check](images/scope.png)
+
+## There are many options for creating commands, which do I use?
+
+[!code-csharp[Register examples](samples/registerint.cs)]
+
+> [!NOTE]
+> You can use bulkoverwrite even if there are no commands in guild, nor globally.
+> The bulkoverwrite method disposes the old set of commands and replaces it with the new.
+
+## Do I need to create commands on startup?
+
+If you are registering your commands for the first time, it is required to create them once.
+After this, commands will exist indefinitely until you overwrite them.
+Overwriting is only required if you make changes to existing commands, or add new ones.
+
+## I can't see all of my user/message commands, why?
+
+Message and user commands have a limit of 5 per guild, and another 5 globally.
+If you have more than 5 guild-only message commands being registered, no more than 5 will actually show up.
+You can get up to 10 entries to show if you register 5 per guild, and another 5 globally.

docs/faq/basics/samples/registerint.cs

@@ -0,0 +1,21 @@
+private async Task ReadyAsync()
+{
+    // pull your commands from some array, everyone has a different approach for this.
+    var commands = _builders.ToArray();
+
+    // write your list of commands globally in one go.
+    await _client.Rest.BulkOverwriteGlobalCommands(commands);
+
+    // write your array of commands to one guild in one go.
+    // You can do a foreach (... in _client.Guilds) approach to write to all guilds.
+    await _client.Rest.BulkOverwriteGuildCommands(commands, /* some guild ID */);
+
+    foreach (var c in commands)
+    {
+        // Create a global command, repeating usage for multiple commands.
+        await _client.Rest.CreateGlobalCommand(c);
+
+        // Create a guild command, repeating usage for multiple commands.
+        await _client.Rest.CreateGuildCommand(c, guildId);
+    }
+}

docs/faq/commands/dependency-injection.md

@@ -23,7 +23,7 @@ throughout execution. Think of it like a chest that holds
 whatever you throw at it that won't be affected by anything unless
 you want it to. Note that you should also learn Microsoft's
 implementation of [Dependency Injection] \([video]) before proceeding,
-as well as how it works in [Discord.Net](xref:Guides.Commands.DI#usage-in-modules).
+as well as how it works in [Discord.Net](xref:Guides.TextCommands.DI#usage-in-modules).
 
 A brief example of service and dependency injection can be seen below.
 

docs/faq/commands/general.md

@@ -1,9 +1,9 @@
 ---
 uid: FAQ.Commands.General
-title: General Questions about Commands
+title: General Questions about chat Commands
 ---
 
-# Command-related Questions
+# Chat Command-related Questions
 
 In the following section, you will find commonly asked questions and
 answered regarding general command usage when using @Discord.Commands.
@@ -144,4 +144,4 @@ For #4, exceptions are caught in [CommandService.Log] event under
 [LogMessage.Exception]: xref:Discord.LogMessage.Exception*
 [ExecuteResult.Exception]: xref:Discord.Commands.ExecuteResult.Exception*
 [CommandException]: xref:Discord.Commands.CommandException
-[IResult]: xref:Discord.Commands.IResult
+[IResult]: xref:Discord.Commands.IResult

docs/faq/commands/interaction.md

@@ -0,0 +1,52 @@
+---
+uid: FAQ.Commands.Interactions
+title: Interaction service
+---
+
+# Interaction commands in services
+
+A chapter talking about the interaction service framework.
+For questions about interactions in general, refer to the [Interactions FAQ]
+
+## Module dependencies aren't getting populated by Property Injection?
+
+Make sure the properties are publicly accessible and publicly settable.
+
+## How do I use this * interaction specific method/property?
+
+If your interaction context holds a down-casted version of the interaction object, you need to up-cast it.
+Ideally, use pattern matching to make sure its the type of interaction you are expecting it to be.
+
+## `InteractionService.ExecuteAsync()` always returns a successful result, how do i access the failed command execution results?
+
+If you are using `RunMode.Async` you need to setup your post-execution pipeline around `CommandExecuted` events.
+
+## How do I check if the executing user has * permission?
+
+Refer to the [documentation about preconditions]
+
+## How do I send the HTTP Response from inside the command modules.
+
+Set the `RestResponseCallback` property of [InteractionServiceConfig] with a delegate for handling HTTP Responses and use
+`RestInteractionModuleBase` to create your command modules. `RespondAsync()` and `DeferAsync()` methods of this module base will use the
+`RestResponseCallback` to create interaction responses.
+
+## Is there a cleaner way of creating parameter choices other than using `[Choice]`?
+
+The default `enum` [TypeConverter] of the Interaction Service will
+automatically register `enum`s as multiple choice options.
+
+## How do I add an optional `enum` parameter but make the default value not visible to the user?
+
+The default `enum` [TypeConverter] of the Interaction Service comes with `[Hide]` attribute that
+can be used to prevent certain enum values from getting registered.
+
+## How does the InteractionService determine the generic TypeConverter to use for a parameter type?
+
+It compares the _target base type_ key of the
+[TypeConverter] and chooses the one that sits highest on the inheritance hierarchy.
+
+[TypeConverter]: xref:Discord.Interactions.TypeConverter
+[Interactions FAQ]: xref: FAQ.Basics.Interactions
+[InteractionServiceConfig]: xref:Discord.Interactions.InteractionServiceConfig
+[documentation about preconditions]: xref: Guides.ChatCommands.Preconditions

docs/faq/misc/glossary.md

@@ -26,11 +26,11 @@ channels, and are often referred to as "servers".
 ## Channel Types
 
 ### Message Channels
-* A **Text Channel** ([ITextChannel]) is a message channel from a
-Guild.
+* A **Text Channel** ([ITextChannel]) is a message channel from a Guild.
+* A **Thread Channel** ([IThreadChannel]) is a thread channel from a Guild.
+* A **News Channel** ([INewsChannel]) (also goes as announcement channel) is a news channel from a Guild.
 * A **DM Channel** ([IDMChannel]) is a message channel from a DM.
-* A **Group Channel** ([IGroupChannel]) is a message channel from a
-Group.
+* A **Group Channel** ([IGroupChannel]) is a message channel from a Group.
 	- This is rarely used due to the bot's inability to join groups.
 * A **Private Channel** ([IPrivateChannel]) is a DM or a Group.
 * A **Message Channel** ([IMessageChannel]) can be any of the above.
@@ -39,11 +39,15 @@ Group.
 * A **Guild Channel** ([IGuildChannel]) is a guild channel in a guild.
 	- This can be any channels that may exist in a guild.
 * A **Voice Channel** ([IVoiceChannel]) is a voice channel in a guild.
+* A **Stage Channel** ([IStageChannel]) is a stage channel in a guild.
 * A **Category Channel** ([ICategoryChannel]) (2.0+) is a category that
 holds one or more sub-channels.
 * A **Nested Channel** ([INestedChannel]) (2.0+) is a channel that can
 exist under a category.
 
+> [!NOTE]
+> A Channel ([IChannel]) can be all types of channels.
+
 [INestedChannel]: xref:Discord.INestedChannel
 [IGuildChannel]: xref:Discord.IGuildChannel
 [IMessageChannel]: xref:Discord.IMessageChannel
@@ -53,6 +57,33 @@ exist under a category.
 [IPrivateChannel]: xref:Discord.IPrivateChannel
 [IVoiceChannel]: xref:Discord.IVoiceChannel
 [ICategoryChannel]: xref:Discord.ICategoryChannel
+[IChannel]: xref:Discord.IChannel
+[IThreadChannel]: xref:Discord.IThreadChannel
+[IStageChannel]: xref:Discord.IStageChannel
+[INewsChannel]: xref:Discord.INewsChannel
+
+## Message Types
+
+* An **User Message** ([IUserMessage]) is a message sent by a user.
+* A **System Message** ([ISystemMessage]) is a message sent by Discord itself.
+* A **Message** ([IMessage]) can be any of the above.
+
+[IUserMessage]: xref:Discord.IUserMessage
+[ISystemMessage]: xref:Discord.ISystemMessage
+[IMessage]: xref:Discord.IMessage
+
+## User Types
+
+* A **Guild User** ([IGuildUser]) is a user available inside a guild.
+* A **Group User** ([IGroupUser]) is a user available inside a group.
+	- This is rarely used due to the bot's inability to join groups.
+* A **Self User** ([ISelfUser]) is the bot user the client is currently logged in as.
+* An **User** ([IUser]) can be any of the above.
+
+[IGuildUser]: xref:Discord.IGuildUser
+[IGroupUser]: xref:Discord.IGroupUser
+[ISelfUser]: xref:Discord.ISelfUser
+[IUser]: xref:Discord.IUser
 
 ## Emoji Types
 
@@ -64,6 +95,15 @@ exist under a category.
 [Emote]: xref:Discord.Emote
 [Emoji]: xref:Discord.Emoji
 
+
+## Sticker Types
+
+* A **Sticker** ([ISticker]) is a standard Discord sticker.
+* A **Custom Sticker ([ICustomSticker]) is a Guild-unique sticker.
+
+[ISticker]: xref:Discord.ISticker
+[ICustomSticker]: xref:Discord.ICustomSticker
+
 ## Activity Types
 
 * A **Game** ([Game]) refers to a user's game activity.

docs/faq/misc/legacy.md

@@ -18,7 +18,7 @@ their breaking nature.
 
 Visit the repo's [release tag] to see the latest public pre-release.
 
-[release tag]: https://github.com/RogueException/Discord.Net/releases
+[release tag]: https://github.com/discord-net/Discord.Net/releases
 
 ## I came from an earlier version of Discord.Net 1.0, and DependencyMap doesn't seem to exist anymore in the later revision? What happened to it?
 
@@ -26,4 +26,4 @@ The `DependencyMap` has been replaced with Microsoft's
 [DependencyInjection] Abstractions. An example usage can be seen
 [here](https://github.com/foxbot/DiscordBotBase/blob/csharp/src/DiscordBot/Program.cs#L36).
 
-[DependencyInjection]: https://docs.microsoft.com/en-us/aspnet/core/fundamentals/dependency-injection
+[DependencyInjection]: https://docs.microsoft.com/en-us/aspnet/core/fundamentals/dependency-injection

docs/faq/toc.yml

@@ -6,10 +6,14 @@
       topicUid: FAQ.Basics.BasicOp
     - name: Client Basics
       topicUid: FAQ.Basics.ClientBasics
+    - name: Interactions
+      topicUid: FAQ.Basics.InteractionBasics
 - name: Commands
   items: 
-    - name: General
+    - name: String commands
       topicUid: FAQ.Commands.General
+    - name: Interaction commands
+      topicUid: FAQ.Commands.Interactions
     - name: Dependency Injection
       topicUid: FAQ.Commands.DI
 - name: Glossary

docs/guides/concepts/entities.md

@@ -63,4 +63,4 @@ a variant of the type that you need.
 
 ## Sample
 
-[!code-csharp[Entity Sample](samples/entities.cs)]
+[!code-csharp[Entity Sample](samples/entities.cs)]

docs/guides/getting_started/installing.md

@@ -11,9 +11,9 @@ may also compile this library yourself should you so desire.
 
 ## Supported Platforms
 
-Discord.Net targets [.NET Standard] both 1.3 and 2.0; this also means
-that creating applications using the latest version of [.NET Core] is
-the most recommended. If you are bound by Windows-specific APIs or
+Discord.Net targets [.NET 5.0], but is also available on older versions, like [.NET Standard] and [.NET Core]; this still means
+that creating applications using the latest version of .NET (6.0)
+is most recommended. If you are bound by Windows-specific APIs or
 other limitations, you may also consider targeting [.NET Framework]
 4.6.1 or higher.
 
@@ -23,6 +23,7 @@ other limitations, you may also consider targeting [.NET Framework]
 > implementation and may crash the application upon startup.
 
 [Mono]: https://www.mono-project.com/
+[.NET 5.0]: https://docs.microsoft.com/en-us/dotnet/core/whats-new/dotnet-5
 [.NET Standard]: https://docs.microsoft.com/en-us/dotnet/articles/standard/library
 [.NET Core]: https://docs.microsoft.com/en-us/dotnet/articles/core/
 [.NET Framework]: https://docs.microsoft.com/en-us/dotnet/framework/get-started/
@@ -90,15 +91,15 @@ In order to compile Discord.Net, you will need the following:
 
 ### Using Visual Studio
 
-* [Visual Studio 2019](https://visualstudio.microsoft.com/)
-* [.NET Core SDK]
+* [Visual Studio 2019](https://visualstudio.microsoft.com/) or later.
+* [.NET 5 SDK]
 
-The .NET Core and Docker workload is required during Visual Studio
+The .NET 5 and Docker workload is required during Visual Studio
 installation.
 
 ### Using Command Line
 
-* [.NET Core SDK]
+* [.NET 5 SDK]
 
 ## Additional Information
 
@@ -141,4 +142,4 @@ over the default ones.
 
 ***
 
-[.NET Core SDK]: https://dotnet.microsoft.com/download
+[.NET 5 SDK]: https://dotnet.microsoft.com/download

docs/guides/getting_started/labs.md

@@ -0,0 +1,30 @@
+---
+uid: Guides.GettingStarted.Installation.Labs
+title: Installing Labs builds
+---
+
+# Installing Discord.NET Labs
+
+Discord.NET Labs is the experimental repository that introduces new features & chips away at all bugs until ready for merging into Discord.NET.
+Are you looking to test or play with new features?
+
+> [!IMPORTANT]
+> It is very ill advised to use Discord.NET Labs in a production environment normally,
+> considering it can include bugs that have not been discovered yet, as features are freshly added.
+> However if approached correctly, will work as a pre-release to Discord.NET.
+> Make sure to report any bugs at the Labs [repository] or on [Discord]
+
+[Discord]: https://discord.gg/dnet
+[repository]: https://github.com/Discord-Net-Labs/Discord.Net-Labs
+
+## Installation:
+
+[NuGet] - This only includes releases, on which features are ready to test.
+
+> [!NOTE]
+> Installing NuGet packages is covered fully at [Installing Discord NET](xref:Guides.GettingStarted.Installation)
+
+[MyGet] - Available for current builds and unreleased features.
+
+[NuGet]: https://www.nuget.org/packages/Discord.Net.Labs/
+[MyGet]: https://www.myget.org/feed/Packages/discord-net-labs

docs/guides/getting_started/nightlies.md

@@ -1,97 +0,0 @@
----
-uid: Guides.GettingStarted.Installation.Nightlies
-title: Installing Nightly Build
----
-
-# Installing Discord.Net Nightly Build
-
-Before Discord.Net pushes a new set of features into the stable
-version, we use nightly builds to test the features with the
-community for an extensive period of time. Each nightly build is
-compiled by AppVeyor whenever a new commit is made and will be pushed
-to our MyGet feed.
-
-> [!IMPORTANT]
-> Although nightlies are generally stable and have more features
-> and bug fixes than the current stable build on NuGet, there
-> will be breaking changes during the development or
-> breaking bugs; these bugs are usually fixed as soon as they
-> are discovered, but you should still be aware of that.
-
-## Installing with MyGet (Recommended)
-
-MyGet is typically used by many development teams to publish their
-latest pre-release packages before the features are finalized and
-pushed to NuGet.
-
-The following is the feed link of Discord.Net,
-
-* `https://www.myget.org/F/discord-net/api/v3/index.json`
-
-Depending on which IDE you use, there are many different ways of
-adding the feed to your package source.
-
-### [Using Visual Studio](#tab/vs)
-
-1. Go to `Tools` > `NuGet Package Manager` > `Package Manager Settings`
-
-    ![VS](images/nightlies-vs-step1.png)
-
-2. Go to `Package Sources`
-
-    ![Package Sources](images/nightlies-vs-step2.png)
-
-3. Click on the add icon
-4. Fill in the desired name and source as shown below and hit `Update`
-
-    ![Add Source](images/nightlies-vs-step4.png)
-
-> [!NOTE]
-> Remember to tick the `Include pre-release` checkbox to see the
-> nightly builds!
-> ![Checkbox](images/nightlies-vs-note.png)
-
-### [Using dotnet CLI](#tab/cli)
-
-1. Launch a terminal of your choice
-2. Navigate to where your `*.csproj` is located
-3. Type `dotnet add package Discord.Net --source https://www.myget.org/F/discord-net/api/v3/index.json`
-
-### [Using Local NuGet.Config](#tab/local-nuget-config)
-
-If you plan on deploying your bot or developing outside of Visual
-Studio, you will need to create a local NuGet configuration file for
-your project.
-
-To do this, create a file named `NuGet.Config` alongside the root of
-your application, where the project is located.
-
-Paste the following snippets into this configuration file, adding any
-additional feeds if necessary.
-
-[!code[NuGet Configuration](samples/nuget.config)]
-
-After which, you may install the packages by directly modifying the
-project file and specifying a version, or by using
-the [Package Manager Console](https://docs.microsoft.com/en-us/nuget/tools/powershell-reference)
-(`Install-Package Discord.Net -IncludePrerelease`).
-
-***
-
-## Installing from AppVeyor Artifacts
-
-As mentioned in the first paragraph, we utilize AppVeyor to perform
-automated tests and publish the new build. During the publishing
-process, we also upload the NuGet packages onto
-AppVeyor's Artifact collection.
-
-The latest build status can be found within our [AppVeyor project].
-
-[AppVeyor project]: https://ci.appveyor.com/project/rogueexception/discord-net
-
-1. In the project, you may find our latest build including the
- aforementioned artifacts.
-    ![Artifacts](images/appveyor-artifacts.png)
-2. In the artifacts collection, you should see the latest packages
- packed in `*.nupkg` form which you could download from and use.
-    ![NuPkgs](images/appveyor-nupkg.png)

docs/guides/interactions/application-commands/context-menu-commands/creating-context-menu-commands.md → docs/guides/int_basics/application-commands/context-menu-commands/creating-context-menu-commands.md

@@ -16,9 +16,9 @@ Guild commands are specific to the guild you specify when making them. Guild com
 - Your app can have a global and guild command with the same name
 - Multiple apps can have commands with the same names
 
-**Note**: Apps can have a maximum of 5 global context menu commands, and an additional 5 guild-specific context menu commands per guild.
-
-If you don't have the code for a bot ready yet please follow [this guide](https://docs.stillu.cc/guides/getting_started/first-bot.html).
+[!IMPORTANT]
+> Apps can have a maximum of 5 global context menu commands,
+> and an additional 5 guild-specific context menu commands per guild.
 
 ## UserCommandBuilder
 
@@ -40,7 +40,9 @@ The context menu message command builder will help you create message commands.
 | WithName | Function | Sets the field name.                                                                                |
 | Build    | Function | Builds the builder into the appropriate `MessageCommandProperties` class used to make Menu commands |
 
-**Note**: Context Menu command names can be upper and lowercase, and use spaces.
+> [!NOTE]
+> Context Menu command names can be upper and lowercase, and use spaces.
+> They cannot be registered pre-ready.
 
 Let's use the user command builder to make a global and guild command.
 
@@ -102,4 +104,7 @@ public async Task Client_Ready()
 ```
 
 > [!NOTE]
-> Application commands only need to be created once. They do _not_ have to be 'created' on every startup or connection. The example simple shows creating them in the ready event as it's simpler than creating normal bot commands to register application commands.
+> Application commands only need to be created once. They do _not_ have to be
+> 'created' on every startup or connection.
+> The example simple shows creating them in the ready event
+> as it's simpler than creating normal bot commands to register application commands.

docs/guides/int_basics/application-commands/intro.md

@@ -0,0 +1,51 @@
+---
+uid: Guides.SlashCommands.Intro
+title: Introduction to slash commands
+---
+
+
+# Getting started with application commands.
+
+This guide will show you how to use application commands.
+If you have extra questions that aren't covered here you can come to our
+[Discord](https://discord.com/invite/dvSfUTet3K) server and ask around there.
+
+## What is an application command?
+
+Application commands consist of three different types. Slash commands, context menu User commands and context menu Message commands.
+Slash commands are made up of a name, description, and a block of options, which you can think of like arguments to a function.
+The name and description help users find your command among many others, and the options validate user input as they fill out your command.
+Message and User commands are only a name, to the user. So try to make the name descriptive.
+They're accessed by right clicking (or long press, on mobile) a user or a message, respectively.
+
+> [!IMPORTANT]
+> Context menu commands are currently not supported on mobile.
+
+All three varieties of application commands have both Global and Guild variants.
+Your global commands are available in every guild that adds your application.
+You can also make commands for a specific guild; they're only available in that guild.
+The User and Message commands are more limited in quantity than the slash commands.
+For specifics, check out their respective guide pages.
+
+An Interaction is the message that your application receives when a user uses a command.
+It includes the values that the user submitted, as well as some metadata about this particular instance of the command being used:
+the guild_id,
+channel_id,
+member and other fields.
+You can find all the values in our data models.
+
+## Authorizing your bot for application commands
+
+There is a new special OAuth2 scope for applications called `applications.commands`.
+In order to make Application Commands work within a guild, the guild must authorize your application
+with the `applications.commands` scope. The bot scope is not enough.
+
+Head over to your discord applications OAuth2 screen and make sure to select the `application.commands` scope.
+
+![OAuth2 scoping](slash-commands/images/oauth.png)
+
+From there you can then use the link to add your bot to a server.
+
+> [!NOTE]
+> In order for users in your guild to use your slash commands, they need to have
+> the "Use Application Commands" permission on the guild.

docs/guides/interactions/message-components/01-getting-started.md → docs/guides/int_basics/message-components/intro.md

@@ -1,5 +1,5 @@
 ---
-uid: Guides.MessageComponents.GettingStarted
+uid: Guides.MessageComponents.Intro
 title: Getting Started with Components
 ---
 

docs/guides/int_framework/autocompletion.md

@@ -0,0 +1,47 @@
+---
+uid: Guides.IntFw.AutoCompletion
+title: Command Autocompletion
+---
+
+# AutocompleteHandlers
+
+[Autocompleters] provide a similar pattern to TypeConverters.
+[Autocompleters] are cached, singleton services and they are used by the
+Interaction Service to handle Autocomplete Interations targeted to a specific Slash Command parameter.
+
+To start using AutocompleteHandlers, use the `[AutocompleteAttribute(Type type)]` overload of the [AutocompleteAttribute].
+This will dynamically link the parameter to the [AutocompleteHandler] type.
+
+AutocompleteHandlers raise the `AutocompleteHandlerExecuted` event on execution. This event can be also used to create a post-execution logic, just like the `*CommandExecuted` events.
+
+## Creating AutocompleteHandlers
+
+A valid AutocompleteHandlers must inherit [AutocompleteHandler] base type and implement all of its abstract methods.
+
+### GenerateSuggestionsAsync()
+
+The Interactions Service uses this method to generate a response of an Autocomplete Interaction.
+This method should return `AutocompletionResult.FromSuccess(IEnumerable<AutocompleteResult>)` to
+display parameter suggestions to the user. If there are no suggestions to be presented to the user, you have two results:
+
+1. Returning the parameterless `AutocompletionResult.FromSuccess()` will display a "No options match your search." message to the user.
+2. Returning `AutocompleteResult.FromError()` will make the Interaction Service **not** respond to the interaction,
+consequently displaying the user a "Loading options failed." message. `AutocompletionResult.FromError()` is solely used for error handling purposes. Discord currently doesn't allow
+you to display custom error messages. This result type will be directly returned to the `AutocompleteHandlerExecuted` method.
+
+## Resolving AutocompleteHandler Dependencies
+
+AutocompleteHandler dependencies are resolved using the same dependency injection
+pattern as the Interaction Modules.
+Property injection and constructor injection are both valid ways to get service dependencies.
+
+Because [AutocompleterHandlers] are constructed at service startup,
+class dependencies are resolved only once.
+
+> [!NOTE]
+> If you need to access per-request dependencies you can use the
+> IServiceProvider parameter of the `GenerateSuggestionsAsync()` method.
+
+[AutoCompleteHandlers]: xref:Discord.Interactions.AutocompleteHandler
+[AutoCompleteHandler]: xref:Discord.Interactions.AutocompleteHandler
+[AutoCompleteAttribute]: 

docs/guides/int_framework/dependency-injection.md

@@ -0,0 +1,13 @@
+---
+uid: Guides.IntFw.DI
+title: Dependency Injection
+---
+
+# Dependency Injection
+
+Dependency injection in the Interaction Service is mostly based on that of the Text-based command service,
+for which further information is found [here](xref:Guides.TextCommands.DI).
+
+> [!NOTE]
+> The 2 are nearly identical, except for one detail:
+> [Resolving Module Dependencies](xref:Guides.IntFw.Intro#resolving-module-dependencies)

docs/guides/int_framework/intro.md

@@ -0,0 +1,353 @@
+---
+uid: Guides.IntFw.Intro
+title: Introduction to the Interaction Service
+---
+
+# Getting Started
+
+The Interaction Service provides an attribute based framework for creating Discord Interaction handlers.
+
+To start using the Interaction Service, you need to create a service instance.
+Optionally you can provide the [InteractionService] constructor with a
+[InteractionServiceConfig] to change the services behaviour to suit your needs.
+
+```csharp
+...
+// _client here is DiscordSocketClient.
+// A different approach to passing in a restclient is also possible.
+var _interactionService = new InteractionService(_client.Rest);
+
+...
+```
+
+## Modules
+
+Attribute based Interaction handlers must be defined within a command module class.
+Command modules are responsible for executing the Interaction handlers and providing them with the necessary execution info and helper functions.
+
+Command modules are transient objects.
+A new module instance is created before a command execution starts then it will be disposed right after the method returns.
+
+Every module class must:
+
+- be public
+- inherit [InteractionModuleBase]
+
+Optionally you can override the included :
+
+- OnModuleBuilding (executed after the module is built)
+- BeforeExecute (executed before a command execution starts)
+- AfterExecute (executed after a command execution concludes)
+
+methods to configure the modules behaviour.
+
+Every command module exposes a set of helper methods, namely:
+
+- `RespondAsync()` => Respond to the interaction
+- `FollowupAsync()` => Create a followup message for an interaction
+- `ReplyAsync()` => Send a message to the origin channel of the interaction
+- `DeleteOriginalResponseAsync()` => Delete the original interaction response
+
+## Commands
+
+Valid **Interaction Commands** must comply with the following requirements:
+
+|                               | return type                  | max parameter count | allowed parameter types       | attribute                |
+|-------------------------------|------------------------------|---------------------|-------------------------------|--------------------------|
+|[Slash Command](#slash-commands)| `Task`/`Task<RuntimeResult>` | 25                  | any*                           | `[SlashCommand]`         |
+|[User Command](#user-commands)  | `Task`/`Task<RuntimeResult>` | 1                   | Implementations of `IUser`    | `[UserCommand]`          |
+|[Message Command](#message-commands)| `Task`/`Task<RuntimeResult>` | 1                   | Implementations of `IMessage` | `[MessageCommand]`       |
+|[Component Interaction Command](#component-interaction-commands)| `Task`/`Task<RuntimeResult>` | inf                 | `string` or `string[]`        | `[ComponentInteraction]` |
+|[Autocomplete Command](#autocomplete-commands)| `Task`/`Task<RuntimeResult>` | -             | -                   | `[AutocompleteCommand]`|
+
+> [!NOTE]
+> a `TypeConverter` that is capable of parsing type in question must be registered to the [InteractionService] instance.
+> You should avoid using long running code in your command module.
+> Depending on your setup, long running code may block the Gateway thread of your bot, interrupting its connection to Discord.
+
+## Slash Commands
+
+Slash Commands are created using the [SlashCommandAttribute].
+Every Slash Command must declare a name and a description.
+You can check Discords **Application Command Naming Guidelines**
+[here](https://discord.com/developers/docs/interactions/application-commands#application-command-object-application-command-naming).
+
+[!code-csharp[Slash Command](samples/intro/slashcommand.cs)]
+
+### Parameters
+
+Slash Commands can have up to 25 method parameters. You must name your parameters in accordance with
+[Discords Naming Guidelines](https://discord.com/developers/docs/interactions/application-commands#application-command-object-application-command-naming).
+[InteractionService] also features a pascal casing seperator for formatting parameter names with
+pascal casing into Discord compliant parameter names('parameterName' => 'parameter-name').
+By default, your methods can feature the following parameter types:
+
+- Implementations of [IUser]
+- Implementations of [IChannel]
+- Implementations of [IRole]
+- Implementations of [IMentionable]
+- `string`
+- `float`, `double`, `decimal`
+- `bool`
+- `char`
+- `sbyte`, `byte`
+- `int16`, `int32`, `int64`
+- `uint16`, `uint32`, `uint64`
+- `enum` (Values are registered as multiple choice options and are enforced by Discord. Use `[HideAttribute]` on enum values to prevent them from getting registered.)
+- `DateTime`
+- `TimeSpan`
+
+---
+
+**You can use more specialized implementations of [IChannel] to restrict the allowed channel types for a channel type option.*
+| interface           | Channel Type                  |
+|---------------------|-------------------------------|
+| `IStageChannel`     | Stage Channels                |
+| `IVoiceChannel`     | Voice Channels                |
+| `IDMChannel`        | DM Channels                   |
+| `IGroupChannel`     | Group Channels                |
+| `ICategory Channel` | Category Channels             |
+| `INewsChannel`      | News Channels                 |
+| `IThreadChannel`    | Public, Private, News Threads |
+| `ITextChannel`      | Text Channels                 |
+
+---
+
+#### Optional Parameters
+
+Parameters with default values (ie. `int count = 0`) will be displayed as optional parameters on Discord Client.
+
+#### Parameter Summary
+
+By using the [SummaryAttribute] you can customize the displayed name and description of a parameter
+
+[!code-csharp[Summary Attribute](samples/intro/summaryattribute.cs)]
+
+#### Parameter Choices
+
+[ChoiceAttribute] can be used to add choices to a parameter.
+
+[!code-csharp[Choice Attribute](samples/intro/groupattribute.cs)]
+
+This Slash Command will be displayed exactly the same as the previous example.
+
+#### Channel Types
+
+Channel types for an [IChannel] parameter can also be restricted using the [ChannelTypesAttribute].
+
+[!code-csharp[Channel Attribute](samples/intro/channelattribute.cs)]
+
+In this case, user can only input Stage Channels and Text Channels to this parameter.
+
+#### Min/Max Value
+
+You can specify the permitted max/min value for a number type parameter using the [MaxValueAttribute] and [MinValueAttribute].
+
+## User Commands
+
+A valid User Command must have the following structure:
+
+[!code-csharp[User Command](samples/intro/usercommand.cs)]
+
+> [!WARNING]
+> User commands can only have one parameter and its type must be an implementation of [IUser].
+
+## Message Commands
+
+A valid Message Command must have the following structure:
+
+[!code-csharp[Message Command](samples/intro/messagecommand.cs)]
+
+> [!WARNING]
+> Message commands can only have one parameter and its type must be an implementation of [IMessage].
+
+## Component Interaction Commands
+
+Component Interaction Commands are used to handle interactions that originate from **Discord Message Component**s.
+This pattern is particularly useful if you will be reusing a set a **Custom ID**s.
+
+Component Interaction Commands support wild card matching,
+by default `*` character can be used to create a wild card pattern.
+Interaction Service will use lazy matching to capture the words corresponding to the wild card character.
+And the captured words will be passed on to the command method in the same order they were captured.
+
+[!code-csharp[Button](samples/intro/button.cs)]
+
+You may use as many wild card characters as you want.
+
+> [!NOTE]
+> If Interaction Service recieves a component interaction with **player:play,rickroll** custom id,
+> `op` will be *play* and `name` will be *rickroll*
+
+## Select Menus
+
+Unlike button interactions, select menu interactions also contain the values of the selected menu items.
+In this case, you should structure your method to accept a string array.
+
+[!code-csharp[Dropdown](samples/intro/dropdown.cs)]
+
+> [!NOTE]
+> Wildcards may also be used to match a select menu ID,
+> though keep in mind that the array containing the select menu values should be the last parameter.
+
+## Autocomplete Commands
+
+Autocomplete commands must be parameterless methods. A valid Autocomplete command must have the following structure:
+
+[!code-csharp[Autocomplete Command](samples/intro/autocomplete.cs)]
+
+Alternatively, you can use the [AutocompleteHandlers] to simplify this workflow.
+
+## Interaction Context
+
+Every command module provides its commands with an execution context.
+This context property includes general information about the underlying interaction that triggered the command execution.
+The base command context.
+
+You can design your modules to work with different implementation types of [IInteractionContext].
+To achieve this, make sure your module classes inherit from the generic variant of the [InteractionModuleBase].
+
+> [!NOTE]
+> Context type must be consistent throughout the project, or you will run into issues during runtime.
+
+The [InteractionService] ships with 4 different kinds of [InteractionContext]:
+
+1. [InteractionContext]]: A bare-bones execution context consisting of only implementation neutral interfaces
+2. [SocketInteractionContext]: An execution context for use with [DiscordSocketClient]. Socket entities are exposed in this context without the need of casting them.
+3. [ShardedInteractionContext]: [DiscordShardedClient] variant of the [SocketInteractionContext]
+4. [RestInteractionContext]: An execution context designed to be used with a [DiscordRestClient] and webhook based interactions pattern
+
+You can create custom Interaction Contexts by implementing the [IInteractionContext] interface.
+
+One problem with using the concrete type InteractionContexts is that you cannot access the information that is specific to different interaction types without casting. Concrete type interaction contexts are great for creating shared interaction modules but you can also use the generic variants of the built-in interaction contexts to create interaction specific interaction modules.
+
+> [!INFO]
+> Message component interactions have access to a special method called `UpdateAsync()` to update the body of the method the interaction originated from.
+> Normally this wouldn't be accessable without casting the `Context.Interaction`.
+
+[!code-csharp[Context Example](samples/intro/context.cs)]
+
+## Loading Modules
+
+[InteractionService] can automatically discover and load modules that inherit [InteractionModuleBase] from an `Assembly`.
+Call `InteractionService.AddModulesAsync()` to use this functionality.
+
+> [!NOTE]
+> You can also manually add Interaction modules using the `InteractionService.AddModuleAsync()`
+> method by providing the module type you want to load.
+
+## Resolving Module Dependencies
+
+Module dependencies are resolved using the Constructor Injection and Property Injection patterns.
+Meaning, the constructor parameters and public settable properties of a module will be assigned using the `IServiceProvider`.
+For more information on dependency injection, read the [DependencyInjection] guides.
+
+> [!NOTE]
+> On every command execution, module dependencies are resolved using a new service scope which allows you to utilize scoped service instances, just like in Asp.Net.
+> Including the precondition checks, every module method is executed using the same service scope and service scopes are disposed right after the `AfterExecute` method returns.
+
+## Module Groups
+
+Module groups allow you to create sub-commands and sub-commands groups.
+By nesting commands inside a module that is tagged with [GroupAttribute] you can create prefixed commands.
+
+> [!WARNING]
+> Although creating nested module stuctures are allowed,
+> you are not permitted to use more than 2 [GroupAttribute]'s in module hierarchy.
+
+## Executing Commands
+
+Any of the following socket events can be used to execute commands:
+
+- [InteractionCreated]
+- [ButtonExecuted]
+- [SelectMenuExecuted]
+- [AutocompleteExecuted]
+- [UserCommandExecuted]
+- [MessageCommandExecuted]
+
+Commands can be either executed on the gateway thread or on a seperate thread from the thread pool. This behaviour can be configured by changing the *RunMode* property of `InteractionServiceConfig` or by setting the *runMode* parameter of a command attribute.
+
+You can also configure the way [InteractionService] executes the commands.
+By default, commands are executed using `ConstructorInfo.Invoke()` to create module instances and
+`MethodInfo.Invoke()` method for executing the method bodies.
+By setting, `InteractionServiceConfig.UseCompiledLambda` to `true`, you can make [InteractionService] create module instances and execute commands using
+*Compiled Lambda* expressions. This cuts down on command execution time but it might add some memory overhead.
+
+Time it takes to create a module instance and execute a `Task.Delay(0)` method using the Reflection methods compared to Compiled Lambda expressions:
+
+|           Method |      Mean |    Error |   StdDev |
+|----------------- |----------:|---------:|---------:|
+| ReflectionInvoke | 225.93 ns | 4.522 ns | 7.040 ns |
+|   CompiledLambda |  48.79 ns | 0.981 ns | 1.276 ns |
+
+## Registering Commands to Discord
+
+Application commands loaded to the Interaction Service can be registered to Discord using a number of different methods.
+In most cases `RegisterCommandsGloballyAsync()` and `RegisterCommandsToGuildAsync()` are the methods to use.
+Command registration methods can only be used after the gateway client is ready or the rest client is logged in.
+
+[!code-csharp[Registering Commands Example](samples/intro/registering.cs)]
+
+Methods like `AddModulesToGuildAsync()`, `AddCommandsToGuildAsync()`, `AddModulesGloballyAsync()` and `AddCommandsGloballyAsync()`
+can be used to register cherry picked modules or commands to global/guild scopes.
+
+> [!NOTE]
+> In debug environment, since Global commands can take up to 1 hour to register/update,
+> it is adviced to register your commands to a test guild for your changes to take effect immediately.
+> You can use preprocessor directives to create a simple logic for registering commands as seen above
+
+## Interaction Utility
+
+Interaction Service ships with a static `InteractionUtiliy`
+class which contains some helper methods to asynchronously waiting for Discord Interactions.
+For instance, `WaitForInteractionAsync()` method allows you to wait for an Interaction for a given amount of time.
+This method returns the first encountered Interaction that satisfies the provided predicate.
+
+> [!WARNING]
+> If you are running the Interaction Service on `RunMode.Sync` you should avoid using this method in your commands,
+> as it will block the gateway thread and interrupt your bots connection.
+
+## Webhook Based Interactions
+
+Instead of using the gateway to recieve Discord Interactions, Discord allows you to recieve Interaction events over Webhooks.
+Interaction Service also supports this Interaction type but to be able to
+respond to the Interactions within your command modules you need to perform the following:
+
+- Make your modules inherit `RestInteractionModuleBase`
+- Set the `ResponseCallback` property of `InteractionServiceConfig` so that the `ResponseCallback`
+delegate can be used to create HTTP responses from a deserialized json object string.
+- Use the interaction endpoints of the module base instead of the interaction object (ie. `RespondAsync()`, `FollowupAsync()`...).
+
+[AutocompleteHandlers]: xref:Guides.IntFw.AutoCompletion
+[DependencyInjection]: xref:Guides.TextCommands.DI
+
+[GroupAttribute]: xref:Discord.Interactions.GroupAttribute
+[InteractionService]: xref:Discord.Interactions.InteractionService
+[InteractionServiceConfig]: xref:Discord.Interactions.InteractionServiceConfig
+[InteractionModuleBase]: xref:Discord.Interactions.InteractionModuleBase
+[SlashCommandAttribute]: xref:Discord.Interactions.SlashCommandAttribute
+[InteractionCreated]: xref:Discord.WebSocket.BaseSocketClient
+[ButtonExecuted]: xref:Discord.WebSocket.BaseSocketClient
+[SelectMenuExecuted]: xref:Discord.WebSocket.BaseSocketClient
+[AutocompleteExecuted]: xref:Discord.WebSocket.BaseSocketClient
+[UserCommandExecuted]: xref:Discord.WebSocket.BaseSocketClient
+[MessageCommandExecuted]: xref:Discord.WebSocket.BaseSocketClient
+[DiscordSocketClient]: xref:Discord.WebSocket.DiscordSocketClient
+[DiscordRestClient]: xref:Discord.Rest.DiscordRestClient
+[SocketInteractionContext]: xref:Discord.Interactions.SocketInteractionContext
+[ShardedInteractionContext]: xref:Discord.Interactions.ShardedInteractionContext
+[InteractionContext]: xref:Discord.Interactions.InteractionContext
+[IInteractionContect]: xref:Discord.Interactions.IInteractionContext
+[RestInteractionContext]: xref:Discord.Rest.RestInteractionContext
+[SummaryAttribute]: xref:Discord.Interactions.SummaryAttribute
+[ChoiceAttribute]: xref:Discord.Interactions.ChoiceAttribute
+[ChannelTypesAttribute]: xref:Discord.Interactions.ChannelTypesAttribute
+[MaxValueAttribute]: xref:Discord.Interactions.MaxValueAttribute
+[MinValueAttribute]: xref:Discord.Interactions.MinValueAttribute
+
+[IChannel]: xref:Discord.IChannel
+[IRole]: xref:Discord.IRole
+[IUser]: xref:Discord.IUser
+[IMessage]: xref:Discord.IMessage
+[IMentionable]: xref:Discord.IMentionable

docs/guides/int_framework/post-execution.md

@@ -0,0 +1,69 @@
+---
+uid: Guides.IntFw.PostExecution
+title: Post-Command execution
+---
+
+# Post-Execution Logic
+
+Interaction Service uses [IResult] to provide information about the state of command execution.
+These can be used to log internal exceptions or provide some insight to the command user.
+
+If you are running your commands using `RunMode.Sync` these command results can be retrieved from
+the return value of [InteractionService.ExecuteCommandAsync] method or by
+registering delegates to Interaction Service events.
+
+If you are using the `RunMode.Async` to run your commands,
+you must use the Interaction Service events to get the execution results. When using `RunMode.Async`,
+[InteractionService.ExecuteCommandAsync] will always return a successful result.
+
+[InteractionService.ExecuteCommandAsync]: xref: Discord.Interactions.InteractionService.ExecuteCommandAsync*
+
+## Results
+
+Interaction Result come in a handful of different flavours:
+
+1. [AutocompletionResult]: returned by Autocompleters
+2. [ExecuteResult]: contains the result of method body execution process
+3. [PreconditionGroupResult]: returned by Precondition groups
+4. [PreconditionResult]: returned by preconditions
+5. [RuntimeResult]: a user implementable result for returning user defined results
+6. [SearchResult]: returned by command lookup map
+7. [TypeConverterResult]: returned by TypeConverters
+
+> [!NOTE]
+> You can either use the [IResult.Error] property of an Interaction result or create type check for the
+> afformentioned result types to branch out your post-execution logic to handle different situations.
+
+
+[AutocompletionResult]: xref:Discord.AutocompleteResult
+[ExecuteResult]: xref:Discord.Interactions.ExecuteResult
+[PreconditionGroupResult]: xref:Discord.Interactions.PreconditionGroupResult
+[PreconditionResult]: xref:Discord.Interactions.PreconditionResult
+[SearchResult]: xref:Discord.Interactions.SearchResult
+[TypeConverterResult]: xref:Discord.Interactions.TypeConverterResult
+[IResult.Error]: xref:Discord.Interactions.IResult.Error*
+
+## CommandExecuted Events
+
+Every time a command gets executed, Interaction Service raises a `CommandExecuted` event.
+These events can be used to create a post-execution pipeline.
+
+[!code-csharp[Error Review](samples/postexecution/error_review.cs)
+
+## Log Event
+
+InteractionService regularly outputs information about the occuring events to keep the developer informed.
+
+## Runtime Result
+
+Interaction commands allow you to return `Task<RuntimeResult>` to pass on additional information about the command execution
+process back to your post-execution logic.
+
+Custom [RuntimeResult] classes can be created by inheriting the base [RuntimeResult] class.
+
+If command execution process reaches the method body of the command and no exceptions are thrown during
+the execution of the method body, [RuntimeResult] returned by your command will be accessible by casting/type-checking the
+[IResult] parameter of the `CommandExecuted` event delegate.
+
+[RuntimeResult]: xref:Discord.Interactions.RuntimeResult
+[IResult]: xref:Discord.Interactions.IResult

docs/guides/int_framework/preconditions.md

@@ -0,0 +1,77 @@
+---
+uid: Guides.IntFw.Preconditions
+title: Preconditions
+---
+
+# Preconditions
+
+Precondition logic is the same as it is for Text-based commands.
+A list of attributes and usage is still given for people who are new to both.
+
+There are two types of Preconditions you can use:
+
+* [PreconditionAttribute] can be applied to Modules, Groups, or Commands.
+* [ParameterPreconditionAttribute] can be applied to Parameters.
+
+You may visit their respective API documentation to find out more.
+
+[PreconditionAttribute]: xref:Discord.Interactions.PreconditionAttribute
+[ParameterPreconditionAttribute]: xref:Discord.Interactions.ParameterPreconditionAttribute
+
+## Bundled Preconditions
+
+@Discord.Interactions ships with several bundled Preconditions for you
+to use.
+
+* @Discord.Interactions.RequireContextAttribute
+* @Discord.Interactions.RequireOwnerAttribute
+* @Discord.Interactions.RequireBotPermissionAttribute
+* @Discord.Interactions.RequireUserPermissionAttribute
+* @Discord.Interactions.RequireNsfwAttribute
+* @Discord.Interactions.RequireRoleAttribute
+
+## Using Preconditions
+
+To use a precondition, simply apply any valid precondition candidate to
+a command method signature as an attribute.
+
+[!code-csharp[Precondition usage](samples/preconditions/precondition_usage.cs)]
+
+## ORing Preconditions
+
+When writing commands, you may want to allow some of them to be
+executed when only some of the precondition checks are passed.
+
+This is where the [Group] property of a precondition attribute comes in
+handy. By assigning two or more preconditions to a group, the command
+system will allow the command to be executed when one of the
+precondition passes.
+
+### Example - ORing Preconditions
+
+[!code-csharp[OR Precondition](samples/preconditions/group_precondition.cs)]
+
+[Group]: xref:Discord.Commands.PreconditionAttribute.Group
+
+## Custom Preconditions
+
+To write your own Precondition, create a new class that inherits from
+either [PreconditionAttribute] or [ParameterPreconditionAttribute]
+depending on your use.
+
+In order for your Precondition to function, you will need to override
+the [CheckPermissionsAsync] method.
+
+If the context meets the required parameters, return
+[PreconditionResult.FromSuccess], otherwise return
+[PreconditionResult.FromError] and include an error message if
+necessary.
+
+> [!NOTE]
+> Visual Studio can help you implement missing members
+> from the abstract class by using the "Implement Abstract Class"
+> IntelliSense hint.
+
+[CheckPermissionsAsync]: xref:Discord.Commands.PreconditionAttribute.CheckPermissionsAsync*
+[PreconditionResult.FromSuccess]: xref:Discord.Commands.PreconditionResult.FromSuccess*
+[PreconditionResult.FromError]: xref:Discord.Commands.PreconditionResult.FromError*

docs/guides/int_framework/samples/intro/autocomplete.cs

@@ -0,0 +1,9 @@
+[AutocompleteCommand("parameter_name", "command_name")]
+public async Task Autocomplete()
+{
+    IEnumerable<AutocompleteResult> results;
+
+    ...
+
+    await (Context.Interaction as SocketAutocompleteInteraction).RespondAsync(results);
+}

docs/guides/int_framework/samples/intro/button.cs

@@ -0,0 +1,5 @@
+[ComponentInteraction("player:*,*")]
+public async Task Play(string op, string name)
+{
+    ...
+}

docs/guides/int_framework/samples/intro/channelattribute.cs

@@ -0,0 +1,5 @@
+[SlashCommand("name", "Description")]
+public async Task Command([ChannelTypes(ChannelType.Stage, ChannelType.Text)] IChannel channel)
+{
+    ...
+}

docs/guides/int_framework/samples/intro/context.cs

@@ -0,0 +1,14 @@
+discordClient.ButtonExecuted += async (interaction) => 
+{
+    var ctx = new SocketInteractionContext<SocketMessageComponent>(discordClient, interaction);
+    await _interactionService.ExecuteAsync(ctx, serviceProvider);
+};
+
+public class MessageComponentModule : InteractionModuleBase<SocketInteractionContext<SocketMessageComponent>>
+{
+    [ComponentInteraction("custom_id")]
+    public async Command()
+    {
+        Context.Interaction.UpdateAsync(...);
+    }
+}

docs/guides/int_framework/samples/intro/dropdown.cs

@@ -0,0 +1,11 @@
+[ComponentInteraction("role_selection")]
+public async Task RoleSelection(string[] selectedRoles)
+{
+    ...
+}
+
+[ComponentInteraction("role_selection_*")]
+public async Task RoleSelection(string id, string[] selectedRoles)
+{
+    ...
+}

docs/guides/int_framework/samples/intro/groupattribute.cs

@@ -0,0 +1,21 @@
+[SlashCommand("blep", "Send a random adorable animal photo")]
+public async Task Blep([Choice("Dog", "dog"), Choice("Cat", "cat"), Choice("Penguin", "penguin")] string animal)
+{
+    ...
+}
+
+// In most cases, you can use an enum to replace the seperate choice attributes in a command.
+
+public enum Animal
+{
+    Cat,
+    Dog,
+    Penguin
+}
+
+[SlashCommand("blep", "Send a random adorable animal photo")]
+public async Task Blep(Animal animal)
+{
+    ...
+}
+```

docs/guides/int_framework/samples/intro/messagecommand.cs

@@ -0,0 +1,5 @@
+[MessageCommand("Bookmark")]
+public async Task Bookmark(IMessage msg)
+{
+    ...
+}

docs/guides/int_framework/samples/intro/registering.cs

@@ -0,0 +1,5 @@
+#if DEBUG
+    await interactionService.RegisterCommandsToGuildAsync(<test_guild_id>);
+#else
+    await interactionService.RegisterCommandsGloballyAsync();
+#endif

docs/guides/int_framework/samples/intro/slashcommand.cs

@@ -0,0 +1,5 @@
+[SlashCommand("echo", "Echo an input")]
+public async Task Echo(string input)
+{
+    await RespondAsync(input);
+}

docs/guides/int_framework/samples/intro/summaryattribute.cs

@@ -0,0 +1 @@
+[Summary(description: "this is a parameter description")] string input

docs/guides/int_framework/samples/intro/usercommand.cs

@@ -0,0 +1,5 @@
+[UserCommand("Say Hello")]
+public async Task SayHello(IUser user)
+{
+    ...
+}

docs/guides/int_framework/samples/postexecution/error_review.cs

@@ -0,0 +1,28 @@
+interactionService.SlashCommandExecuted += SlashCommandExecuted;
+
+async Task SlashCommandExecuted(SlashCommandInfo arg1, Discord.IInteractionContext arg2, IResult arg3)
+{
+    if (!arg3.IsSuccess)
+    {
+        switch (arg3.Error)
+        {
+            case InteractionCommandError.UnmetPrecondition:
+                await arg2.Interaction.RespondAsync($"Unmet Precondition: {arg3.ErrorReason}");
+                break;
+            case InteractionCommandError.UnknownCommand:
+                await arg2.Interaction.RespondAsync("Unknown command");
+                break;
+            case InteractionCommandError.BadArgs:
+                await arg2.Interaction.RespondAsync("Invalid number or arguments");
+                break;
+            case InteractionCommandError.Exception:
+                await arg2.Interaction.RespondAsync("Command exception:{arg3.ErrorReason}");
+                break;
+            case InteractionCommandError.Unsuccessful:
+                await arg2.Interaction.RespondAsync("Command could not be executed");
+                break;
+            default:
+                break;
+        }
+    }
+}

docs/guides/int_framework/samples/preconditions/precondition_usage.cs

@@ -0,0 +1,3 @@
+[RequireOwner]
+[SlashCommand("hi")]
+public Task SayHiAsync() => RespondAsync("hello owner!");

docs/guides/int_framework/samples/typeconverters/enum_converter.cs

@@ -0,0 +1,30 @@
+internal sealed class EnumConverter<T> : TypeConverter<T> where T : struct, Enum
+{
+    public override ApplicationCommandOptionType GetDiscordType() => ApplicationCommandOptionType.String;
+
+    public override Task<TypeConverterResult> ReadAsync(IInteractionCommandContext context, SocketSlashCommandDataOption option, IServiceProvider services)
+    {
+        if (Enum.TryParse<T>((string)option.Value, out var result))
+            return Task.FromResult(TypeConverterResult.FromSuccess(result));
+        else
+            return Task.FromResult(TypeConverterResult.FromError(InteractionCommandError.ConvertFailed, $"Value {option.Value} cannot be converted to {nameof(T)}"));
+    }
+
+    public override void Write(ApplicationCommandOptionProperties properties, IParameterInfo parameterInfo)
+    {
+        var names = Enum.GetNames(typeof(T));
+        if (names.Length <= 25)
+        {
+            var choices = new List<ApplicationCommandOptionChoiceProperties>();
+
+            foreach (var name in names)
+                choices.Add(new ApplicationCommandOptionChoiceProperties
+                {
+                    Name = name,
+                    Value = name
+                });
+
+            properties.Choices = choices;
+        }
+    }
+}

docs/guides/int_framework/typeconverters.md

@@ -0,0 +1,118 @@
+---
+uid: Guides.IntFw.TypeConverters
+title: Parameter Type Converters
+---
+
+# TypeConverters
+
+[TypeConverters] are responsible for registering command parameters to Discord and parsing the user inputs into method parameters.
+
+By default, TypeConverters for the following types are provided with @Discord.Interactions library.
+
+- Implementations of [IUser]
+- Implementations of [IChannel]
+- Implementations of [IRole]
+- Implementations of [IMentionable]
+- `string`
+- `float`, `double`, `decimal`
+- `bool`
+- `char`
+- `sbyte`, `byte`
+- `int16`, `int32`, `int64`
+- `uint16`, `uint32`, `uint64`
+- `enum`
+- `DateTime`
+- `TimeSpan`
+
+## Creating TypeConverters
+
+Depending on your needs, there are two types of TypeConverters you can create:
+
+- Concrete type
+- Generic type
+
+A valid converter must inherit [TypeConverter] base type. And override the abstract base methods.
+
+### CanConvertTo() Method
+
+This method is used by Interaction Service to search for alternative Type Converters.
+
+Interaction Services determines the most suitable [TypeConverter] for a parameter type in the following order:
+
+1. It searches for a [TypeConverter] that is registered to specifically target that parameter type
+2. It searches for a [TypeConverter] that returns `true` when its `CanConvertTo()` method is invoked for thaty parameter type.
+3. It searches for a generic `TypeConverter<T>` with a matching type constraint. If there are more multiple matches,
+the one whose type constraint is the most specialized will be chosen.
+
+> [!NOTE}
+> Alternatively, you can use the generic variant (`TypeConverter<T>`) of the
+> [TypeConverter] base class which implements the following method body for `CanConvertTo()` method
+
+```csharp
+public sealed override bool CanConvertTo (Type type) => 
+    typeof(T).IsAssignableFrom(type);
+```
+
+### GetDiscordType() Method
+
+This method is used by [InteractionService] to determine the
+[Discord Application Command Option type](https://discord.com/developers/docs/interactions/application-commands#application-command-object-application-command-option-type)
+of a parameter type.
+
+### ReadAsync() Method
+
+This method is used by [InteractionService] to parse the user input.
+This method should return @Discord.Interactions.TypeConverterResult.FromSuccess* if the parsing operation is successful,
+otherwise it should return @Discord.Interactions.TypeConverterResult.FromError* .
+The inner logic of this method is totally up to you,
+however you should avoid using long running code.
+
+### Write() Method
+
+This method is used to configure the **Discord Application Command Option** before it gets registered to Discord.
+Command Option is configured by modifying the `ApplicationCommandOptionProperties` instance.
+
+> [!WARNING]
+> The default parameter building pipeline is isolated and will not be disturbed by the [TypeConverter] workflow.
+> But changes made in this method will override the values generated by the
+> [InteractionService] for a **Discord Application Command Option**.
+
+## Example Enum TypeConverter
+
+[!code-csharp[Enum Converter](samples/typeconverters/enum_converter.cs)]
+
+> [!IMPORTANT]
+> TypeConverters must be registered prior to module discovery.
+> If Interaction Service encounters a parameter type that doesn't belong to any of the
+> registered [TypeConverters] during this phase, it will throw an exception.
+
+## Concrete TypeConverters
+
+Registering Concrete TypeConverters are as simple as creating an instance of your custom converter and invoking `AddTypeConverter()` method.
+
+```csharp
+interactionService.AddTypeConverter<string[]>(new StringArrayConverter());
+```
+
+## Generic TypeConverters
+
+To register a generic `TypeConverter<T>`, you need to invoke the `AddGenericTypeConverter()` method of the Interaction Service class.
+You need to pass the type of your `TypeConverter<T>` and a target base type to this method.
+
+For instance, to register the previously mentioned enum converter the following can be used:
+
+```csharp
+interactionService.AddGenericTypeConverter<Enum>(typeof(EnumConverter<>));
+```
+
+Interaction service checks if the target base type satisfies the type constraints of the Generic `TypeConverter` class.
+
+> [!NOTE]
+> Dependencies of Generic TypeConverters are also resolved using the Dependency Injection pattern.
+
+[TypeConverter]: xref:Discord.Interactions.TypeConverter
+[InteractionService]: xref:Discord.Interactions.InteractionService
+[IChannel]: xref:Discord.IChannel
+[IRole]: xref:Discord.IRole
+[IUser]: xref:Discord.IUser
+[IMentionable]: xref:Discord.IMentionable

docs/guides/interactions/application-commands/01-getting-started.md

@@ -1,32 +0,0 @@
----
-uid: Guides.SlashCommands.Intro
-title: Introduction to slash commands
----
-
-
-# Getting started with application commands.
-
-Welcome! This guide will show you how to use application commands.
-
-## What is an application command?
-
-Application commands consist of three different types. Slash commands, context menu User commands and context menu Message commands.
-Slash commands are made up of a name, description, and a block of options, which you can think of like arguments to a function. The name and description help users find your command among many others, and the options validate user input as they fill out your command.
-Message and User commands are only a name, to the user. So try to make the name descriptive. They're accessed by right clicking (or long press, on mobile) a user or a message, respectively.
-
-All three varieties of application commands have both Global and Guild variants. Your global commands are available in every guild that adds your application. You can also make commands for a specific guild; they're only available in that guild. The User and Message commands are more limited in quantity than the slash commands. For specifics, check out their respective guide pages.
-
-An Interaction is the message that your application receives when a user uses a command. It includes the values that the user submitted, as well as some metadata about this particular instance of the command being used: the guild_id, channel_id, member and other fields. You can find all the values in our data models.
-
-## Authorizing your bot for application commands
-
-There is a new special OAuth2 scope for applications called `applications.commands`. In order to make Application Commands work within a guild, the guild must authorize your application with the `applications.commands` scope. The bot scope is not enough.
-
-Head over to your discord applications OAuth2 screen and make sure to select the `application.commands` scope.
-
-![OAuth2 scoping](slash-commands/images/oauth.png)
-
-From there you can then use the link to add your bot to a server.
-
-> [!NOTE]
-> In order for users in your guild to use your slash commands, they need to have the "Use Slash Command" permission on the guild. 

docs/guides/interactions_framework/autocompleters.md

@@ -1,27 +0,0 @@
----
-uid: Guides.InteractionsFramework.Autocompleters
-title: Autocompleters
----
-
-# Autocompleters
-
-Autocompleters provide a similar pattern to TypeConverters. Autocompleters are cached, singleton services and they are used by the Interaction Service to handle Autocomplete Interations targeted to a specific Slash Command parameter.
-
-To start using Autocompleters, use the `[AutocompleteAttribute(Type autocompleterType)]` overload of the `[AutocompleteAttribute]`. This will dynamically link the parameter to the Autocompleter type.
-
-## Creating Autocompleters
-
-A valid Autocompleter must inherit `AutocompleteHandler` base type and implement all of its abstract methods.
-
-### GenerateSuggestionsAsync()
-
-Interactions Service uses this method to generate a response to a Autocomplete Interaction. This method should return `AutocompletionResult.FromSuccess(IEnumerable<AutocompleteResult>)` to display parameter sugesstions to the user. If there are no suggestions to be presented to the user, you have two options:
-
-1. Returning the parameterless `AutocompletionResult.FromSuccess()` will display "No options match your search." message to the user.
-2. Returning `AutocompleteResult.FromError()` will make the Interaction Service not respond to the interation, consequently displaying the user "Loading options failed." message.
-
-## Resolving Autocompleter Dependencies
-
-Autocompleter dependencies are resolved using the same dependency injection pattern as the Interaction Modules. Property injection and constructor injection are both valid ways to get service dependencies.
-
-Because Autocompleters are constructed at service startup, class dependencies are resolved only once. If you need to access per-request dependencies you can use the IServiceProvider parameter of the `GenerateSuggestionsAsync()` method.

docs/guides/interactions_framework/dependency-injection.md

@@ -1,27 +0,0 @@
----
-uid: Guides.InteractionsFramework.DependencyInjection
-title: Dependency Injection
----
-
-# Dependency Injection
-
-Interaction Service uses dependency injection to perform most of its operations. This way, you can access service dependencies throughout the framework.
-
-## Setup
-
-1. Create a `Microsoft.Extensions.DependencyInjection.ServiceCollection`.
-2. Add the dependencies you wish to use in the modules.
-3. Build a `IServiceProvider` using the `BuildServiceProvider()` method of the `ServiceCollection`.
-4. Pass the `IServiceProvider` to `AddModulesAsync()`, `AddModuleAsync()` and `ExecuteAsync()` methods.
-
-## Accessing the Dependencies
-
-Services of a `IServiceProvider` can be accessed using *Contructor Injection* and *Property Injection*.
-
-Interaction Service will populate the constructor parameters using the provided `IServiceProvider`. Any public settable class Property will also be populated in the same manner.
-
-## Service Scopes
-
-Interaction Service has built-in support for scoped service types. Scoped lifetime services are instantiated once per command execution. Including the Preconditon checks, every module operation is executed within a single service scope (which is sepearate from the global service scope).
-
-> For more in-depth information about service lifetimes check out [Microsoft Docs](https://docs.microsoft.com/en-us/aspnet/core/fundamentals/dependency-injection?view=aspnetcore-5.0#service-lifetimes-1).

docs/guides/interactions_framework/intro.md

@@ -1,360 +0,0 @@
----
-uid: Guides.InteractionsFramework.Intro
-title: Introduction to the Interaction Framework
----
-
-# Getting Started
-
-Interaction Service provides an attribute based framework for creating Discord Interaction handlers.
-
-To start using the Interaction Service, you need to create a service instance. Optionally you can provide the `InterctionService` constructor with a `InteractionServiceConfig` to change the services behaviour to suit your needs.
-
-```csharp
-...
-
-var commands = new InteractionService(discord);
-
-...
-```
-
-## Modules
-
-Attribute based Interaction handlers must be defined within a command module class. Command modules are responsible for executing the Interaction handlers and providing them with the necessary execution info and helper functions.
-
-Command modules are transient objects. A new module instance is created before a command execution starts then it will be disposed right after the method returns.
-
-Every module class must:
-
-- be public
-- inherit `InteractionModuleBase`
-
-Optionally you can override the included :
-
-- OnModuleBuilding (executed after the module is built)
-- BeforeExecute (executed before a command execution starts)
-- AfterExecute (executed after a command execution concludes)
-
-methods to configure the modules behaviour.
-
-Every command module exposes a set of helper methods, namely:
-
-- `RespondAsync()` => Respond to the interaction
-- `FollowupAsync()` => Create a followup message for an interaction
-- `ReplyAsync()` => Send a message to the origin channel of the interaction
-- `DeleteOriginalResponseAsync()` => Delete the original interaction response
-
-## Commands
-
-Valid **Interaction Commands** must comply with the following requirements:
-
-|                               | return type                  | max parameter count | allowed parameter types       | attribute                |
-|-------------------------------|------------------------------|---------------------|-------------------------------|--------------------------|
-|[Slash Command](#slash-commands)| `Task`/`Task<RuntimeResult>` | 25                  | any*                           | `[SlashCommand]`         |
-|[User Command](#user-commands)  | `Task`/`Task<RuntimeResult>` | 1                   | Implementations of `IUser`    | `[UserCommand]`          |
-|[Message Command](#message-commands)| `Task`/`Task<RuntimeResult>` | 1                   | Implementations of `IMessage` | `[MessageCommand]`       |
-|[Component Interaction Command](#component-interaction-commands)| `Task`/`Task<RuntimeResult>` | inf                 | `string` or `string[]`        | `[ComponentInteraction]` |
-|[Autocomplete Command](#autocomplete-commands)| `Task`/`Task<RuntimeResult>` | -             | -                   | `[AutocompleteCommand]`|
-
-> [!NOTE]
-> a `TypeConverter` that is capable of parsing type in question must be registered to the `InteractionService` instance. 
-
-You should avoid using long running code in your command module. Depending on your setup, long running code may block the Gateway thread of your bot, interrupting its connection to Discord.
-
-### Slash Commands
-
-Slash Commands are created using the `[SlashCommandAttribute]`. Every Slash Command must declare a name and a description. You can check Discords **Application Command Naming Guidelines** [here](https://discord.com/developers/docs/interactions/application-commands#application-command-object-application-command-naming).
-
-```csharp
-[SlashCommand("echo", "Echo an input")]
-public async Task Echo(string input)
-{
-    await RespondAsync(input);
-}
-```
-
-#### Parameters
-
-Slash Commands can have up to 25 method parameters. You must name your parameters in accordance with [Discords Naming Guidelines](https://discord.com/developers/docs/interactions/application-commands#application-command-object-application-command-naming). Interaction Service also features a pascal casing seperator for formatting parameter names with pascal casing into Discord compliant parameter names('parameterName' => 'parameter-name'). By default, your methods can feature the following parameter types:
-
-- Implementations of `IUser`
-- Implementations of `IChannel`*
-- Implementations of `IRole`
-- Implementations of `IMentionable`
-- `string`
-- `float`, `double`, `decimal`
-- `bool`
-- `char`
-- `sbyte`, `byte`
-- `int16`, `int32`, `int64`
-- `uint16`, `uint32`, `uint64`
-- `enum` (Values are registered as multiple choice options and are enforced by Discord. Use `[HideAttribute]' on enum values to prevent them from getting registered.)
-- `DateTime`
-- `TimeSpan`
-
----
-
-**You can use more specialized implementations of `IChannel` to restrict the allowed channel types for a channel type option.*
-| interface           | Channel Type                  |
-|---------------------|-------------------------------|
-| `IStageChannel`     | Stage Channels                |
-| `IVoiceChannel`     | Voice Channels                |
-| `IDMChannel`        | DM Channels                   |
-| `IGroupChannel`     | Group Channels                |
-| `ICategory Channel` | Category Channels             |
-| `INewsChannel`      | News Channels                 |
-| `IThreadChannel`    | Public, Private, News Threads |
-| `ITextChannel`      | Text Channels                 |
-
----
-
-##### Optional Parameters
-
-Parameters with default values (ie. `int count = 0`) will be displayed as optional parameters on Discord Client.
-
-##### Parameter Summary
-
-By using the `[SummaryAttribute]` you can customize the displayed name and description of a parameter
-
-```csharp
-[Summary(description: "this is a parameter description")] string input
-```
-
-##### Parameter Choices
-
-`[ChoiceAttribute]` can be used to add choices to a parameter.
-
-```csharp
-[SlashCommand("blep", "Send a random adorable animal photo")]
-public async Task Blep([Choice("Dog","dog"), Choice("Cat", "cat"), Choice("Penguin", "penguin")] string animal)
-{
-    ...
-}
-```
-
-In most cases, instead of relying on this attribute, you should use an `Enum` to create multiple choice parameters. Ex.
-
-```csharp
-public enum Animal
-{
-    Cat,
-    Dog,
-    Penguin
-}
-
-[SlashCommand("blep", "Send a random adorable animal photo")]
-public async Task Blep(Animal animal)
-{
-    ...
-}
-```
-
-This Slash Command will be displayed exactly the same as the previous example.
-
-##### Channel Types
-
-Channel types for an `IChannel` parameter can also be restricted using the `[ChannelTypesAttribute]`.
-
-```csharp
-[SlashCommand("name", "Description")]
-public async Task Command([ChannelTypes(ChannelType.Stage, ChannelType.Text)]IChannel channel)
-{
-    ...
-}
-```
-
-In this case, user can only input Stage Channels and Text Channels to this parameter.
-
-##### Autocomplete
-
-You can enable Autocomple Interactions for a Slash Command parameter using the `[AutocompleteAttribute]`. To handle the Autocomplete Interactions raised by this parameter you can either create [Autocomplete Commands](#autocomplete-commands) or you can opt to use the [Autocompleters Pattern](./autocompleters)
-
-##### Min/Max Value
-
-You can specify the permitted max/min value for a number type parameter using the `[MaxValueAttribute]` and `[MinValueAttribute]`.
-
-### User Commands
-
-A valid User Command must have the following structure:
-
-```csharp
-[UserCommand("Say Hello")]
-public async Task SayHello(IUser user)
-{
-    ...
-}
-```
-
-User commands can only have one parameter and its type must be an implementation of `IUser`.
-
-### Message Commands
-
-A valid Message Command must have the following structure:
-
-```csharp
-[MessageCommand("Bookmark")]
-public async Task Bookmark(IMessage user)
-{
-    ...
-}
-```
-
-Message commands can only have one parameter and its type must be an implementation of `IMessage`.
-
-### Component Interaction Commands
-
-Component Interaction Commands are used to handle interactions that originate from **Discord Message Component**s. This pattern is particularly useful if you will be reusing a set a **Custom ID**s.
-
-```csharp
-[ComponentInteraction("custom_id")]
-public async Task RoleSelection()
-{
-    ...
-}
-```
-
-Component Interaction Commands support wild card matching, by default `*` character can be used to create a wild card pattern. Interaction Service will use lazy matching to capture the words corresponding to the wild card character. And the captured words will be passed on to the command method in the same order they were captured.
-
-*Ex.*
-
-If Interaction Service recieves a component interaction with **player:play,rickroll** custom id, `op` will be *play* and `name` will be *rickroll*
-
-```csharp
-[ComponentInteraction("player:*,*")]
-public async Task Play(string op, string name)
-{
-    ...
-}
-```
-
-You may use as many wild card characters as you want.
-
-#### Select Menus
-
-Unlike button interactions, select menu interactions also contain the values of the selected menu items. In this case, you should structure your method to accept a string array.
-
-```csharp
-[ComponentInteraction("role_selection")]
-public async Task RoleSelection(string[] selectedRoles)
-{
-    ...
-}
-```
-
- Wild card pattern can also be used to match select menu custom ids but remember that the array containing the select menu values should be the last parameter.
-
-```csharp
-[ComponentInteraction("role_selection_*")]
-public async Task RoleSelection(string id, string[] selectedRoles)
-{
-    ...
-}
-```
-
-### Autocomplete Commands
-
-Autocomplete commands must be parameterless methods. A valid Autocomplete command must  have the following structure:
-
-```csharp
-[AutocompleteCommand("command_name", "parameter_name")]
-public async Task Autocomplete()
-{
-    IEnumerable<AutocompleteResult> results;
-
-    ...
-
-    await (Context.Interaction as SocketAutocompleteInteraction).RespondAsync(results);
-}
-```
-
-Alternatively, you can use the *Autocompleters* to simplify this workflow.
-
-## Interaction Context
-
-Every command module provides its commands with an execution context. This context property includes general information about the underlying interaction that triggered the command execution. The base command context.
-
-You can design your modules to work with different implementation types of `IInteractionContext`. To achieve this, make sure your module classes inherit from the generic variant of the `InteractionModuleBase`.
-
-> Context type must be consistent throughout the project, or you will run into issues during runtime.
-
-Interaction Service ships with 4 different kinds of `InteractionContext`s:
-
-1. InteractionContext: A bare-bones execution context consisting of only implementation netural interfaces
-2. SocketInteractionContext: An execution context for use with `DiscordSocketClient`. Socket entities are exposed in this context without the need of casting them.
-3. ShardedInteractionContext: `DiscordShardedClient` variant of the `SocketInteractionContext`
-4. RestInteractionContext: An execution context designed to be used with a `DiscordRestClient` and webhook based interactions pattern
-
-You can create custom Interaction Contexts by implementing the `IInteracitonContext` interface.
-
-One problem with using the concrete type InteractionContexts is that you cannot access the information that is specific to different interaction types without casting. Concrete type interaction contexts are great for creating shared interaction modules but you can also use the generic variants of the built-in interaction contexts to create interaction specific interaction modules.
-
-Ex.
-Message component interactions have access to a special method called `UpdateAsync()` to update the body of the method the interaction originated from. Normally this wouldn't be accessable without casting the `Context.Interaction`.
-
-```csharp
-discordClient.ButtonExecuted += async (interaction) => 
-{
-    var ctx = new SocketInteractionContext<SocketMessageComponent>(discordClient, interaction);
-    await interactionService.ExecuteAsync(ctx, serviceProvider);
-};
-
-public class MessageComponentModule : InteractionModuleBase<SocketInteractionContext<SocketMessageComponent>>
-{
-    [ComponentInteraction("custom_id")]
-    public async Command()
-    {
-        Context.Interaction.UpdateAsync(...);
-    }
-}
-```
-
-## Loading Modules
-
-Interaction Service can automatically discover and load modules that inherit `InteractionModuleBase` from an `Assembly`. Call `InteractionService.AddModulesAsync()` to use this functionality.
-
-You can also manually add Interaction modules using the `InteractionService.AddModuleAsync()` method by providing the module type you want to load.
-
-## Resolving Module Dependencies
-
-Module dependencies are resolved using the Constructor Injection and Property Injection patterns. Meaning, the constructor parameters and public settable properties of a module will be assigned using the `IServiceProvider`. For more information on dependency injection, check out [Dependency Injection](./dependency-injection.md)
-
-## Module Groups
-
-Module groups allow you to create sub-commands and sub-commands groups. By nesting commands inside a module that is tagged with `[GroupAttribute]` you can create prefixed commands.
-
-Although creating nested module stuctures are allowed, you are not permitted to use more than 2 `[GroupAttribute]`s in module hierarchy.
-
-## Executing Commands
-
-Any of the following socket events can be used to execute commands:
-
-- InteractionCreated
-- ButtonExecuted
-- SelectMenuExecuted
-- AutocompleteExecuted
-- UserCommandExecuted
-- MessageCommandExecuted
-
-Commands can be either executed on the gateway thread or on a seperate thread from the thread pool. This behaviour can be configured by changing the *RunMode* property of `InteractionServiceConfig` or by setting the *runMode* parameter of a command attribute.
-
-You can also configure the way `InteractionService` executes the commands. By default, commands are executed using `ConstructorInfo.Invoke()` to create module instances and `MethodInfo.Invoke()` method for executing the method bodies. By setting, `InteractionServiceConfig.UseCompiledLambda` to `true`, you can make `InteractionService` create module instances and execute commands using *Compiled Lambda* expressions. This cuts down on command execution time but it might add some memory overhead.
-
-Time it takes to create a module instance and execute a `Task.Delay(0)` method using the Reflection methods compared to Compiled Lambda expressions:
-
-|           Method |      Mean |    Error |   StdDev |
-|----------------- |----------:|---------:|---------:|
-| ReflectionInvoke | 225.93 ns | 4.522 ns | 7.040 ns |
-|   CompiledLambda |  48.79 ns | 0.981 ns | 1.276 ns |
-
-## Registering Commands to Discord
-
-Application commands loaded to the Interaction Service can be registered to Discord using a number of different methods. In most cases `RegisterCommandsGloballyAsync()` and `RegisterCommandsToGuildAsync()` are the methods to use. Command registration methods can only be used after the gateway client is ready or the rest client is logged in.
-
-In debug environment, since Global commands can take up to 1 hour to register/update, you should register your commands to a test guild for your changes to take effect immediately. You can use the preprocessor directives to create a simple logic for registering commands:
-
-```csharp
-#if DEBUG
-    await interactionService.RegisterCommandsToGuildAsync(<test_guild_id>);
-#else
-    await interactionService.RegisterCommandsGloballyAsync();
-#endif
-```

docs/guides/interactions_framework/post_execution.md

@@ -1,73 +0,0 @@
----
-uid: Guides.InteractionsFramework.PostEx
-title: Post-Execution
----
-
-# Post-Execution Logic
-
-Interaction Service uses `IResult`s to provide information about the state of command execution. These can be used to log internal exceptions or provide some insight to the command user.
-
-If you are running your commands using `RunMode.Sync` these command results can be retrieved from the return value of `InteractionService.ExecuteCommandAsync()` method or by registering delegates to Interaction Service events.
-
-If you are using the `RunMode.Async` to run your commands, you must use the Interaction Service events to get the execution results. When using `RunMode.Async`, `InteractionService.ExecuteCommandAsync()` will always return a successful result.
-
-## Results
-
-Interaction Result come in a handful of different flavours:
-
-1. `AutocompletionResult`: returned by Autocompleters
-2. `ExecuteResult`: contains the result of method body execution process
-3. `PreconditionGroupResult`: returned by Precondition groups
-4. `PreconditionResult`: returned by preconditions
-5. `RuntimeResult`: a user implementable result for returning user defined results
-6. `SearchResult`: returned by command lookup map
-7. `TypeConverterResult`: returned by TypeConverters
-
-You can either use the `IResult.Error` property of an Interaction result or create type check for the afformentioned result types to branch out your post-execution logic to handle different situations.
-
-## CommandExecuted Events
-
-Every time a command gets executed, Interaction Service raises a *CommandExecuted event. These events can be used to create a post-execution pipeline.
-
-```csharp
-interactionService.SlashCommandExecuted += SlashCommandExecuted;
-
-async Task SlashCommandExecuted (SlashCommandInfo arg1, Discord.IInteractionContext arg2, IResult arg3)
-        {
-            if (!arg3.IsSuccess)
-            {
-                switch (arg3.Error)
-                {
-                    case InteractionCommandError.UnmetPrecondition:
-                        await arg2.Interaction.RespondAsync($"Unmet Precondition: {arg3.ErrorReason}");
-                        break;
-                    case InteractionCommandError.UnknownCommand:
-                        await arg2.Interaction.RespondAsync("Unknown command");
-                        break;
-                    case InteractionCommandError.BadArgs:
-                        await arg2.Interaction.RespondAsync("Invalid number or arguments");
-                        break;
-                    case InteractionCommandError.Exception:
-                        await arg2.Interaction.RespondAsync($"Command exception:{arg3.ErrorReason}");
-                        break;
-                    case InteractionCommandError.Unsuccessful:
-                        await arg2.Interaction.RespondAsync("Command could not be executed");
-                        break;
-                    default:
-                        break;
-                }
-            }
-        }
-```
-
-## Log Event
-
-InteractionService regularly outputs information about the occuring events to keep the developer informed.
-
-## Runtime Result
-
-Interaction commands allow you to return `Task<RuntimeResult>` to pass on additional information about the command execution process back to your post-execution logic.
-
-Custom `RuntimeResult` classes can be created by inheriting the base `RuntimeResult` class.
-
-If command execution process reaches the method body of the command and no exceptions are thrown during the execution of the method body, `RuntimeResult` returned by your command will be accessible by casting/type-checking the `IResult` parameter of the *CommandExecuted event delegate.

docs/guides/interactions_framework/preconditions.md

@@ -1,8 +0,0 @@
----
-uid: Guides.InteractionsFramework.Preconditions
-title: Preconditions
----
-
-# Preconditions
-
-Preconditions in Interaction Service work exactly the same as they do in ***Discord.Net.Commands***. For more information, check out [Preconditions](../commands/preconditions.md)

docs/guides/interactions_framework/typeconverters.md

@@ -1,130 +0,0 @@
----
-uid: Guides.InteractionsFramework.TypeConverters
-title: Type Converters
----
-
-# TypeConverters
-
-TypeConverters are responsible for registering command parameters to Discord and parsing the user inputs into method parameters.
-
-By default, TypeConverters for the following types are provided with `Discord.Net.Interactions` library.
-
-- Implementations of `IUser`
-- Implementations of `IChannel`
-- Implementations of `IRole`
-- Implementations of `IMentionable`
-- `string`
-- `float`, `double`, `decimal`
-- `bool`
-- `char`
-- `sbyte`, `byte`
-- `int16`, `int32`, `int64`
-- `uint16`, `uint32`, `uint64`
-- `enum`
-- `DateTime`
-- `TimeSpan`
-
-## Creating TypeConverters
-
-Depending on your needs, there are two types of `TypeConverter`s you can create:
-
-- Concrete type
-- Generic type
-
-A valid converter must inherit `TypeConverter` base type. And override the abstract base methods.
-
-### CanConvertTo() Method
-
-This method is used by Interaction Service to search for alternative Type Converters.
-
-Interaction Services determines the most suitable `TypeConverter` for a parameter type in the following order:
-
-1. It searches for a `TypeConverter` that is registered to specifically target that parameter type
-2. It searches for a generic `TypeConverter` with a matching type constraint. If there are more multiple matches, the one whose type constraint is the most specialized will be chosen.
-3. It searches for a `TypeConverter` that returns `true` when its `CanConvertTo()` method is invoked for thaty parameter type.
-
-> Alternatively, you can use the generic variant (`TypeConverter<T>`) of the `TypeConverter` base class which implements the following method body for `CanConvertTo()` method
-
-```csharp
-public sealed override bool CanConvertTo (Type type) => 
-    typeof(T).IsAssignableFrom(type);
-```
-
-### GetDiscordType() Method
-
-This method is used by Interaction Service to determine the [Discord Application Command Option type](https://discord.com/developers/docs/interactions/application-commands#application-command-object-application-command-option-type) of a parameter type.
-
-### ReadAsync() Method
-
-This method is used by Interaction Service to parse the user input. This method should return `TypeConverterResult.FromSuccess` if the parsing operation is successful, otherwise it should return `TypeConverterResult.FromError`. The inner logic of this method is totally up to you, however you should avoid using long running code.
-
-### Write() Method
-
-This method is used to configure the **Discord Application Command Option** before it gets registered to Discord. Command Option is configured by modifying the `ApplicationCommandOptionProperties` instance.
-
-The default parameter building pipeline is isolated and will not be disturbed by the `TypeConverter` workflow. But changes made in this method will override the values generated by the Interaction Service for a **Discord Application Command Option**.
-
----
-
-### Example Enum TypeConverter
-
-```csharp
-internal sealed class EnumConverter<T> : TypeConverter<T> where T : struct, Enum
-{
-    public override ApplicationCommandOptionType GetDiscordType ( ) => ApplicationCommandOptionType.String;
-
-    public override Task<TypeConverterResult> ReadAsync (IInteractionCommandContext context, SocketSlashCommandDataOption option, IServiceProvider services)
-    {
-        if (Enum.TryParse<T>((string)option.Value, out var result))
-            return Task.FromResult(TypeConverterResult.FromSuccess(result));
-        else
-            return Task.FromResult(TypeConverterResult.FromError(InteractionCommandError.ConvertFailed, $"Value {option.Value} cannot be converted to {nameof(T)}"));
-    }
-
-    public override void Write (ApplicationCommandOptionProperties properties, IParameterInfo parameterInfo)
-    {
-        var names = Enum.GetNames(typeof(T));
-        if (names.Length <= 25)
-        {
-            var choices = new List<ApplicationCommandOptionChoiceProperties>();
-
-            foreach (var name in names)
-                choices.Add(new ApplicationCommandOptionChoiceProperties
-                {
-                    Name = name,
-                    Value = name
-                });
-
-            properties.Choices = choices;
-        }
-    }
-}
-```
-
----
-
-## Registering TypeConverters
-
-> TypeConverters must be registered prior to module discovery. If Interaction Service encounters a parameter type that doesn't belong to any of the  registered `TypeConverter`s during this phase, it will throw an exception.
-
-### Concrete TypeConverters
-
-Registering Concrete TypeConverters are as simple as creating an instance of your custom converter and invoking `AddTypeConverter()` method.
-
-```csharp
-interactionService.AddTypeConverter<string[]>(new StringArrayConverter());
-```
-
-### Generic TypeConverters
-
-To register a generic TypeConverter, you need to invoke the `AddGenericTypeConverter()` method of the Interaction Service class. You need to pass the type of your `TypeConverter` and a target base type to this method.
-
-For instance, to register the previously mentioned [Example Enum Converter](#example-enum-converter) the following can be used:
-
-```csharp
-interactionService.AddGenericTypeConverter<Enum>(typeof(EnumConverter<>));
-```
-
-Interaction service checks if the target base type satisfies the type constraints of the Generic TypeConverter class.
-
-> Dependencies of Generic TypeConverters are also resolved using the Dependency Injection pattern.

docs/guides/introduction/intro.md

@@ -23,7 +23,7 @@ in [our GitHub repository].
 > Please note that you should *not* try to blindly copy paste
 > the code. The examples are meant to be a template or a guide.
 
-[our GitHub repository]: https://github.com/RogueException/Discord.Net/tree/dev/samples
+[our GitHub repository]: https://github.com/discord-net/Discord.Net/
 [Task-based Asynchronous Pattern]: https://docs.microsoft.com/en-us/dotnet/standard/asynchronous-programming-patterns/task-based-asynchronous-pattern-tap
 [polymorphism]: https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/polymorphism
 [interface]: https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/interfaces/
@@ -44,8 +44,5 @@ resources to get you started.
 
 ## Still have questions?
 
-Please visit us at `#dotnet_discord-net` on the [Discord API] server.
-Describe the problem in details to us, what you've done, and,
-if any, the problematic code uploaded onto [Hastebin](https://hastebin.com).
-
-[Discord API]: https://discord.gg/jkrBmQR
+Please visit us at our [Discord](https://discord.gg/dnet) server.
+Describe the problem in details to us, what you've tried and what you need help with.

docs/guides/commands/dependency-injection.md → docs/guides/text_commands/dependency-injection.md

@@ -1,14 +1,18 @@
 ---
-uid: Guides.Commands.DI
+uid: Guides.TextCommands.DI
 title: Dependency Injection
 ---
 
 # Dependency Injection
 
-The Command Service is bundled with a very barebone Dependency
+The Text Command Service is bundled with a very barebone Dependency
 Injection service for your convenience. It is recommended that you use
 DI when writing your modules.
 
+> [!WARNING]
+> If you were brought here from the Interaction Service guides,
+> make sure to replace all namespaces that imply `Discord.Commands` with `Discord.Interactions`
+
 ## Setup
 
 1. Create a @Microsoft.Extensions.DependencyInjection.ServiceCollection.
@@ -44,4 +48,4 @@ manner.
 [!code-csharp[Injection Modules](samples/dependency-injection/dependency_module.cs)]
 [!code-csharp[Disallow Dependency Injection](samples/dependency-injection/dependency_module_noinject.cs)]
 
-[DontInjectAttribute]: xref:Discord.Commands.DontInjectAttribute
+[DontInjectAttribute]: xref:Discord.Commands.DontInjectAttribute

docs/guides/commands/intro.md → docs/guides/text_commands/intro.md

@@ -1,9 +1,9 @@
 ---
-uid: Guides.Commands.Intro
-title: Introduction to Command Service
+uid: Guides.TextCommands.Intro
+title: Introduction to the Chat Command Service
 ---
 
-# The Command Service
+# The Text Command Service
 
 [Discord.Commands](xref:Discord.Commands) provides an attribute-based
 command parser.

docs/guides/commands/namedarguments.md → docs/guides/text_commands/namedarguments.md

@@ -1,5 +1,5 @@
 ---
-uid: Guides.Commands.NamedArguments
+uid: Guides.TextCommands.NamedArguments
 title: Named Arguments
 ---
 

docs/guides/commands/post-execution.md → docs/guides/text_commands/post-execution.md

@@ -1,9 +1,9 @@
 ---
-uid: Guides.Commands.PostExecution
+uid: Guides.TextCommands.PostExecution
 title: Post-command Execution Handling
 ---
 
-# Post-execution Handling for Commands
+# Post-execution Handling for Text Commands
 
 When developing commands, you may want to consider building a
 post-execution handling system so you can have finer control
@@ -117,4 +117,4 @@ of the command.
 [CommandExecuted]: xref:Discord.Commands.CommandService.CommandExecuted
 [ExecuteAsync]: xref:Discord.Commands.CommandService.ExecuteAsync*
 [ExecuteResult]: xref:Discord.Commands.ExecuteResult
-[Command Guide]: xref:Guides.Commands.Intro
+[Command Guide]: xref:Guides.TextCommands.Intro

docs/guides/commands/preconditions.md → docs/guides/text_commands/preconditions.md

@@ -1,5 +1,5 @@
 ---
-uid: Guides.Commands.Preconditions
+uid: Guides.TextCommands.Preconditions
 title: Preconditions
 ---