Rust SDK email client

// From environment variables (recommended)
let client = PauboxClient::from_env()?;

// Direct constructor
let client = PauboxClient::new("YOUR_API_KEY");

// Builder (custom timeout, base URL for testing)
let client = PauboxClient::builder()
    .api_key("YOUR_API_KEY")
    .timeout(Duration::from_secs(15))
    .build()?;

use paubox::Message;

let message = Message::builder()
    .from("sender@yourdomain.com")           // required
    .to(["alice@example.com"])               // required; accepts any iterable
    .subject("Your results are ready")       // required
    .text_content("Plain text body.")        // at least one of text/html required
    .html_content("<p>HTML body.</p>")       // optional
    .reply_to("support@yourdomain.com")      // optional
    .cc(["manager@example.com"])             // optional
    .bcc(["audit@example.com"])              // optional
    .allow_non_tls(false)                    // optional; default false
    .force_secure_notification(true)         // optional
    .build()?;

use paubox::Attachment;
use std::fs;

let data = fs::read("report.pdf")?;

let attachment = Attachment::from_bytes("report.pdf", "application/pdf", &data);

let attachment = Attachment::from_base64("report.pdf", "application/pdf", encoded_string);

let message = Message::builder()
    // ...other fields...
    .attachment(attachment)
    .build()?;

let response = client.send_message(&message).await?;
println!("Tracking ID: {}", response.source_tracking_id);

let disposition = client
    .get_email_disposition(&response.source_tracking_id)
    .await?;

for delivery in &disposition.message_deliveries {
    println!(
        "{} → {} (opened: {})",
        delivery.recipient,
        delivery.delivery_status,
        delivery.opened_status
    );
}

let response = client
    .schedule_message(&message, "2025-12-25T15:00:00Z")
    .await?;
println!("Tracking ID: {}", response.source_tracking_id);
println!("Scheduled for: {}", response.scheduled_at);

let status = client.get_scheduled_message("source-tracking-id").await?;
println!("State: {}", status.state);          // "pending", "sent", "cancelled"
println!("Scheduled for: {}", status.scheduled_at);

let response = client
    .reschedule_message("source-tracking-id", "2025-12-26T10:00:00Z")
    .await?;
println!("Rescheduled to: {}", response.scheduled_at);

let response = client
    .cancel_scheduled_message("source-tracking-id")
    .await?;
println!("Cancelled: {} (state: {})", response.source_tracking_id, response.state);

client.api_status().await?;

use paubox::PauboxError;

match client.send_message(&message).await {
    Ok(response) => println!("Sent: {}", response.source_tracking_id),
    Err(PauboxError::Auth(msg)) => eprintln!("Invalid credentials: {}", msg),
    Err(PauboxError::Http { status, body }) => {
        eprintln!("HTTP {}: {}", status, body);
    }
    Err(PauboxError::Validation(msg)) => eprintln!("Invalid message: {}", msg),
    Err(e) => eprintln!("Error: {}", e),
}