send

pub async fn send_message(
    &self,
    to: impl Into<Jid>,
    message: wa::Message,
) -> Result<SendResult, anyhow::Error>

#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub struct SendResult {
    pub message_id: String,
    pub to: Jid,
}

impl SendResult {
    /// Returns a MessageKey for this sent message.
    /// Useful for album child linking, pinning, and other operations.
    pub fn message_key(&self) -> wa::MessageKey;
}

pub struct ChatMessageId {
    pub chat: Jid,
    pub id: MessageId,
}

use waproto::whatsapp as wa;

let message = wa::Message {
    conversation: Some("Hello, world!".to_string()),
    ..Default::default()
};

let result = client.send_message(
    "15551234567@s.whatsapp.net".parse()?,
    message
).await?;

println!("Message sent with ID: {}", result.message_id);

use waproto::whatsapp as wa;

let newsletter_jid: Jid = "120363999999999999@newsletter".parse()?;

let message = wa::Message {
    conversation: Some("Hello subscribers!".to_string()),
    ..Default::default()
};

// Newsletter messages are sent as plaintext automatically
let result = client.send_message(newsletter_jid, message).await?;

use waproto::whatsapp as wa;

// First upload the image
let upload_result = client.upload(image_bytes, MediaType::Image, Default::default()).await?;

let message = wa::Message {
    image_message: Some(Box::new(wa::message::ImageMessage {
        url: Some(upload_result.url),
        direct_path: Some(upload_result.direct_path),
        media_key: Some(upload_result.media_key_vec()),
        file_enc_sha256: Some(upload_result.file_enc_sha256_vec()),
        file_sha256: Some(upload_result.file_sha256_vec()),
        file_length: Some(upload_result.file_length),
        media_key_timestamp: Some(upload_result.media_key_timestamp),
        caption: Some("Check out this image!".to_string()),
        mimetype: Some("image/jpeg".to_string()),
        ..Default::default()
    })),
    ..Default::default()
};

let result = client.send_message(chat_jid, message).await?;

use waproto::whatsapp as wa;
use whatsapp_rust::proto_helpers::wrap_as_album_child;

// 1. Send the parent album message with expected media counts
let album_parent = wa::Message {
    album_message: Some(Box::new(wa::message::AlbumMessage {
        expected_image_count: Some(2),
        expected_video_count: Some(1),
        ..Default::default()
    })),
    ..Default::default()
};

let parent_result = client.send_message(&chat_jid, album_parent).await?;
let parent_key = parent_result.message_key();

// 2. Send each child media wrapped as an album child
let image1 = wa::Message {
    image_message: Some(Box::new(wa::message::ImageMessage {
        url: Some(upload1.url),
        direct_path: Some(upload1.direct_path),
        media_key: Some(upload1.media_key_vec()),
        file_sha256: Some(upload1.file_sha256_vec()),
        file_enc_sha256: Some(upload1.file_enc_sha256_vec()),
        file_length: Some(upload1.file_length),
        media_key_timestamp: Some(upload1.media_key_timestamp),
        mimetype: Some("image/jpeg".to_string()),
        ..Default::default()
    })),
    ..Default::default()
};

let wrapped = wrap_as_album_child(image1, parent_key.clone());
client.send_message(&chat_jid, wrapped).await?;

// Repeat for each additional image/video in the album

pub async fn forward_message(
    &self,
    to: impl Into<Jid>,
    message: &wa::Message,
) -> Result<SendResult, anyhow::Error>

// `received` is a `wa::Message` from an incoming event.
let result = client.forward_message(destination_jid, &received).await?;
println!("Forwarded as {:?}", result.message_id);

pub async fn send_message_with_options(
    &self,
    to: impl Into<Jid>,
    message: wa::Message,
    options: SendOptions,
) -> Result<SendResult, anyhow::Error>

