Client

use whatsapp_rust::Client;
use std::sync::Arc;

let (client, sync_receiver) = Client::new(
    persistence_manager,
    transport_factory,
    http_client,
    None, // version override
).await;

pub async fn run(self: &Arc<Self>)

let client_clone = client.clone();
tokio::spawn(async move {
    client_clone.run().await;
});

pub async fn connect(self: &Arc<Self>) -> Result<(), anyhow::Error>

pub async fn disconnect(self: &Arc<Self>)

pub async fn wait_for_socket(
    &self,
    timeout: std::time::Duration
) -> Result<(), anyhow::Error>

pub async fn wait_for_connected(
    &self,
    timeout: std::time::Duration
) -> Result<(), anyhow::Error>

pub fn is_connected(&self) -> bool

pub fn is_logged_in(&self) -> bool

// Disable auto-reconnect (default: enabled)
client.enable_auto_reconnect.store(false, Ordering::Relaxed);

// Check current state
let enabled = client.enable_auto_reconnect.load(Ordering::Relaxed);

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

use waproto::whatsapp as wa;

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

let msg_id = client.send_message(jid, message).await?;

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

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

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

pub fn blocking(&self) -> Blocking<'_>

client.blocking().block(&jid).await?;
let blocked = client.blocking().get_blocklist().await?;

pub fn groups(&self) -> Groups<'_>

use whatsapp_rust::features::{GroupCreateOptions, GroupSubject};

let options = GroupCreateOptions::new(
    GroupSubject::new("My Group")?,
    vec![participant_jid],
);
let result = client.groups().create_group(options).await?;

pub fn presence(&self) -> Presence<'_>

client.presence().set_available().await?;
client.presence().subscribe(&jid).await?;

pub fn contacts(&self) -> Contacts<'_>

pub fn tc_token(&self) -> TcToken<'_>

pub async fn get_push_name(&self) -> String

pub async fn get_pn(&self) -> Option<Jid>

pub async fn get_lid(&self) -> Option<Jid>

pub fn persistence_manager(&self) -> Arc<PersistenceManager>

pub fn set_skip_history_sync(&self, enabled: bool)

pub fn skip_history_sync_enabled(&self) -> bool

pub async fn fetch_props(&self) -> Result<(), IqError>

pub async fn fetch_privacy_settings(&self) -> Result<PrivacySettingsResponse, IqError>

pub async fn clean_dirty_bits(
    &self,
    type_: &str,
    timestamp: Option<&str>
) -> Result<(), IqError>

pub async fn send_node(&self, node: Node) -> Result<(), ClientError>

pub fn register_handler(&self, handler: Arc<dyn EventHandler>)

use wacore::types::events::{Event, EventHandler};

struct MyHandler;

impl EventHandler for MyHandler {
    fn handle_event(&self, event: &Event) {
        match event {
            Event::Message(msg) => println!("New message: {:?}", msg),
            Event::Connected(_) => println!("Connected!"),
            _ => {}
        }
    }
}

client.register_handler(Arc::new(MyHandler));

pub async fn register_chatstate_handler(
    &self,
    handler: Arc<dyn Fn(ChatStateEvent) + Send + Sync>
)

pub async fn send_spam_report(
    &self,
    request: SpamReportRequest
) -> Result<SpamReportResult, IqError>

use whatsapp_rust::{SpamReportRequest, SpamFlow};

// Report a spam message
let result = client.send_spam_report(SpamReportRequest {
    message_id: "MESSAGE_ID".to_string(),
    message_timestamp: 1234567890,
    from_jid: Some(sender_jid),
    spam_flow: SpamFlow::MessageMenu,
    ..Default::default()
}).await?;

pub async fn set_passive(&self, passive: bool) -> Result<(), IqError>

pub async fn send_digest_key_bundle(&self) -> Result<(), IqError>

pub enum ClientError {
    NotConnected,
    Socket(SocketError),
    EncryptSend(EncryptSendError),
    AlreadyConnected,
    NotLoggedIn,
}