Struct twilight_http::request::application::interaction::create_followup_message::CreateFollowupMessage

pub struct CreateFollowupMessage<'a> { /* fields omitted */ }

Create a followup message to an interaction.

You must specify at least one of content, embeds, or files.

Examples

use std::env;
use twilight_http::Client;
use twilight_model::id::ApplicationId;

let client = Client::new(env::var("DISCORD_TOKEN")?);
client.set_application_id(ApplicationId::new(1).expect("non zero"));

client
    .create_followup_message("webhook token")?
    .content("Pinkie...")
    .exec()
    .await?;

Implementations

impl<'a> CreateFollowupMessage<'a>

pub const fn allowed_mentions(
    self,
    allowed_mentions: &'a AllowedMentions
) -> Self

Specify the AllowedMentions for the webhook message.

pub const fn avatar_url(self, avatar_url: &'a str) -> Self

The URL of the avatar of the webhook.

pub fn components(
    self,
    components: &'a [Component]
) -> Result<Self, CreateFollowupMessageError>

Add multiple Components to a message.

Calling this method multiple times will clear previous calls.

Errors

Returns an CreateFollowupMessageErrorType::ComponentCount error type if too many components are provided.

Returns an CreateFollowupMessageErrorType::ComponentInvalid error type if one of the provided components is invalid.

pub const fn content(self, content: &'a str) -> Self

The content of the webook’s message.

Up to 2000 UTF-16 codepoints.

pub const fn embeds(self, embeds: &'a [Embed]) -> Self

Set the list of embeds of the webhook’s message.

pub const fn ephemeral(self, ephemeral: bool) -> Self

Set if the followup should be ephemeral.

pub const fn files(self, files: &'a [(&'a str, &'a [u8])]) -> Self

Attach multiple files to the webhook.

pub const fn payload_json(self, payload_json: &'a [u8]) -> Self

JSON encoded body of any additional request fields.

If this method is called, all other fields are ignored, except for file. See Discord Docs/Create Message.

Examples

Without payload_json:

use std::env;
use twilight_embed_builder::EmbedBuilder;
use twilight_http::Client;
use twilight_model::id::{MessageId, ApplicationId};

let client = Client::new(env::var("DISCORD_TOKEN")?);
client.set_application_id(ApplicationId::new(1).expect("non zero"));

let message = client.create_followup_message("token here")?
    .content("some content")
    .embeds(&[EmbedBuilder::new().title("title").build()?])
    .exec()
    .await?
    .model()
    .await?;

assert_eq!(message.content, "some content");

With payload_json:

use std::env;
use twilight_http::Client;
use twilight_model::id::{MessageId, ApplicationId};

let client = Client::new(env::var("DISCORD_TOKEN")?);
client.set_application_id(ApplicationId::new(1).expect("non zero"));

let message = client.create_followup_message("token here")?
    .content("some content")
    .payload_json(br#"{ "content": "other content", "embeds": [ { "title": "title" } ] }"#)
    .exec()
    .await?
    .model()
    .await?;

assert_eq!(message.content, "other content");

pub const fn tts(self, tts: bool) -> Self

Specify true if the message is TTS.

pub const fn username(self, username: &'a str) -> Self

Specify the username of the webhook’s message.

pub fn exec(self) -> ResponseFuture<Message>

Execute the request, returning a future resolving to a Response.