PHP SDK

use Laneful\Models\TrackingSettings;

// Create tracking settings
$tracking = new TrackingSettings(opens: true, clicks: true, unsubscribes: true);

$email = new Email(
    from: new Address('sender@example.com', 'Your Name'),
    to: [new Address('recipient@example.com', 'Recipient Name')],
    subject: 'HTML Email with Tracking',
    htmlContent: '<h1>Welcome!</h1><p>This is an <strong>HTML email</strong> with tracking enabled.</p>',
    textContent: 'Welcome! This is an HTML email with tracking enabled.',
    tracking: $tracking,
    tag: 'welcome-email'
);

$response = $client->sendEmail($email);

$email = new Email(
    from: new Address('sender@example.com'),
    to: [new Address('user@example.com')],
    subject: 'Welcome {{name}}!',
    templateId: 'welcome-template',
    templateData: [
        'name' => 'John Doe',
        'company' => 'Acme Corporation',
        'activation_link' => 'https://example.com/activate'
    ],
    tracking: new TrackingSettings(opens: true, clicks: true)
);

$response = $client->sendEmail($email);

use Laneful\Models\Attachment;

// Create attachment from file
$attachment = Attachment::fromFile('/path/to/document.pdf');

$email = new Email(
    from: new Address('sender@example.com'),
    to: [new Address('user@example.com')],
    subject: 'Document Attached',
    textContent: 'Please find the document attached.',
    attachments: [$attachment],
    tracking: new TrackingSettings(opens: true, clicks: true)
);

$response = $client->sendEmail($email);

$email = new Email(
    from: new Address('sender@example.com', 'Your Name'),
    to: [
        new Address('user1@example.com', 'User One'),
        new Address('user2@example.com', 'User Two')
    ],
    cc: [new Address('cc@example.com', 'CC Recipient')],
    bcc: [new Address('bcc@example.com', 'BCC Recipient')],
    replyTo: new Address('reply@example.com', 'Reply To'),
    subject: 'Email to Multiple Recipients',
    textContent: 'This email is being sent to multiple recipients.',
    tracking: new TrackingSettings(opens: true, clicks: true)
);

$response = $client->sendEmail($email);

// Schedule for 24 hours from now
$sendTime = time() + (24 * 60 * 60);

$email = new Email(
    from: new Address('sender@example.com'),
    to: [new Address('user@example.com')],
    subject: 'Scheduled Email',
    textContent: 'This email was scheduled.',
    sendTime: $sendTime,
    tracking: new TrackingSettings(opens: true, clicks: true)
);

$response = $client->sendEmail($email);

$emails = [
    new Email(
        from: new Address('sender@example.com'),
        to: [new Address('user1@example.com')],
        subject: 'Email 1',
        textContent: 'First email content.'
    ),
    new Email(
        from: new Address('sender@example.com'),
        to: [new Address('user2@example.com')],
        subject: 'Email 2',
        textContent: 'Second email content.'
    )
];

$response = $client->sendEmails($emails);

use Laneful\Webhooks\WebhookVerifier;

// Complete webhook handler implementation
class WebhookController {
    private string $webhookSecret;
    
    public function __construct(string $webhookSecret) {
        $this->webhookSecret = $webhookSecret;
    }
    
    public function handleWebhook(): void {
        try {
            // Extract signature from headers
            $signature = WebhookVerifier::extractSignatureFromHeaders($_SERVER);
            if (!$signature) {
                $this->respond(401, 'Missing signature');
                return;
            }
            
            // Get raw payload
            $payload = file_get_contents('php://input');
            
            // Verify signature
            if (!WebhookVerifier::verifySignature($this->webhookSecret, $payload, $signature)) {
                $this->respond(401, 'Invalid signature');
                return;
            }
            
            // Parse and validate payload
            $webhookData = WebhookVerifier::parseWebhookPayload($payload);
            
            // Process events
            foreach ($webhookData['events'] as $event) {
                $eventType = $event['event'];
                $email = $event['email'];
                
                switch ($eventType) {
                    case 'delivery':
                        error_log("Email delivered to: " . $email);
                        break;
                    case 'open':
                        error_log("Email opened by: " . $email);
                        break;
                    case 'click':
                        $url = $event['url'] ?? 'Unknown URL';
                        error_log("Link clicked by " . $email . ": " . $url);
                        break;
                    case 'bounce':
                        $isHard = $event['is_hard'] ?? false;
                        error_log("Email bounced (" . ($isHard ? "hard" : "soft") . ") for: " . $email);
                        break;
                }
            }
            
            $this->respond(200, 'Webhook processed successfully');
            
        } catch (\InvalidArgumentException $e) {
            $this->respond(400, 'Invalid payload: ' . $e->getMessage());
        } catch (Exception $e) {
            $this->respond(500, 'Processing error: ' . $e->getMessage());
        }
    }
    
    private function respond(int $status, string $message): void {
        http_response_code($status);
        header('Content-Type: application/json');
        echo json_encode(['status' => $status, 'message' => $message]);
    }
}

use Laneful\Webhooks\WebhookVerifier;

// In your webhook handler
$payload = file_get_contents('php://input'); // Get the raw request body
$signature = WebhookVerifier::extractSignatureFromHeaders($_SERVER);
$secret = 'your-webhook-secret';

if ($signature && WebhookVerifier::verifySignature($secret, $payload, $signature)) {
    // Process webhook data
    $webhookData = WebhookVerifier::parseWebhookPayload($payload);
    // Handle webhook events
} else {
    // Invalid signature
    http_response_code(401);
    echo "Invalid webhook signature";
}

use Laneful\Webhooks\WebhookVerifier;

// Complete webhook verification and processing workflow
try {
    // Step 1: Get raw payload
    $payload = file_get_contents('php://input');
    
    // Step 2: Extract signature from headers (supports multiple formats)
    $signature = WebhookVerifier::extractSignatureFromHeaders($_SERVER);
    
    // Step 3: Verify signature (supports sha256= prefix)
    if (!$signature || !WebhookVerifier::verifySignature($webhookSecret, $payload, $signature)) {
        throw new SecurityException("Invalid webhook signature");
    }
    
    // Step 4: Parse and validate payload structure
    $webhookData = WebhookVerifier::parseWebhookPayload($payload);
    
    // Step 5: Process events (handles both batch and single event formats)
    foreach ($webhookData['events'] as $event) {
        $eventType = $event['event'];
        $email = $event['email'];
        
        switch ($eventType) {
            case 'delivery':
                handleDeliveryEvent($event);
                break;
            case 'open':
                handleOpenEvent($event);
                break;
            case 'click':
                handleClickEvent($event);
                break;
            case 'bounce':
                handleBounceEvent($event);
                break;
            case 'drop':
                handleDropEvent($event);
                break;
            case 'spam_complaint':
                handleSpamComplaintEvent($event);
                break;
            case 'unsubscribe':
                handleUnsubscribeEvent($event);
                break;
        }
    }
    
} catch (\InvalidArgumentException $e) {
    // Payload validation error
    http_response_code(400);
    echo "Invalid payload: " . $e->getMessage();
} catch (Exception $e) {
    // Other errors
    http_response_code(401);
    echo "Processing error: " . $e->getMessage();
}

$webhookData = WebhookVerifier::parseWebhookPayload($payload);

if ($webhookData['is_batch']) {
    // Processing multiple events in batch mode
    echo "Processing " . count($webhookData['events']) . " events in batch";
} else {
    // Processing single event
    echo "Processing single event";
}

// Process all events
foreach ($webhookData['events'] as $event) {
    processEvent($event);
}