Newsletter

let newsletter = client.newsletter();

pub async fn list_subscribed(&self) -> Result<Vec<NewsletterMetadata>, NewsletterError>

let newsletters = client.newsletter().list_subscribed().await?;

for nl in &newsletters {
    println!("{}: {} ({} subscribers)", nl.jid, nl.name, nl.subscriber_count);
}

pub async fn get_metadata(&self, jid: &Jid) -> Result<NewsletterMetadata, NewsletterError>

let metadata = client.newsletter().get_metadata(&newsletter_jid).await?;

println!("Name: {}", metadata.name);
println!("Subscribers: {}", metadata.subscriber_count);
println!("Verified: {:?}", metadata.verification);

use whatsapp_rust::NewsletterError;

match client.newsletter().get_metadata(&newsletter_jid).await {
    Ok(metadata) => println!("Found: {}", metadata.name),
    Err(NewsletterError::NotFound(jid)) => eprintln!("No channel at {}", jid),
    Err(e) => eprintln!("Error: {}", e),
}

pub async fn get_metadata_by_invite(
    &self,
    invite_code: &str,
) -> Result<NewsletterMetadata, NewsletterError>

let metadata = client.newsletter()
    .get_metadata_by_invite("ABC123")
    .await?;

println!("Found: {} ({})", metadata.name, metadata.jid);

pub async fn create(
    &self,
    name: &str,
    description: Option<&str>,
) -> Result<NewsletterMetadata, NewsletterError>

let created = client.newsletter()
    .create("My Channel", Some("A description"))
    .await?;

println!("Created: {} ({})", created.name, created.jid);

pub async fn join(&self, jid: &Jid) -> Result<NewsletterMetadata, NewsletterError>

let joined = client.newsletter().join(&newsletter_jid).await?;

println!("Joined '{}' as {:?}", joined.name, joined.role);

pub async fn leave(&self, jid: &Jid) -> Result<(), NewsletterError>

client.newsletter().leave(&newsletter_jid).await?;

pub async fn update(
    &self,
    jid: &Jid,
    name: Option<&str>,
    description: Option<&str>,
) -> Result<NewsletterMetadata, NewsletterError>

let updated = client.newsletter()
    .update(&newsletter_jid, Some("New Name"), None)
    .await?;

println!("Updated: {}", updated.name);

pub async fn set_picture(
    &self,
    jid: &Jid,
    jpeg: &[u8],
) -> Result<NewsletterMetadata, NewsletterError>

let updated = client.newsletter()
    .set_picture(&newsletter_jid, &jpeg_bytes)
    .await?;

pub async fn remove_picture(&self, jid: &Jid) -> Result<NewsletterMetadata, NewsletterError>

client.newsletter().remove_picture(&newsletter_jid).await?;

pub async fn delete(&self, jid: &Jid) -> Result<(), NewsletterError>

client.newsletter().delete(&newsletter_jid).await?;

pub async fn change_owner(&self, jid: &Jid, user: &Jid) -> Result<(), NewsletterError>

client.newsletter()
    .change_owner(&newsletter_jid, &new_owner_jid)
    .await?;

pub async fn demote_admin(&self, jid: &Jid, user: &Jid) -> Result<(), NewsletterError>

client.newsletter()
    .demote_admin(&newsletter_jid, &admin_jid)
    .await?;

pub async fn get_admin_info(&self, jid: &Jid) -> Result<NewsletterAdminInfo, NewsletterError>

let info = client.newsletter().get_admin_info(&newsletter_jid).await?;

println!("Admins: {:?}", info.admin_count);

pub async fn get_followers(
    &self,
    jid: &Jid,
    count: u32,
) -> Result<Vec<NewsletterFollower>, NewsletterError>

let followers = client.newsletter()
    .get_followers(&newsletter_jid, 100)
    .await?;

for f in &followers {
    println!("{}: {:?}", f.jid, f.role);
}

pub async fn set_follower_mute(&self, jid: &Jid, muted: bool) -> Result<(), NewsletterError>

// Mute
client.newsletter().set_follower_mute(&newsletter_jid, true).await?;

// Unmute
client.newsletter().set_follower_mute(&newsletter_jid, false).await?;

pub async fn set_admin_mute(&self, jid: &Jid, muted: bool) -> Result<(), NewsletterError>

client.newsletter().set_admin_mute(&newsletter_jid, true).await?;

use whatsapp_rust::waproto::whatsapp as wa;

let mut message = wa::Message::default();
message.conversation = Some("Hello subscribers!".to_string());

