pix-efi

[dependencies]
pix-efi = "0.1"

use pix_efi::{EfiClient, EfiConfig};

let config = EfiConfig {
    client_id: "your_client_id".to_string(),
    client_secret: "your_client_secret".to_string(),
    certificate_path: "/path/to/cert.p12".to_string(),
    certificate_password: "".to_string(),
    sandbox: true,
};

let client = EfiClient::new(config)?;

// Authentication happens automatically on first API call
let balance = client.get_balance().await?;

use pix_provider::{ChargeRequest, Debtor};

let request = ChargeRequest {
    amount: "25.00".to_string(),
    pix_key: "+5511999999999".to_string(),
    description: Some("Order #123".to_string()),
    expiration: Some(3600),
    debtor: Some(Debtor {
        name: "João Silva".to_string(),
        document: "12345678901".to_string(),
    }),
    txid: None,
};

let charge = client.create_charge(request).await?;
println!("TxID: {}", charge.txid);
println!("Status: {}", charge.status);
println!("BR Code: {}", charge.brcode.unwrap_or_default());

let charge = client.get_charge("abc123def456").await?;
println!("Status: {}", charge.status);

use pix_provider::TransactionFilter;
use chrono::{Utc, Duration};

let filter = TransactionFilter {
    start: Some(Utc::now() - Duration::days(7)),
    end: Some(Utc::now()),
    page: None,
    per_page: None,
};

let charges = client.list_charges(filter).await?;
for charge in charges {
    println!("{}: R${} ({})", charge.txid, charge.amount, charge.status);
}

let filter = TransactionFilter {
    start: Some(Utc::now() - Duration::days(7)),
    end: Some(Utc::now()),
    page: None,
    per_page: None,
};

let transactions = client.list_pix(filter).await?;
for tx in transactions {
    println!("{}: R${}", tx.e2eid, tx.amount);
}

let tx = client.get_pix("E12345678901234567890123456").await?;
println!("Amount: R${}", tx.amount);
println!("Payer: {}", tx.payer_name.unwrap_or_default());

let balance = client.get_balance().await?;
println!("Available: R${}", balance.available);

// Register
client.register_webhook("+5511999999999", "https://example.com/webhook").await?;

// Get
let webhook = client.get_webhook("+5511999999999").await?;
println!("URL: {}", webhook.url);

// Remove
client.remove_webhook("+5511999999999").await?;

use pix_efi::EfiError;

match client.get_balance().await {
    Ok(balance) => println!("Balance: R${}", balance.available),
    Err(EfiError::Auth(msg)) => eprintln!("Authentication failed: {}", msg),
    Err(EfiError::Api { status, message }) => {
        eprintln!("API error ({}): {}", status, message);
    }
    Err(EfiError::Certificate(msg)) => eprintln!("Certificate error: {}", msg),
    Err(e) => eprintln!("Unexpected error: {}", e),
}