pub struct SendOptions {
    /// Override the auto-generated message ID.
    /// Useful for resending a failed message with the same ID or idempotency.
    pub message_id: Option<String>,
    /// Extra XML child nodes on the message stanza.
    pub extra_stanza_nodes: Vec<Node>,
    /// Ephemeral duration in seconds. Sets `contextInfo.expiration` on the
    /// message for disappearing messages support.
    /// Common values: 86400 (24h), 604800 (7d), 7776000 (90d).
    pub ephemeral_expiration: Option<u32>,
    /// Force the `<message type="...">` attribute instead of deriving it from
    /// content. Escape hatch for a type the classifier can't infer.
    pub stanza_type_override: Option<StanzaType>,
}

use whatsapp_rust::send::SendOptions;

let options = SendOptions {
    message_id: Some("3EB0ABC123".to_string()),
    ..Default::default()
};

let result = client.send_message_with_options(
    chat_jid,
    message,
    options
).await?;

assert_eq!(result.message_id, "3EB0ABC123");

use whatsapp_rust::send::SendOptions;

let options = SendOptions {
    ephemeral_expiration: Some(604800), // 7 days
    ..Default::default()
};

let result = client.send_message_with_options(
    chat_jid,
    message,
    options
).await?;

use whatsapp_rust::send::SendOptions;
use wacore_binary::builder::NodeBuilder;

let options = SendOptions {
    extra_stanza_nodes: vec![
        NodeBuilder::new("custom-tag")
            .attr("key", "value")
            .build()
    ],
    ..Default::default()
};

let result = client.send_message_with_options(
    chat_jid,
    message,
    options
).await?;

pub async fn edit_message(
    &self,
    to: impl Into<Jid>,
    original_id: impl Into<String>,
    new_content: wa::Message,
) -> Result<String, anyhow::Error>

use waproto::whatsapp as wa;

// Send original message
let result = client.send_message(
    &chat_jid,
    wa::Message {
        conversation: Some("Hello!".to_string()),
        ..Default::default()
    }
).await?;

// Edit it
let edit_id = client.edit_message(
    &chat_jid,
    &result.message_id,
    wa::Message {
        conversation: Some("Hello, edited!".to_string()),
        ..Default::default()
    }
).await?;

pub async fn edit_message_encrypted(
    &self,
    to: impl Into<Jid>,
    original_id: impl Into<String>,
    message_secret: &[u8],
    new_content: wa::Message,
) -> Result<String, anyhow::Error>

use waproto::whatsapp as wa;

let edit_id = client.edit_message_encrypted(
    &chat_jid,
    &original_id,
    &message_secret,
    wa::Message {
        conversation: Some("edited (encrypted)".to_string()),
        ..Default::default()
    },
).await?;

pub async fn revoke_message(
    &self,
    to: impl Into<Jid>,
    message_id: impl Into<String>,
    revoke_type: RevokeType,
) -> Result<(), anyhow::Error>

#[non_exhaustive]
pub enum RevokeType {
    /// The message sender deleting their own message
    Sender,
    /// A group admin deleting another user's message
    /// `original_sender` is the JID of the user who sent the message
    Admin { original_sender: Jid },
}

// Send a message
let result = client.send_message(
    &chat_jid,
    message
).await?;

// Delete it (sender revoke)
client.revoke_message(
    &chat_jid,
    &result.message_id,
    RevokeType::Sender
).await?;

use wacore_binary::jid::Jid;

// Admin deleting another user's message
let original_sender: Jid = "15551234567@s.whatsapp.net".parse()?;

client.revoke_message(
    group_jid,
    &message_id,
    RevokeType::Admin { original_sender }
).await?;

pub async fn pin_message(
    &self,
    chat: impl Into<Jid>,
    key: wa::MessageKey,
    duration: PinDuration,
) -> Result<(), anyhow::Error>

#[non_exhaustive]
pub enum PinDuration {
    Hours24,
    Days7,   // default
    Days30,
}

use waproto::whatsapp as wa;
use whatsapp_rust::send::PinDuration;

let key = wa::MessageKey {
    remote_jid: Some(chat_jid.to_string()),
    id: Some(message_id.clone()),
    from_me: Some(false),
    participant: None,
};