// Pass a newsletter JID directly to send_message
let msg_id = client.send_message(newsletter_jid, message).await?;

use whatsapp_rust::{Client, NewsletterMessageRef};

async fn react(client: &Client, target: &NewsletterMessageRef<'_>) -> whatsapp_rust::anyhow::Result<()> {
    let operation = client.newsletter().send_reaction(target, "👍").await?;
    println!("ACK operation: {}", operation.as_str());
    client.newsletter().send_reaction(target, "").await?;
    Ok(())
}

use whatsapp_rust::{Client, NewsletterMessageRef};
use whatsapp_rust::wacore::poll::compute_option_hash;

async fn vote(client: &Client, poll: &NewsletterMessageRef<'_>) -> whatsapp_rust::anyhow::Result<()> {
    client.newsletter().send_poll_vote(poll, &[compute_option_hash("Rust")]).await?;
    Ok(())
}

pub async fn get_messages(
    &self,
    jid: &Jid,
    count: u32,
    before: Option<u64>,
) -> Result<Vec<NewsletterMessage>, NewsletterError>

// Fetch latest 50 messages
let messages = client.newsletter()
    .get_messages(&newsletter_jid, 50, None)
    .await?;

// Paginate backwards
if let Some(oldest) = messages.last() {
    let older = client.newsletter()
        .get_messages(&newsletter_jid, 50, Some(oldest.server_id))
        .await?;
}

pub async fn get_my_addons(
    &self,
    jid: &Jid,
    limit: u32,
) -> Result<Vec<NewsletterMyAddOns>, NewsletterError>

let addons = client.newsletter()
    .get_my_addons(&newsletter_jid, 20)
    .await?;

for addon in &addons {
    if let Some(reaction) = &addon.reaction {
        println!("{}: reacted {}", addon.server_id, reaction.code);
    }
    match &addon.poll_vote {
        Some(vote) if vote.option_hashes.is_empty() => {
            println!("{}: vote removed", addon.server_id);
        }
        Some(vote) => {
            println!("{}: voted for {} option(s)", addon.server_id, vote.option_hashes.len());
        }
        None => {}
    }
}

pub async fn subscribe_live_updates(
    &self,
    jid: &Jid,
) -> Result<u64, NewsletterError>

let duration = client.newsletter()
    .subscribe_live_updates(&newsletter_jid)
    .await?;

println!("Subscribed for {}s", duration);

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct NewsletterMetadata {
    pub jid: Jid,
    pub name: String,
    pub description: Option<String>,
    pub subscriber_count: u64,
    pub verification: NewsletterVerification,
    pub state: NewsletterState,
    pub picture_url: Option<String>,
    pub preview_url: Option<String>,
    pub invite_code: Option<String>,
    pub role: Option<NewsletterRole>,
    pub creation_time: Option<u64>,
    pub muted: Option<bool>,
    pub follower_activity_muted: Option<bool>,
}

#[non_exhaustive]
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum NewsletterVerification {
    Verified,
    Unverified,
    /// A value this library does not model, as the server spelled it.
    Other(String),
}

#[non_exhaustive]
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum NewsletterState {
    Active,
    Suspended,
    Geosuspended,
    /// A state this library does not model, as the server spelled it.
    Other(String),
}

match metadata.state {
    NewsletterState::Active => println!("Channel is active"),
    NewsletterState::Suspended | NewsletterState::Geosuspended => println!("Channel is suspended"),
    NewsletterState::Other(ref s) if s.eq_ignore_ascii_case("DELETED") => println!("Channel was deleted"),
    _ => println!("Unknown state"),
}

