import { EmailMate } from 'emailmate';

const emailmate = new EmailMate('em_xxxxxxxxxxxx');

await emailmate.emails.send({
  from: 'you@yourapp.com',
  to: 'user@example.com',
  subject: 'Welcome',
  html: '<h1>Welcome aboard!</h1>'
});

// Before
import { Resend } from 'resend';

// After
import { Resend } from 'emailmate';

// Your code? Untouched. Same API. Same types. Same everything.
const resend = new Resend('em_xxxxxxxxxxxx');
await resend.emails.send({ ... });

import { EmailMate } from 'emailmate';

// Default (emailmate.dev cloud)
const em = new EmailMate('em_xxxxxxxxxxxx');

// Self-hosted / BYOS (Bring Your Own SES)
const em = new EmailMate('em_xxxxxxxxxxxx', {
  baseUrl: 'https://your-instance.com'
});

const { id } = await em.emails.send({
  from: 'Acme <hello@acme.com>',
  to: 'user@example.com',
  subject: 'Welcome to Acme',
  html: '<h1>Welcome!</h1><p>Thanks for signing up.</p>'
});

import { WelcomeEmail } from './emails/welcome';

await em.emails.send({
  from: 'Acme <hello@acme.com>',
  to: 'user@example.com',
  subject: 'Welcome',
  react: <WelcomeEmail name="John" />
});

await em.emails.send({
  from: 'billing@acme.com',
  to: 'user@example.com',
  subject: 'Your invoice',
  html: '<p>Invoice attached.</p>',
  attachments: [{
    filename: 'invoice.pdf',
    content: Buffer.from(pdfBytes),
    content_type: 'application/pdf'
  }]
});

await em.emails.send({
  from: 'hello@acme.com',
  to: 'user@example.com',
  subject: 'Welcome',
  html: '<p>Welcome!</p>',
  tags: [
    { name: 'category', value: 'onboarding' },
    { name: 'app', value: 'acme' }
  ]
});

await em.emails.send({
  from: 'hello@acme.com',
  to: 'user@example.com',
  subject: 'Reminder',
  html: '<p>Don\'t forget!</p>',
  scheduled_at: '2025-04-01T10:00:00Z'
});

const email = await em.emails.get('em_xxxx');
// { id, object, to, from, subject, html, text, created_at, last_event }

const { id, canceled } = await em.emails.cancel('em_xxxx');

const { data } = await em.emails.batch([
  { from, to: 'a@x.com', subject: 'Hi',    html: '<p>Hi</p>' },
  { from, to: 'b@x.com', subject: 'Hello', html: '<p>Hello</p>' },
]);
// data: [{ id: 'em_...' }, { id: 'em_...' }]

const page = await em.emails.list({ limit: 50, after: 'em_cursor' });
// { object: 'list', data: Email[], has_more: boolean, next_cursor?: string }

const domain = await em.domains.create({ name: 'acme.com' });
// { id, name, status: "pending", records: [...] }

const { data } = await em.domains.list();
// data: Domain[]

const domain = await em.domains.get('dom_xxxx');

const domain = await em.domains.verify('dom_xxxx');

await em.domains.delete('dom_xxxx');

const audience = await em.audiences.create({ name: 'Newsletter' });
// { id, name, created_at }

const { data } = await em.audiences.list();

const audience = await em.audiences.get('aud_xxxx');

await em.audiences.delete('aud_xxxx');

const contact = await em.contacts.create('aud_xxxx', {
  email: 'user@example.com',
  first_name: 'Jane',
  last_name: 'Doe',
  unsubscribed: false
});

const { data } = await em.contacts.list('aud_xxxx');

const contact = await em.contacts.get('aud_xxxx', 'con_xxxx');

await em.contacts.update('aud_xxxx', 'con_xxxx', {
  first_name: 'Janet',
  unsubscribed: true
});

await em.contacts.delete('aud_xxxx', 'con_xxxx');

const { id, token } = await em.apiKeys.create({
  name: 'Production',
  permission: 'full_access' // or 'sending_access'
});
// token is only shown once — store it securely

const { data } = await em.apiKeys.list();

await em.apiKeys.delete('key_xxxx');

