@flusys/ng-email 1.0.0-rc

package/README.md

@@ -0,0 +1,872 @@
+# Email Package Guide
+
+> **Package:** `@flusys/ng-email`
+> **Type:** Email management with configurations, templates, and sending
+
+---
+
+## Overview
+
+`@flusys/ng-email` provides complete email management:
+
+- **Email Configurations** - CRUD for SMTP, SendGrid, Mailgun providers
+- **Email Templates** - Visual template management with variable interpolation
+- **HTML/Plain Text** - Toggle between content types with live preview
+- **Test Sending** - Test configurations and templates with dynamic variables
+- **Company Scoping** - Automatic company-scoped queries (when enabled)
+- **Lazy Loading** - All page components are lazy-loaded via routes
+- **Responsive Design** - Mobile-first with horizontal scroll tables
+- **Dark Mode** - Full dark/light mode support
+
+### Package Hierarchy
+
+```
+@flusys/ng-core           <- Foundation (APP_CONFIG, DEFAULT_APP_NAME)
+        |
+@flusys/ng-shared         <- Shared utilities (ApiResourceService, IBaseEntity)
+        |
+@flusys/ng-layout         <- Layout (LAYOUT_AUTH_STATE for company context)
+        |
+@flusys/ng-email          <- Email management (THIS PACKAGE)
+```
+
+### Company Context
+
+Email components use `LAYOUT_AUTH_STATE` from `@flusys/ng-layout` for company context. This follows the Provider Interface Pattern - ng-email depends on ng-layout's abstraction, not ng-auth directly.
+
+```typescript
+import { LAYOUT_AUTH_STATE } from '@flusys/ng-layout';
+import { APP_CONFIG, DEFAULT_APP_NAME } from '@flusys/ng-core';
+
+// Optional injection - works with or without company feature
+private readonly companyContext = inject(LAYOUT_AUTH_STATE, { optional: true });
+
+readonly showCompanyInfo = computed(
+  () => this.appConfig.enableCompanyFeature && !!this.companyContext,
+);
+
+readonly currentCompanyName = computed(
+  () => this.companyContext?.currentCompanyInfo()?.name ?? DEFAULT_APP_NAME,
+);
+```
+
+---
+
+## Package Architecture
+
+```
+ng-email/
+├── enums/
+│   ├── email-provider.enum.ts       # EmailProviderEnum (smtp, sendgrid, mailgun)
+│   ├── email-block-type.enum.ts     # EmailBlockType (text, image, button, etc.)
+│   └── public-api.ts
+├── interfaces/
+│   ├── email-config.interface.ts    # IEmailConfig, ICreateEmailConfigDto
+│   ├── email-template.interface.ts  # IEmailTemplate, ICreateEmailTemplateDto
+│   ├── email-schema.interface.ts    # IEmailSchema, IEmailSection, IEmailBlock
+│   ├── email-send.interface.ts      # ISendEmailDto, ISendTemplateEmailDto
+│   └── public-api.ts
+├── services/
+│   ├── email-config-api.service.ts  # Config CRUD + test sending
+│   ├── email-template-api.service.ts # Template CRUD + getBySlug
+│   ├── email-send.service.ts        # Email sending operations
+│   ├── email-builder-state.service.ts # Template builder state management
+│   └── public-api.ts
+├── pages/
+│   ├── email-container/
+│   │   └── email-container.component.ts  # Main container with tabs
+│   ├── config/
+│   │   ├── email-config-list.component.ts
+│   │   └── email-config-form.component.ts
+│   └── template/
+│       ├── template-list.component.ts
+│       └── template-form.component.ts
+├── routes/
+│   └── email.routes.ts
+└── public-api.ts
+```
+
+---
+
+## Route Integration
+
+### Adding Email Routes
+
+```typescript
+// app.routes.ts
+import { EMAIL_ROUTES } from '@flusys/ng-email';
+
+export const routes: Routes = [
+  {
+    path: 'email',
+    children: EMAIL_ROUTES,
+  },
+];
+```
+
+### Route Structure
+
+| Path | Component | Description |
+|------|-----------|-------------|
+| `/email` | EmailContainerComponent | Main container with tab navigation |
+| `/email/templates` | TemplateListComponent | List email templates |
+| `/email/templates/new` | TemplateFormComponent | Create new template |
+| `/email/templates/:id` | TemplateFormComponent | Edit template |
+| `/email/configs` | EmailConfigListComponent | List email configurations |
+| `/email/configs/new` | EmailConfigFormComponent | Create new config |
+| `/email/configs/:id` | EmailConfigFormComponent | Edit config |
+
+---
+
+## Enums
+
+### EmailProviderEnum
+
+```typescript
+export enum EmailProviderEnum {
+  SMTP = 'smtp',
+  SENDGRID = 'sendgrid',
+  MAILGUN = 'mailgun',
+}
+```
+
+### EmailBlockType
+
+```typescript
+export enum EmailBlockType {
+  TEXT = 'text',
+  IMAGE = 'image',
+  BUTTON = 'button',
+  DIVIDER = 'divider',
+  HTML = 'html',
+}
+```
+
+---
+
+## Interfaces
+
+### Email Configuration
+
+```typescript
+interface IEmailConfig extends IBaseEntity {
+  name: string;
+  provider: EmailProviderEnum;
+  config: Record<string, any>;    // Provider-specific config
+  fromEmail: string | null;
+  fromName: string | null;
+  isActive: boolean;
+  isDefault: boolean;             // Set as default configuration
+  companyId?: string | null;
+}
+
+interface ICreateEmailConfigDto {
+  name: string;
+  provider: EmailProviderEnum;
+  config: Record<string, any>;
+  fromEmail?: string;
+  fromName?: string;
+  isActive?: boolean;
+  isDefault?: boolean;
+}
+
+interface IUpdateEmailConfigDto extends Partial<ICreateEmailConfigDto> {
+  id: string;
+}
+```
+
+### Provider-Specific Configs
+
+```typescript
+// SMTP
+interface ISmtpConfig {
+  host: string;
+  port: number;
+  secure?: boolean;
+  username: string;
+  password: string;
+}
+
+// SendGrid
+interface ISendGridConfig {
+  apiKey: string;
+}
+
+// Mailgun
+interface IMailgunConfig {
+  apiKey: string;
+  domain: string;
+  region?: 'us' | 'eu';
+}
+```
+
+### Email Template
+
+```typescript
+interface IEmailTemplate extends IBaseEntity {
+  name: string;
+  slug: string;
+  description: string | null;
+  subject: string;
+  schema: IEmailSchema;
+  htmlContent: string;
+  textContent: string | null;
+  schemaVersion: number;
+  isActive: boolean;
+  isHtml: boolean;                 // true=HTML mode, false=plain text
+  metadata: Record<string, unknown> | null;
+  companyId?: string | null;
+}
+
+interface ICreateEmailTemplateDto {
+  name: string;
+  slug: string;
+  description?: string;
+  subject: string;
+  schema: IEmailSchema;
+  htmlContent: string;
+  textContent?: string;
+  isActive?: boolean;
+  isHtml?: boolean;
+  metadata?: Record<string, unknown>;
+}
+
+interface IUpdateEmailTemplateDto extends Partial<ICreateEmailTemplateDto> {
+  id: string;
+}
+```
+
+### Email Schema
+
+```typescript
+interface IEmailSchema {
+  id: string;
+  version: string;
+  name: string;
+  subject: string;
+  preheader?: string;
+  sections: IEmailSection[];
+  variables?: IEmailTemplateVariable[];
+  settings?: IEmailSettings;
+}
+
+interface IEmailSection {
+  id: string;
+  type: 'header' | 'body' | 'footer';
+  name: string;
+  blocks: IEmailBlock[];
+  order: number;
+  style?: IEmailSectionStyle;
+}
+
+interface IEmailBlock {
+  id: string;
+  type: EmailBlockType;
+  order: number;
+  content: ITextBlockContent | IImageBlockContent | IButtonBlockContent | IDividerBlockContent | IHtmlBlockContent;
+  style?: IEmailBlockStyle;
+}
+
+interface IEmailTemplateVariable {
+  name: string;
+  type: 'string' | 'number' | 'boolean' | 'date';
+  required?: boolean;
+  defaultValue?: string;
+  description?: string;
+}
+```
+
+### Email Sending
+
+```typescript
+// Test send result
+interface ITestSendResult {
+  success: boolean;
+  messageId?: string;
+  error?: string;
+}
+
+// Direct email
+interface ISendEmailDto {
+  to: string | string[];
+  cc?: string | string[];
+  bcc?: string | string[];
+  subject: string;
+  html: string;
+  text?: string;
+  from?: string;
+  fromName?: string;
+  replyTo?: string;
+  emailConfigId?: string;
+}
+
+// Template email
+interface ISendTemplateEmailDto {
+  templateId?: string;
+  templateSlug?: string;
+  to: string | string[];
+  cc?: string | string[];
+  bcc?: string | string[];
+  variables?: Record<string, any>;
+  from?: string;
+  fromName?: string;
+  replyTo?: string;
+  emailConfigId?: string;
+}
+```
+
+---
+
+## Services
+
+All services are `providedIn: 'root'`. Company scoping is automatic when the company feature is enabled.
+
+### EmailConfigApiService
+
+Email configuration CRUD. Extends `ApiResourceService<IUpdateEmailConfigDto, IEmailConfig>`.
+
+```typescript
+@Injectable({ providedIn: 'root' })
+export class EmailConfigApiService extends ApiResourceService<
+  IUpdateEmailConfigDto,
+  IEmailConfig
+> {
+  constructor() {
+    const http = inject(HttpClient);
+    super('email/email-config', http);
+  }
+
+  /** Send test email to verify configuration */
+  sendTest(configId: string, recipient: string): Observable<ISingleResponse<ITestSendResult>> {
+    return this.http.post<ISingleResponse<ITestSendResult>>(
+      `${this.baseUrl.replace('/email-config', '')}/send/test`,
+      { emailConfigId: configId, recipient },
+    );
+  }
+}
+```
+
+### EmailTemplateApiService
+
+Email template CRUD. Extends `ApiResourceService<IUpdateEmailTemplateDto, IEmailTemplate>`.
+
+```typescript
+@Injectable({ providedIn: 'root' })
+export class EmailTemplateApiService extends ApiResourceService<
+  IUpdateEmailTemplateDto,
+  IEmailTemplate
+> {
+  constructor() {
+    const http = inject(HttpClient);
+    super('email/email-template', http);
+  }
+
+  /** Get template by slug (POST-only RPC pattern) */
+  getBySlug(slug: string): Observable<ISingleResponse<IEmailTemplate | null>> {
+    return this.http.post<ISingleResponse<IEmailTemplate | null>>(
+      `${this.baseUrl}/get-by-slug`,
+      { slug },
+    );
+  }
+}
+```
+
+### EmailSendService
+
+Handles email sending operations.
+
+```typescript
+@Injectable({ providedIn: 'root' })
+export class EmailSendService {
+  private readonly http = inject(HttpClient);
+  private readonly baseUrl = `${inject(APP_CONFIG).apiBaseUrl}/email/send`;
+
+  /** Send email directly (without template) */
+  sendDirect(dto: ISendEmailDto): Observable<ISingleResponse<ITestSendResult>>;
+
+  /** Send email using template */
+  sendTemplate(dto: ISendTemplateEmailDto): Observable<ISingleResponse<ITestSendResult>>;
+}
+```
+
+### EmailBuilderStateService
+
+Manages email builder UI state. Should be provided at component level, not root.
+
+```typescript
+@Injectable()
+export class EmailBuilderStateService {
+  // Schema state
+  readonly schema: Signal<IEmailSchema>;
+  readonly isDirty: Signal<boolean>;
+
+  // Selection state
+  readonly selectedSectionId: Signal<string | null>;
+  readonly selectedBlockId: Signal<string | null>;
+
+  // Computed signals
+  readonly sections: Signal<IEmailSection[]>;
+  readonly headerSection: Signal<IEmailSection | null>;
+  readonly bodySection: Signal<IEmailSection | null>;
+  readonly footerSection: Signal<IEmailSection | null>;
+
+  // Methods
+  loadSchema(schema: IEmailSchema): void;
+  createNewSchema(name?: string): void;
+  addBlock(sectionId: string, blockType: EmailBlockType): string | null;
+  updateBlock(sectionId: string, blockId: string, updates: Partial<IEmailBlock>): void;
+  deleteBlock(sectionId: string, blockId: string): void;
+}
+```
+
+---
+
+## Components
+
+All components are standalone, use Angular 21 signals, OnPush change detection, and lazy-load via routes.
+
+### EmailContainerComponent
+
+Main container with tab navigation between Templates and Configurations.
+
+**Features:**
+- Responsive page title (`text-xl sm:text-2xl`)
+- Tab navigation with horizontal scroll on mobile
+- Router outlet for child routes
+
+```html
+<div class="p-2 sm:p-4">
+  <h1 class="text-xl sm:text-2xl font-bold m-0">Email</h1>
+  <p class="text-sm text-muted-color mt-1">Manage email templates...</p>
+
+  <div class="scrollbar-hide flex gap-1 mb-4 border-b border-surface overflow-x-auto">
+    @for (tab of tabs; track tab.id) {
+      <a [routerLink]="tab.route" routerLinkActive="tab-active">...</a>
+    }
+  </div>
+
+  <router-outlet />
+</div>
+```
+
+### EmailConfigListComponent
+
+Lists email configurations with actions.
+
+**Features:**
+- Lazy pagination via `p-table` with `[paginator]="totalRecords() > 0"`
+- Horizontal scroll on mobile (`overflow-x-auto -mx-4 sm:mx-0`)
+- Provider type tags (SMTP, SendGrid, Mailgun)
+- Active/Inactive status badges
+- Default configuration badge
+- Test button with dialog for recipient input
+- Edit and delete actions
+- Company info display when enabled
+
+**Test Dialog:**
+
+```typescript
+showTestDialog = false;  // Plain property for ngModel
+readonly selectedConfig = signal<IEmailConfig | null>(null);
+readonly isSendingTest = signal(false);
+testRecipient = '';
+
+onTest(config: IEmailConfig): void {
+  this.selectedConfig.set(config);
+  this.testRecipient = '';
+  this.showTestDialog = true;
+}
+
+async sendTestEmail(): Promise<void> {
+  const config = this.selectedConfig();
+  if (!config || !this.testRecipient) return;
+
+  const response = await firstValueFrom(
+    this.configService.sendTest(config.id, this.testRecipient)
+  );
+
+  if (response.data?.success) {
+    this.messageService.add({
+      severity: 'success',
+      summary: 'Success',
+      detail: `Test email sent! Message ID: ${response.data.messageId}`,
+    });
+    this.showTestDialog = false;
+  }
+}
+```
+
+### EmailConfigFormComponent
+
+Create/edit email configuration with dynamic provider fields.
+
+**Features:**
+- Responsive grid layout (`grid-cols-1 md:grid-cols-2`)
+- Dynamic form fields based on selected provider
+- SMTP: host, port, secure toggle, username, password
+- SendGrid: apiKey (masked input)
+- Mailgun: apiKey, domain, region
+- Active toggle and Set as Default toggle
+- Form actions right-aligned at bottom
+- Create/Edit mode auto-detection
+
+### TemplateListComponent
+
+Lists email templates with test send functionality.
+
+**Features:**
+- Lazy pagination with conditional display
+- Responsive table with hidden columns on mobile
+- HTML/Text type badges (based on `isHtml`)
+- Active/Inactive status badges
+- Test send with dynamic variables
+- Edit and delete actions
+
+**Test Send Dialog with Variables:**
+
+```typescript
+/** Extract variables from template content */
+readonly templateVariables = computed(() => {
+  const template = this.selectedTemplate();
+  if (!template) return [];
+
+  const content = [
+    template.subject,
+    template.htmlContent,
+    template.textContent || '',
+  ].join(' ');
+
+  const matches = content.matchAll(/\{\{(\w+)\}\}/g);
+  const variables = new Set<string>();
+
+  for (const match of matches) {
+    variables.add(match[1]);
+  }
+
+  return Array.from(variables).sort();
+});
+
+variableValues: Record<string, string> = {};
+```
+
+### TemplateFormComponent
+
+Create/edit email template with HTML/Plain Text toggle and live preview.
+
+**Features:**
+- Responsive form grid (`grid-cols-1 md:grid-cols-2`)
+- Name, slug, subject, description fields
+- Subject line with variable support hint
+- Editor Mode Toggle (HTML/Plain Text buttons)
+- Same height content editor and preview (`h-[400px]`)
+- Horizontal scroll for code (`wrap="off"`)
+- Live HTML preview in iframe with white background
+- Content sync between modes when switching
+- Active toggle
+- Form actions right-aligned at bottom
+
+**Preview with Light Background:**
+
+```typescript
+getPreviewHtml(): string {
+  const baseStyles = `
+    <style>
+      body {
+        font-family: Arial, sans-serif;
+        margin: 16px;
+        background-color: #ffffff;
+        color: #333333;
+      }
+      img { max-width: 100%; height: auto; }
+    </style>
+  `;
+  return baseStyles + (this.formModel.htmlContent || '');
+}
+```
+
+---
+
+## Responsive Design Patterns
+
+### Tables
+
+```html
+<!-- Horizontal scroll wrapper -->
+<div class="overflow-x-auto -mx-4 sm:mx-0">
+  <p-table
+    [paginator]="totalRecords() > 0"
+    styleClass="p-datatable-sm"
+    [tableStyle]="{ 'min-width': '50rem' }"
+  >
+    <!-- Hidden columns on smaller screens -->
+    <th class="hidden md:table-cell">Slug</th>
+    <th class="hidden lg:table-cell">Subject</th>
+    <th class="hidden xl:table-cell">Created</th>
+  </p-table>
+</div>
+```
+
+### Forms
+
+```html
+<!-- Responsive grid -->
+<div class="grid grid-cols-1 md:grid-cols-2 gap-4">
+  <div class="field">...</div>
+  <div class="field md:col-span-2">...</div>  <!-- Full width on all screens -->
+</div>
+
+<!-- Form actions -->
+<div class="flex justify-end gap-2 mt-6 pt-4 border-t border-surface">
+  <p-button label="Cancel" severity="secondary" [outlined]="true" routerLink="../" />
+  <p-button [label]="isEditMode() ? 'Update' : 'Create'" icon="pi pi-save" />
+</div>
+```
+
+### Headers
+
+```html
+<div class="flex flex-col sm:flex-row justify-between items-start sm:items-center gap-3 mb-4">
+  <div>
+    <h3 class="text-lg sm:text-xl font-semibold m-0">Title</h3>
+    @if (showCompanyInfo()) {
+      <p class="text-sm text-muted-color mt-1">Company: {{ currentCompanyName() }}</p>
+    }
+  </div>
+  <p-button label="Action" styleClass="w-full sm:w-auto" />
+</div>
+```
+
+---
+
+## Dark Mode Support
+
+All components use PrimeNG/Tailwind dark mode classes:
+
+| Element | Classes |
+|---------|---------|
+| Borders | `border-surface` |
+| Text | `text-muted-color` |
+| Backgrounds | `bg-surface-0 dark:bg-surface-900`, `bg-surface-100 dark:bg-surface-700` |
+| Code blocks | `bg-surface-100 dark:bg-surface-700` |
+| Hover states | `hover:bg-surface-hover` |
+
+---
+
+## Usage Examples
+
+### Send Direct Email
+
+```typescript
+import { EmailSendService } from '@flusys/ng-email';
+
+private readonly emailSendService = inject(EmailSendService);
+
+async sendEmail(): Promise<void> {
+  const response = await firstValueFrom(
+    this.emailSendService.sendDirect({
+      to: 'user@example.com',
+      subject: 'Hello!',
+      html: '<h1>Hello World</h1>',
+      text: 'Hello World',
+      emailConfigId: 'config-id',
+    })
+  );
+
+  if (response.data?.success) {
+    console.log('Sent! Message ID:', response.data.messageId);
+  }
+}
+```
+
+### Send Template Email
+
+```typescript
+async sendTemplateEmail(): Promise<void> {
+  const response = await firstValueFrom(
+    this.emailSendService.sendTemplate({
+      templateId: 'template-id',
+      to: 'user@example.com',
+      emailConfigId: 'config-id',
+      variables: {
+        userName: 'John',
+        appName: 'My App',
+        verificationLink: 'https://example.com/verify/abc123',
+      },
+    })
+  );
+
+  if (response.data?.success) {
+    console.log('Sent! Message ID:', response.data.messageId);
+  }
+}
+```
+
+### Test Configuration
+
+```typescript
+import { EmailConfigApiService } from '@flusys/ng-email';
+
+private readonly configService = inject(EmailConfigApiService);
+
+async testConfig(configId: string, recipient: string): Promise<boolean> {
+  const response = await firstValueFrom(
+    this.configService.sendTest(configId, recipient)
+  );
+
+  return response.data?.success ?? false;
+}
+```
+
+### Get Template by Slug
+
+```typescript
+import { EmailTemplateApiService } from '@flusys/ng-email';
+
+private readonly templateService = inject(EmailTemplateApiService);
+
+async getTemplate(slug: string): Promise<IEmailTemplate | null> {
+  const response = await firstValueFrom(
+    this.templateService.getBySlug(slug)
+  );
+
+  return response.data ?? null;
+}
+```
+
+---
+
+## Backend Integration
+
+All endpoints use **POST-only RPC** style (not REST).
+
+| Service | Endpoint | Description |
+|---------|----------|-------------|
+| Config | `POST /email/email-config/insert` | Create config |
+| Config | `POST /email/email-config/get/:id` | Get config by ID |
+| Config | `POST /email/email-config/get-all` | List configs (paginated) |
+| Config | `POST /email/email-config/update` | Update config |
+| Config | `POST /email/email-config/delete` | Delete config |
+| Template | `POST /email/email-template/insert` | Create template |
+| Template | `POST /email/email-template/get/:id` | Get template by ID |
+| Template | `POST /email/email-template/get-all` | List templates (paginated) |
+| Template | `POST /email/email-template/get-by-slug` | Get template by slug |
+| Template | `POST /email/email-template/update` | Update template |
+| Template | `POST /email/email-template/delete` | Delete template |
+| Send | `POST /email/send/direct` | Send email directly |
+| Send | `POST /email/send/template` | Send using template |
+| Send | `POST /email/send/test` | Test configuration |
+
+---
+
+## Best Practices
+
+### 1. Use Template Slugs for Code References
+
+```typescript
+// ✅ Use slug for programmatic access
+await this.emailSendService.sendTemplate({
+  templateSlug: 'welcome-email',  // Stable identifier
+  ...
+});
+
+// ❌ Don't hardcode template IDs
+await this.emailSendService.sendTemplate({
+  templateId: 'f47ac10b-58cc-4372-a567-0e02b2c3d479',  // May change
+  ...
+});
+```
+
+### 2. Provide Both HTML and Text Content
+
+```typescript
+// ✅ Provide both for maximum compatibility
+{
+  isHtml: true,
+  htmlContent: '<h1>Hello!</h1>',
+  textContent: 'Hello!',  // Fallback for text-only clients
+}
+```
+
+### 3. Test Configurations Before Production
+
+Always use the test send feature to verify configurations work before using them in production.
+
+### 4. Use Meaningful Variable Names
+
+```typescript
+// ✅ Clear, descriptive variable names
+"Hello {{userName}}, your order #{{orderNumber}} shipped on {{shipDate}}."
+
+// ❌ Vague or abbreviated names
+"Hello {{u}}, order {{o}} shipped {{d}}."
+```
+
+### 5. Handle Send Failures Gracefully
+
+```typescript
+async sendEmail(): Promise<void> {
+  try {
+    const response = await firstValueFrom(
+      this.emailSendService.sendTemplate({ ... })
+    );
+
+    if (response.data?.success) {
+      this.messageService.add({
+        severity: 'success',
+        summary: 'Email Sent',
+        detail: `Message ID: ${response.data.messageId}`,
+      });
+    } else {
+      this.messageService.add({
+        severity: 'error',
+        summary: 'Send Failed',
+        detail: response.data?.error || 'Unknown error occurred',
+      });
+    }
+  } catch (error: any) {
+    this.messageService.add({
+      severity: 'error',
+      summary: 'Error',
+      detail: error?.message || 'Failed to send email.',
+    });
+  }
+}
+```
+
+---
+
+## Public API Exports
+
+```typescript
+// Enums
+export { EmailProviderEnum } from '@flusys/ng-email';
+export { EmailBlockType } from '@flusys/ng-email';
+
+// Interfaces
+export {
+  IEmailConfig, ICreateEmailConfigDto, IUpdateEmailConfigDto,
+  ISmtpConfig, ISendGridConfig, IMailgunConfig,
+  IEmailTemplate, ICreateEmailTemplateDto, IUpdateEmailTemplateDto,
+  IEmailSchema, IEmailSection, IEmailBlock, IEmailTemplateVariable,
+  ISendEmailDto, ISendTemplateEmailDto, ITestSendResult,
+} from '@flusys/ng-email';
+
+// Services
+export {
+  EmailConfigApiService,
+  EmailTemplateApiService,
+  EmailSendService,
+  EmailBuilderStateService,
+} from '@flusys/ng-email';
+
+// Components
+export { EmailContainerComponent } from '@flusys/ng-email';
+
+// Routes
+export { EMAIL_ROUTES } from '@flusys/ng-email';
+```
+
+---
+
+**Last Updated:** 2026-02-18
+**Angular Version:** 21