client.pin_message(chat_jid, key, PinDuration::Days7).await?;

use waproto::whatsapp as wa;
use whatsapp_rust::send::PinDuration;

let key = wa::MessageKey {
    remote_jid: Some(group_jid.to_string()),
    id: Some(message_id.clone()),
    from_me: Some(false),
    participant: Some(sender_jid.to_string()),
};

client.pin_message(group_jid, key, PinDuration::Days30).await?;

pub async fn unpin_message(
    &self,
    chat: impl Into<Jid>,
    key: wa::MessageKey,
) -> Result<(), anyhow::Error>

use waproto::whatsapp as wa;

let key = wa::MessageKey {
    remote_jid: Some(chat_jid.to_string()),
    id: Some(message_id.clone()),
    from_me: Some(false),
    participant: None,
};

client.unpin_message(chat_jid, key).await?;

pub async fn keep_message(
    &self,
    chat: impl Into<Jid>,
    key: wa::MessageKey,
    keep: bool,
) -> Result<SendResult, anyhow::Error>

use waproto::whatsapp as wa;

let key = wa::MessageKey {
    remote_jid: Some(chat_jid.to_string()),
    id: Some(message_id.clone()),
    from_me: Some(false),
    participant: None,
};

client.keep_message(chat_jid, key, true).await?;

use waproto::whatsapp as wa;

let key = wa::MessageKey {
    remote_jid: Some(group_jid.to_string()),
    id: Some(message_id.clone()),
    from_me: Some(false),
    participant: Some(sender_jid.to_string()),
};

client.keep_message(group_jid, key, false).await?;

pub async fn set_chat_disappearing_timer(
    &self,
    chat: Jid,
    duration: u32,
) -> Result<SendResult, anyhow::Error>

let chat: Jid = "15551234567@s.whatsapp.net".parse()?;

// Enable 7-day disappearing messages
client.set_chat_disappearing_timer(chat.clone(), 604_800).await?;

// Turn it off
client.set_chat_disappearing_timer(chat, 0).await?;

pub async fn send_reaction(
    &self,
    chat: impl Into<Jid>,
    target_key: wa::MessageKey,
    emoji: &str,
) -> Result<SendResult, anyhow::Error>

use waproto::whatsapp as wa;

let target_key = wa::MessageKey {
    remote_jid: Some(chat_jid.to_string()),
    from_me: Some(false),
    id: Some(target_message_id.clone()),
    participant: None, // DMs omit participant
};

client.send_reaction(&chat_jid, target_key, "👍").await?;

use waproto::whatsapp as wa;

let target_key = wa::MessageKey {
    remote_jid: Some(group_jid.to_string()),
    from_me: Some(false),
    id: Some(target_message_id.clone()),
    // The original sender — required for groups so the receipt can be attributed.
    participant: Some(sender_jid.to_string()),
};

client.send_reaction(&group_jid, target_key, "🎉").await?;

client.send_reaction(&chat_jid, target_key, "").await?;

<biz>
  <interactive type="native_flow" v="1">
    <native_flow name="order_details"/>
  </interactive>
</biz>

use whatsapp_rust::{StanzaType, send::SendOptions};

let options = SendOptions {
    stanza_type_override: Some(StanzaType::Text),
    ..Default::default()
};

let result = client
    .send_message_with_options(to, message, options)
    .await?;

use waproto::whatsapp as wa;
use wacore::proto_helpers::build_quote_context_with_info;

let context = build_quote_context_with_info(
    quoted_message_id,
    &quoted_sender_jid,
    &chat_jid, // quoted_chat_jid
    &chat_jid, // target_chat_jid (same as quoted for in-place replies)
    &quoted_message,
);

let message = wa::Message {
    extended_text_message: Some(Box::new(wa::message::ExtendedTextMessage {
        text: Some("Reply to your message".to_string()),
        context_info: Some(Box::new(context)),
        ..Default::default()
    })),
    ..Default::default()
};