const t = await em.templates.create({
  name: 'Welcome',
  slug: 'welcome-v1',
  html: '<h1>Welcome {{ name }}</h1>',
  variables: ['name'],
});
await em.templates.list();
await em.templates.get(t.id);
await em.templates.update(t.id, { html: '<h1>Hi {{ name }}</h1>' });
await em.templates.delete(t.id);

const w = await em.webhooks.create({
  url: 'https://api.acme.com/email-webhook',
  events: ['email.delivered', 'email.bounced', 'email.opened'],
});
await em.webhooks.list();
await em.webhooks.test(w.id); // trigger a sample event
await em.webhooks.update(w.id, { status: 'disabled' });
await em.webhooks.delete(w.id);

const b = await em.broadcasts.create({
  audience_id: 'aud_xxxx',
  from: 'Acme <hello@acme.com>',
  subject: 'New release',
  html: '<p>It ships Monday.</p>',
});
await em.broadcasts.send(b.id, { scheduled_at: '2026-05-01T14:00:00Z' });
await em.broadcasts.cancel(b.id);

const em = new EmailMate('em_xxxx', {
  maxRetries: 3,               // default: 3
  retryBackoff: 'exponential', // 'exponential' | 'linear', default: 'exponential'
  timeout: 30_000,             // per-request ms, default: 30_000
  onRetry: (attempt, error) => console.warn('retry', attempt, error),
  onError: (error)            => console.error('final', error),
  onResponse: (res)           => console.log(res.status),
});

const controller = new AbortController();
const p = em.emails.send(payload, { signal: controller.signal });
controller.abort();

import { wrap, btn, p, greeting, center, hint, htmlToText } from 'emailmate';

const html = wrap(
  greeting('Jane') +
  p('Thanks for signing up. Your account is ready.') +
  center(btn('https://acme.com/dashboard', 'Go to Dashboard')) +
  hint('If you didn\'t create this account, ignore this email.'),
  { brand: 'Acme', tagline: 'Ship faster', url: 'https://acme.com', domain: 'acme.com' }
);

// Auto-generate plain text from HTML
const text = htmlToText(html);

await em.emails.send({ from, to, subject, html, text });

import { renderTemplate } from 'emailmate/templates';
import { EmailMate } from 'emailmate';

const em = new EmailMate(process.env.EMAILMATE_API_KEY!);

const { html, text } = await renderTemplate('welcome', {
  appKey: 'bookstand',
  userName: 'Jimmy',
});

await em.emails.send({
  from: 'BookStand <hello@bookstand.app>',
  to: 'user@example.com',
  subject: 'Welcome to BookStand',
  html,
  text,
});

// convex/email/acme.ts
import { createConvexEmailSender } from 'emailmate/convex';

export const sendAcmeEmail = createConvexEmailSender({
  apiKey: process.env.EMAILMATE_API_KEY!,
  defaultFrom: 'Acme <hello@acme.com>',
  defaultReplyTo: 'support@acme.com',
  defaultTags: [{ name: 'app', value: 'acme' }],
});

// convex/auth.ts
import { internalAction } from './_generated/server';
import { v } from 'convex/values';
import { sendAcmeEmail } from './email/acme';

export const sendWelcome = internalAction({
  args: { email: v.string(), name: v.string() },
  handler: async (_ctx, { email, name }) => {
    await sendAcmeEmail({
      to: email,
      subject: `Welcome, ${name}!`,
      html: `<h1>Welcome!</h1><p>Hey ${name}, your account is ready.</p>`,
    });
  },
});

import { sendViaEmailMate } from 'emailmate/convex';

await sendViaEmailMate({
  apiKey: process.env.EMAILMATE_API_KEY!,
  from: 'Acme <hello@acme.com>',
  to: 'user@example.com',
  subject: 'Hi',
  html: '<p>Hi</p>',
});

ctx.scheduler.runAfter(0, internal.emails.sendWelcome, { email, name });

try {
  await em.emails.send({ ... });
} catch (error) {
  // { code: 'validation_error', message: 'Missing required field: to' }
  console.error(error.code, error.message);
}

import type {
  SendEmailOptions,
  SendEmailResponse,
  Email,
  Domain,
  DnsRecord,
  Audience,
  Contact,
  ApiKey,
  Attachment,
  Tag,
  EmailMateConfig,
  EmailMateError,
} from 'emailmate';