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);

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_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 waproto::whatsapp as wa;

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

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

pub async fn send_reaction(
    &self,
    jid: &Jid,
    server_id: u64,
    reaction: &str,
) -> Result<(), NewsletterError>

// Add a reaction
client.newsletter()
    .send_reaction(&newsletter_jid, server_id, "👍")
    .await?;

// Remove a reaction
client.newsletter()
    .send_reaction(&newsletter_jid, server_id, "")
    .await?;

pub async fn edit_message(
    &self,
    jid: &Jid,
    message_id: impl Into<String>,
    new_content: wa::Message,
) -> Result<(), NewsletterError>

use waproto::whatsapp as wa;

let new_body = wa::Message {
    conversation: Some("edited text".to_string()),
    ..Default::default()
};

client.newsletter()
    .edit_message(&newsletter_jid, original_message_id, new_body)
    .await?;

pub async fn revoke_message(
    &self,
    jid: &Jid,
    message_id: impl Into<String>,
) -> Result<(), NewsletterError>

client.newsletter()
    .revoke_message(&newsletter_jid, message_id)
    .await?;

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 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>,
}

#[non_exhaustive]
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum NewsletterVerification {
    Verified,
    Unverified,
}

#[non_exhaustive]
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum NewsletterState {
    Active,
    Suspended,
    Geosuspended,
}

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

pub struct NewsletterMessage {
    /// Server-assigned message ID (monotonic, used for pagination cursors).
    pub server_id: u64,
    /// Message timestamp (Unix seconds).
    pub timestamp: u64,
    /// Message type (Text, Media, Reaction, etc.).
    pub message_type: NewsletterMessageType,
    /// Whether the viewer is the sender.
    pub is_sender: bool,
    /// Decoded protobuf message (from plaintext bytes).
    pub message: Option<wa::Message>,
    /// Reaction counts on this message.
    pub reactions: Vec<NewsletterReactionCount>,
}

#[non_exhaustive]
pub enum NewsletterMessageType {
    Text,          // "text"
    Media,         // "media"
    Reaction,      // "reaction"
    Revoke,        // "revoke"
    PollCreation,  // "poll_creation"
    PollVote,      // "poll_vote"
    Edit,          // "edit"
    Other(String), // Unknown/future types
}

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

#[non_exhaustive]
pub enum NewsletterError {
    #[error(transparent)]
    Mex(#[from] MexError),
    #[error(transparent)]
    Iq(#[from] IqError),
    #[error(transparent)]
    Client(#[from] ClientError),
    #[error("invalid newsletter request: {0}")]
    InvalidRequest(String),
    #[error(transparent)]
    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),
}