Struct Bot 

pub struct Bot { /* private fields */ }

A configured WhatsApp session with its event handlers already wired, ready to be started.

This is the high-level entry point and what most applications should use. Build one with Bot::builder: the typestate BotBuilder takes the storage backend (the only required dependency with the default cargo features), the pairing callbacks, and the message/event handlers, then hands back a Bot.

Starting it is a single call. Bot::run drives the session on the current task until logout or shutdown; Bot::spawn starts it on the runtime instead and returns a BotHandle you can await, shut down gracefully, or abort. Both consume the Bot, so handlers are registered at build time, not afterwards.

let bot = Bot::builder()
    .with_backend(SqliteStore::new("whatsapp.db").await?)
    .on_message(|ctx| async move {
        let _ = ctx.reply("pong").await;
    })
    .build()
    .await?;

bot.run().await;

Handlers registered through the builder (on_message, on_event, …) receive typed Event payloads. Anything the builder does not expose is reachable on the underlying client via Bot::client, which stays valid after the bot is started.

Implementations

impl Bot

pub fn builder() -> BotBuilder<MissingBackend, Provided, Provided, Provided>

pub fn client(&self) -> Arc<Client>

pub async fn run(self)

Run the bot on the current task until it shuts down (logout, or Client::disconnect called on Bot::client from another task).

To run in the background instead, use Bot::spawn.

Coroutines are LocalCopy across crates: a consumer crate that awaits this future re-codegens the whole state machine graph behind it in its own binary. The boxed barrier below type-erases the graph in a plain (linker-shared) function, so callers poll through a vtable and the graph is compiled once, here. One allocation per process.

pub fn spawn(self) -> BotHandle

Start the bot on its runtime and return a BotHandle to await, gracefully shut down, or abort it.

Trait Implementations

impl Debug for Bot

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.