#[non_exhaustive]
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum NewsletterRole {
    Owner,
    Admin,
    Subscriber,
    Guest,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct NewsletterAdminProfile {
    pub id: Option<String>,
    pub name: String,
    pub picture_id: Option<String>,
    pub picture_direct_path: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct NewsletterAdminInfo {
    pub admin_count: Option<u32>,
    pub admin_profile: Option<NewsletterAdminProfile>,
    pub admin_profiles_enabled: Option<bool>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct NewsletterFollower {
    pub jid: Jid,
    pub phone_jid: Option<Jid>,
    pub display_name: Option<String>,
    pub username: Option<String>,
    pub role: Option<NewsletterRole>,
    pub follow_time: Option<u64>,
    pub admin_profile: Option<NewsletterAdminProfile>,
}

#[non_exhaustive]
pub struct NewsletterMessage {
    pub message_id: Option<MessageId>,
    pub server_id: u64,
    pub timestamp: u64,
    pub message_type: NewsletterMessageType,
    pub message_type_raw: Option<String>,
    pub edit: EditAttribute,
    pub is_sender: bool,
    pub message: Option<wa::Message>,
    pub media_type: Option<NewsletterMediaType>,
    pub reactions: Vec<NewsletterReactionCount>,
    pub votes: Vec<NewsletterPollVote>,
    pub forwards_count: Option<u64>,
    pub views_count: Option<u64>,
    pub responses_count: Option<u64>,
    pub original_timestamp: Option<u64>,
    pub last_edit_timestamp_ms: Option<u64>,
    pub poll_type: Option<PollType>,
    pub poll_type_raw: Option<String>,
    pub content_type: Option<String>,
    pub question_type: Option<NewsletterQuestionType>,
    pub message_association_type: Option<NewsletterMessageAssociationType>,
    pub is_wamo_sub: bool,
    pub admin_profile: Option<NewsletterAdminProfile>,
    pub rcat: Option<Vec<u8>>,
}

#[non_exhaustive]
pub enum NewsletterMessageType {
    Text,          // "text"
    Media,         // "media"
    Poll,          // "poll"
    Reaction,      // (never emitted; see NewsletterMessage.reactions)
    Revoke,        // (never emitted; a revocation is edit="8")
    PollCreation,  // (never emitted; use Poll + poll_type)
    PollVote,      // (never emitted; use NewsletterMessage.votes)
    Edit,          // (never emitted; an edit is edit="3")
    Other(String),
}

#[non_exhaustive]
pub enum NewsletterMediaType {
    OnePSticker, Audio, AvatarSticker, CatalogLink, Collection, Document,
    GenAiSticker, Gif, Image, MotionPhoto, MotionVideo, ProductLink,
    Ptt, Ptv, Sticker, StickerPack, Url, UserCreatedSticker, Vcard, Video,
    Other(String),
}

#[non_exhaustive]
pub enum NewsletterQuestionType {
    Question, // "question"
    Reply,    // "reply"
    Other(String),
}

#[non_exhaustive]
pub enum NewsletterMessageAssociationType {
    HdImageDualUpload,
    HdVideoDualUpload,
    HevcVideoDualUpload,
    MediaPoll,
    MotionPhoto,
    PollAddOption,
    StickerAnnotation,
    Other(String),
}

pub struct NewsletterReactionCount {
    pub code: String,
    pub count: u64,
}

#[non_exhaustive]
pub struct NewsletterPollVote {
    /// SHA-256 of the option name (same digest as `wacore::poll::compute_option_hash`).
    /// Match it against the options of the `pollCreationMessage` in
    /// `NewsletterMessage::message` to recover which option was voted for.
    pub option_hash: [u8; 32],
    /// How many followers picked this option.
    pub count: u64,
}

#[non_exhaustive]
pub struct NewsletterMyAddOns {
    pub server_id: u64,
    pub reaction: Option<NewsletterMyReaction>,
    pub poll_vote: Option<NewsletterMyPollVote>,
}

#[non_exhaustive]
pub struct NewsletterMyReaction {
    pub code: String,    // Reaction emoji
    pub timestamp: u64,  // When it was set (Unix seconds)
}

#[non_exhaustive]
pub struct NewsletterMyPollVote {
    pub timestamp: u64,
    pub option_hashes: Vec<[u8; 32]>,
}

#[non_exhaustive]
pub enum NewsletterError {
    #[error("{0}")]
    Poll(#[from] PollError),
    #[error("{0}")]
    Send(#[from] SendError),
    #[error("{0}")]
    MessageRef(#[from] MessageRefError),
    #[error("{0}")]
    Mex(#[from] MexError),
    #[error("{0}")]
    Iq(#[from] IqError),
    #[error("{0}")]
    Client(#[from] ClientError),
    #[error("picture data cannot be empty; use remove_picture instead")]
    EmptyPicture,
    #[error("invalid newsletter request: {0}")]
    InvalidRequest(String),
    #[error("newsletter not found: {0}")]
    NotFound(Jid),
    #[error("{0}")]
    Internal(#[from] anyhow::Error),
}

use whatsapp_rust::NewsletterError;

match client.newsletter().join(&newsletter_jid).await {
    Ok(metadata) => println!("Joined: {}", metadata.jid),
    Err(NewsletterError::Mex(e)) => eprintln!("MEX error: {}", e),
    Err(NewsletterError::Iq(e)) => eprintln!("IQ error: {}", e),
    Err(e) => eprintln!("Error: {}", e),
}