import { EmailSender, quickSendEmail } from 'email-deliverability-tester';

// Auto-detects configuration from environment variables
const result = await quickSendEmail({
  to: 'recipient@example.com',
  subject: 'Hello World',
  text: 'This email was sent with auto-detected configuration!'
});

console.log(`Email sent: ${result.success}`);

import { quickEmailValidation } from 'email-deliverability-tester';

// Quick email validation (no actual delivery test)
const result = await quickEmailValidation('user@example.com');
console.log(`Email is ${result.isValid ? 'valid' : 'invalid'}`);
console.log(`Domain exists: ${result.domainExists}`);
console.log(`MX records found: ${result.mxRecords.length}`);

import { EmailSender, EmailDeliverabilityTester } from 'email-deliverability-tester';

// Manual AWS SES configuration
const sender = new EmailSender({
  aws: {
    accessKeyId: 'your-aws-access-key',
    secretAccessKey: 'your-aws-secret-key',
    region: 'us-east-1'
  },
  defaultFrom: 'your-from-email@domain.com'
});

const result = await sender.sendWithSes({
  to: 'recipient@example.com',
  subject: 'Manual Configuration Test',
  text: 'This email was sent with manual configuration.'
});

import { EmailDeliverabilityTester } from 'email-deliverability-tester';

const tester = new EmailDeliverabilityTester({
  accessKeyId: 'your-aws-access-key',
  secretAccessKey: 'your-aws-secret-key',
  region: 'us-east-1'
}, 'your-from-email@domain.com');

const result = await tester.testEmailDeliverability({
  email: 'recipient@example.com',
  provider: 'aws-ses',
  skipActualDelivery: false // Set to true to skip sending actual email
});

console.log(`Delivery test: ${result.deliverabilityTests.awsSes?.success}`);

import { quickEmailTestWithSmtp } from 'email-deliverability-tester';

const smtpConfig = {
  host: 'smtp.gmail.com',
  port: 587,
  secure: false,
  auth: {
    user: 'your-email@gmail.com',
    pass: 'your-app-password'
  }
};

const result = await quickEmailTestWithSmtp('recipient@example.com', smtpConfig);
console.log(`SMTP test: ${result.deliverabilityTests.smtp?.success}`);

import { EmailSender, quickSendEmail } from 'email-deliverability-tester';

// Simple email sending - auto-detects provider
const result = await quickSendEmail({
  to: 'recipient@example.com',
  subject: 'Auto-detected Configuration',
  text: 'This email uses auto-detected SMTP or AWS SES configuration!'
});

// Advanced email with attachments
const sender = new EmailSender(); // Auto-detects from env vars
const advancedResult = await sender.send({
  to: ['user1@example.com', 'user2@example.com'],
  cc: 'manager@example.com',
  subject: 'Monthly Report',
  html: '<h1>Report</h1><p>Please find the monthly report attached.</p>',
  attachments: [
    {
      filename: 'report.pdf',
      content: reportBuffer,
      contentType: 'application/pdf'
    }
  ]
});

import { batchEmailValidation } from 'email-deliverability-tester';

const emails = ['user1@example.com', 'user2@gmail.com', 'invalid-email'];
const result = await batchEmailValidation(emails);

console.log(`Valid emails: ${result.validEmails.length}`);
console.log(`Invalid emails: ${result.invalidEmails.length}`);

new EmailDeliverabilityTester(awsConfig?, fromEmail?)

interface EmailTestConfig {
  email: string;
  provider?: 'aws-ses' | 'smtp' | 'both';
  smtpConfig?: SmtpConfig;
  testMessage?: TestMessage;
  skipActualDelivery?: boolean;
}

interface EmailTestResult {
  email: string;
  isValid: boolean;
  domainExists: boolean;
  mxRecords: MxRecord[];
  spfRecord?: string;
  dmarcRecord?: string;
  deliverabilityTests: DeliveryTestResults;
  recommendations: string[];
  testDuration?: number;
}

interface SmtpConfig {
  host: string;
  port: number;
  secure: boolean;
  auth?: {
    user: string;
    pass: string;
  };
}

import { EmailDeliverabilityTester } from 'email-deliverability-tester';

class EnhancedEmailService {
  private tester: EmailDeliverabilityTester;

  constructor() {
    this.tester = new EmailDeliverabilityTester();
  }

  async sendWithValidation(email: string, content: any) {
    // Pre-validate email
    const validation = await this.tester.testEmailDeliverability({
      email,
      skipActualDelivery: true
    });

    if (!validation.isValid || !validation.domainExists) {
      throw new Error(`Invalid email: ${validation.recommendations.join(', ')}`);
    }

    // Proceed with sending email
    return this.sendEmail(email, content);
  }

  private async sendEmail(email: string, content: any) {
    // Your email sending logic here
    console.log(`Sending email to ${email}`);
  }
}

import { EmailDeliverabilityTester } from 'email-deliverability-tester';

async function validateEmailList(emails: string[]) {
  const tester = new EmailDeliverabilityTester();
  
  console.log(`Validating ${emails.length} emails...`);
  
  const result = await tester.validateEmails(emails);
  
  console.log(`✅ Valid: ${result.validEmails.length}`);
  console.log(`❌ Invalid: ${result.invalidEmails.length}`);
  
  // Log details for invalid emails
  result.invalidEmails.forEach(item => {
    console.log(`❌ ${item.email}: ${item.issues.join(', ')}`);
  });
  
  return result.validEmails;
}