Struct serenity::model::interactions::application_command::ApplicationCommand

#[non_exhaustive]
pub struct ApplicationCommand {
    pub id: CommandId,
    pub kind: ApplicationCommandType,
    pub application_id: ApplicationId,
    pub guild_id: Option<GuildId>,
    pub name: String,
    pub description: String,
    pub options: Vec<ApplicationCommandOption>,
    pub default_permission: bool,
    pub version: CommandVersionId,
}

The base command model that belongs to an application.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

id: CommandId

The command Id.

kind: ApplicationCommandType

The application command kind.

application_id: ApplicationId

The parent application Id.

guild_id: Option<GuildId>

The command guild Id, if it is a guild command.

Note: It may only be present if it is received through the gateway.

name: String

The command name.

description: String

The command description.

options: Vec<ApplicationCommandOption>

The parameters for the command.

default_permission: bool

Whether the command is enabled by default when the application is added to a guild.

version: CommandVersionId

An autoincremented version identifier updated during substantial record changes.

Implementations

impl ApplicationCommand

pub async fn create_global_application_command<F>(
    http: impl AsRef<Http>,
    f: F
) -> Result<ApplicationCommand> where
    F: FnOnce(&mut CreateApplicationCommand) -> &mut CreateApplicationCommand, 

Creates a global ApplicationCommand, overriding an existing one with the same name if it exists.

When a created ApplicationCommand is used, the InteractionCreate event will be emitted.

Note: Global commands may take up to an hour to be updated in the user slash commands list. If an outdated command data is sent by a user, discord will consider it as an error and then will instantly update that command.

As such, it is recommended that guild application commands be used for testing purposes.

Examples

Create a simple ping command:

use serenity::model::{
    id::ApplicationId,
    interactions::application_command::ApplicationCommand,
};

let _ = ApplicationCommand::create_global_application_command(&http, |command| {
    command.name("ping").description("A simple ping command")
})
.await;

Create a command that echoes what is inserted:

use serenity::model::{
    id::ApplicationId,
    interactions::application_command::{ApplicationCommand, ApplicationCommandOptionType},
};

let _ = ApplicationCommand::create_global_application_command(&http, |command| {
    command.name("echo").description("Makes the bot send a message").create_option(|option| {
        option
            .name("message")
            .description("The message to send")
            .kind(ApplicationCommandOptionType::String)
            .required(true)
    })
})
.await;

Errors

May return an Error::Http if the ApplicationCommand is illformed, such as if more than 10 choices are set. See the API Docs for further details.

Can also return an Error::Json if there is an error in deserializing the response.

pub async fn set_global_application_commands<F>(
    http: impl AsRef<Http>,
    f: F
) -> Result<Vec<ApplicationCommand>> where
    F: FnOnce(&mut CreateApplicationCommands) -> &mut CreateApplicationCommands, 

Overrides all global application commands.

Errors

If there is an error, it will be either Error::Http or Error::Json.

pub async fn edit_global_application_command<F>(
    http: impl AsRef<Http>,
    command_id: CommandId,
    f: F
) -> Result<ApplicationCommand> where
    F: FnOnce(&mut CreateApplicationCommand) -> &mut CreateApplicationCommand, 

Edits a global command by its Id.

Errors

If there is an error, it will be either Error::Http or Error::Json.

pub async fn get_global_application_commands(
    http: impl AsRef<Http>
) -> Result<Vec<ApplicationCommand>>

Gets all global commands.

Errors

If there is an error, it will be either Error::Http or Error::Json.

pub async fn get_global_application_command(
    http: impl AsRef<Http>,
    command_id: CommandId
) -> Result<ApplicationCommand>

Gets a global command by its Id.

Errors

If there is an error, it will be either Error::Http or Error::Json.

pub async fn delete_global_application_command(
    http: impl AsRef<Http>,
    command_id: CommandId
) -> Result<()>

Deletes a global command by its Id.

Errors

If there is an error, it will be either Error::Http or Error::Json.

Trait Implementations

impl Clone for ApplicationCommand

fn clone(&self) -> ApplicationCommand

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ApplicationCommand

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ApplicationCommand

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Serialize for ApplicationCommand

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.