Struct serenity::model::interactions::ApplicationCommand

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

This is supported on crate feature unstable_discord_api only.

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.

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.

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 become available.

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

Examples

Create a simple ping command

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

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

Create a command that echoes what is inserted

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

let _ = ApplicationCommand::create_global_application_command(&http, |a| {
   a.name("echo")
    .description("What is said is echoed")
    .create_option(|o| {
        o.name("to_say")
         .description("What will be echoed")
         .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 create_global_application_commands<F>(
    http: impl AsRef<Http>,
    f: F
) -> Result<Vec<ApplicationCommand>> where
    F: FnOnce(&mut CreateApplicationCommands) -> &mut CreateApplicationCommands, 

Same as create_global_application_command but allows to create more than one global command per call.

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.

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

Gets all global commands.

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

Gets a global command by its Id.

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

Deletes a global command by its Id.

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.