vintasend 0.2.3 → 0.4.0

package/dist/implementations/vintasend-winston/src/winston-logger.d.ts

@@ -1,9 +1,9 @@
 import type { BaseLogger } from 'vintasend/src/services/loggers/base-logger';
-import * as winston from 'winston';
+import type * as winston from 'winston';
 export declare class WinstonLogger implements BaseLogger {
-    private logger;
-    constructor(winstonOptions?: Parameters<typeof winston.createLogger>[0]);
-    info(message: string): void;
-    error(message: string): void;
-    warn(message: string): void;
+  private logger;
+  constructor(winstonOptions?: Parameters<typeof winston.createLogger>[0]);
+  info(message: string): void;
+  error(message: string): void;
+  warn(message: string): void;
 }

package/dist/implementations/vintasend-winston/src/winston-logger.js

@@ -1,57 +1,72 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
+var __createBinding =
+  (this && this.__createBinding) ||
+  (Object.create
+    ? (o, m, k, k2) => {
+        if (k2 === undefined) k2 = k;
+        var desc = Object.getOwnPropertyDescriptor(m, k);
+        if (!desc || ('get' in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+          desc = { enumerable: true, get: () => m[k] };
+        }
+        Object.defineProperty(o, k2, desc);
+      }
+    : (o, m, k, k2) => {
+        if (k2 === undefined) k2 = k;
+        o[k2] = m[k];
+      });
+var __setModuleDefault =
+  (this && this.__setModuleDefault) ||
+  (Object.create
+    ? (o, v) => {
+        Object.defineProperty(o, 'default', { enumerable: true, value: v });
+      }
+    : (o, v) => {
+        o['default'] = v;
+      });
+var __importStar =
+  (this && this.__importStar) ||
+  (() => {
+    var ownKeys = (o) => {
+      ownKeys =
+        Object.getOwnPropertyNames ||
+        ((o) => {
+          var ar = [];
+          for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+          return ar;
+        });
+      return ownKeys(o);
     };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
+    return (mod) => {
+      if (mod && mod.__esModule) return mod;
+      var result = {};
+      if (mod != null)
+        for (var k = ownKeys(mod), i = 0; i < k.length; i++)
+          if (k[i] !== 'default') __createBinding(result, mod, k[i]);
+      __setModuleDefault(result, mod);
+      return result;
     };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
+  })();
+Object.defineProperty(exports, '__esModule', { value: true });
 exports.WinstonLogger = void 0;
-const winston = __importStar(require("winston"));
+const winston = __importStar(require('winston'));
 class WinstonLogger {
-    constructor(winstonOptions) {
-        this.logger = winston.createLogger(winstonOptions || {});
-        if (process.env.NODE_ENV === 'development') {
-            this.logger.add(new winston.transports.Console({
-                format: winston.format.simple(),
-            }));
-        }
-    }
-    info(message) {
-        this.logger.info(message);
-    }
-    error(message) {
-        this.logger.error(message);
-    }
-    warn(message) {
-        this.logger.warn(message);
+  constructor(winstonOptions) {
+    this.logger = winston.createLogger(winstonOptions || {});
+    if (process.env.NODE_ENV === 'development') {
+      this.logger.add(
+        new winston.transports.Console({
+          format: winston.format.simple(),
+        }),
+      );
     }
+  }
+  info(message) {
+    this.logger.info(message);
+  }
+  error(message) {
+    this.logger.error(message);
+  }
+  warn(message) {
+    this.logger.warn(message);
+  }
 }
 exports.WinstonLogger = WinstonLogger;

package/dist/index.d.ts

@@ -1,8 +1,16 @@
-export { VintaSendFactory } from './services/notification-service';
+export { BaseAttachmentManager } from './services/attachment-manager/base-attachment-manager';
+export type { LocalFileAttachmentManagerConfig } from './services/attachment-manager/local-file-attachment-manager';
+export { LocalFileAttachmentManager } from './services/attachment-manager/local-file-attachment-manager';
+export { BaseNotificationAdapter, isOneOffNotification, } from './services/notification-adapters/base-notification-adapter';
+export type { BaseNotificationBackend } from './services/notification-backends/base-notification-backend';
+export { supportsAttachments } from './services/notification-backends/base-notification-backend';
+export type { BaseNotificationQueueService } from './services/notification-queue-service/base-notification-queue-service';
 export type { VintaSend } from './services/notification-service';
-export type { Notification, DatabaseNotification, NotificationInput, NotificationResendWithContextInput, } from './types/notification';
+export { VintaSendFactory } from './services/notification-service';
+export type { BaseEmailTemplateRenderer } from './services/notification-template-renderers/base-email-template-renderer';
+export type { BaseNotificationTemplateRenderer } from './services/notification-template-renderers/base-notification-template-renderer';
+export type { AttachmentFile, AttachmentFileRecord, FileAttachment, NotificationAttachment, NotificationAttachmentReference, NotificationAttachmentUpload, StoredAttachment, } from './types/attachment';
+export { isAttachmentReference } from './types/attachment';
+export type { AnyDatabaseNotification, AnyNotification, AnyNotificationInput, DatabaseNotification, DatabaseOneOffNotification, Notification, NotificationInput, NotificationResendWithContextInput, OneOffNotification, OneOffNotificationInput, OneOffNotificationResendWithContextInput, } from './types/notification';
 export type { ContextGenerator } from './types/notification-context-generators';
 export type { BaseNotificationTypeConfig } from './types/notification-type-config';
-export type { BaseNotificationQueueService } from './services/notification-queue-service/base-notification-queue-service';
-export type { BaseNotificationTemplateRenderer } from './services/notification-template-renderers/base-notification-template-renderer';
-export type { BaseEmailTemplateRenderer } from './services/notification-template-renderers/base-email-template-renderer';

package/dist/index.js

@@ -1,5 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VintaSendFactory = void 0;
+exports.isAttachmentReference = exports.VintaSendFactory = exports.supportsAttachments = exports.isOneOffNotification = exports.BaseNotificationAdapter = exports.LocalFileAttachmentManager = exports.BaseAttachmentManager = void 0;
+// Attachment Manager
+var base_attachment_manager_1 = require("./services/attachment-manager/base-attachment-manager");
+Object.defineProperty(exports, "BaseAttachmentManager", { enumerable: true, get: function () { return base_attachment_manager_1.BaseAttachmentManager; } });
+var local_file_attachment_manager_1 = require("./services/attachment-manager/local-file-attachment-manager");
+Object.defineProperty(exports, "LocalFileAttachmentManager", { enumerable: true, get: function () { return local_file_attachment_manager_1.LocalFileAttachmentManager; } });
+var base_notification_adapter_1 = require("./services/notification-adapters/base-notification-adapter");
+Object.defineProperty(exports, "BaseNotificationAdapter", { enumerable: true, get: function () { return base_notification_adapter_1.BaseNotificationAdapter; } });
+Object.defineProperty(exports, "isOneOffNotification", { enumerable: true, get: function () { return base_notification_adapter_1.isOneOffNotification; } });
+var base_notification_backend_1 = require("./services/notification-backends/base-notification-backend");
+Object.defineProperty(exports, "supportsAttachments", { enumerable: true, get: function () { return base_notification_backend_1.supportsAttachments; } });
 var notification_service_1 = require("./services/notification-service");
 Object.defineProperty(exports, "VintaSendFactory", { enumerable: true, get: function () { return notification_service_1.VintaSendFactory; } });
+var attachment_1 = require("./types/attachment");
+Object.defineProperty(exports, "isAttachmentReference", { enumerable: true, get: function () { return attachment_1.isAttachmentReference; } });

package/dist/services/attachment-manager/base-attachment-manager.d.ts

@@ -0,0 +1,42 @@
+import type { AttachmentFile, AttachmentFileRecord, FileAttachment } from '../../types/attachment';
+export declare abstract class BaseAttachmentManager {
+    /**
+     * Upload a file and return file record (reusable across notifications)
+     */
+    abstract uploadFile(file: FileAttachment, filename: string, contentType?: string): Promise<AttachmentFileRecord>;
+    /**
+     * Delete a file (only if not referenced by any notifications)
+     */
+    abstract deleteFile(fileId: string): Promise<void>;
+    /**
+     * Reconstruct AttachmentFile from storage metadata
+     */
+    abstract reconstructAttachmentFile(storageMetadata: Record<string, unknown>): AttachmentFile;
+    /**
+     * Detect content type from filename
+     * Public to allow backends and custom implementations to use it
+     */
+    detectContentType(filename: string): string;
+    /**
+     * Calculate checksum for file data
+     * Public to allow backends to perform deduplication checks
+     */
+    calculateChecksum(data: Buffer): string;
+    /**
+     * Convert various file formats to Buffer
+     * Public to allow backends and custom implementations to use it
+     */
+    fileToBuffer(file: FileAttachment): Promise<Buffer>;
+    /**
+     * Type guard to check if value is a Node.js Readable stream
+     */
+    private isNodeReadable;
+    /**
+     * Convert Web ReadableStream to Buffer
+     */
+    private webStreamToBuffer;
+    /**
+     * Convert Node.js Readable stream to Buffer
+     */
+    private nodeStreamToBuffer;
+}

package/dist/services/attachment-manager/base-attachment-manager.js

@@ -0,0 +1,115 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseAttachmentManager = void 0;
+const crypto = __importStar(require("node:crypto"));
+const mime = __importStar(require("mime-types"));
+class BaseAttachmentManager {
+    /**
+     * Detect content type from filename
+     * Public to allow backends and custom implementations to use it
+     */
+    detectContentType(filename) {
+        return mime.lookup(filename) || 'application/octet-stream';
+    }
+    /**
+     * Calculate checksum for file data
+     * Public to allow backends to perform deduplication checks
+     */
+    calculateChecksum(data) {
+        return crypto.createHash('sha256').update(data).digest('hex');
+    }
+    /**
+     * Convert various file formats to Buffer
+     * Public to allow backends and custom implementations to use it
+     */
+    async fileToBuffer(file) {
+        if (Buffer.isBuffer(file)) {
+            return file;
+        }
+        // Support both Web ReadableStream and Node.js Readable streams
+        if (typeof ReadableStream !== 'undefined' && file instanceof ReadableStream) {
+            return this.webStreamToBuffer(file);
+        }
+        // Check for Node.js Readable stream
+        if (this.isNodeReadable(file)) {
+            return this.nodeStreamToBuffer(file);
+        }
+        if (typeof file === 'string') {
+            const fs = await Promise.resolve().then(() => __importStar(require('node:fs/promises')));
+            return fs.readFile(file);
+        }
+        throw new Error('Unsupported file type');
+    }
+    /**
+     * Type guard to check if value is a Node.js Readable stream
+     */
+    isNodeReadable(value) {
+        return (typeof value === 'object' &&
+            value !== null &&
+            // biome-ignore lint/suspicious/noExplicitAny: checking for stream methods
+            typeof value.read === 'function' &&
+            // biome-ignore lint/suspicious/noExplicitAny: checking for stream methods
+            typeof value.on === 'function' &&
+            // biome-ignore lint/suspicious/noExplicitAny: checking for stream methods
+            typeof value.pipe === 'function');
+    }
+    /**
+     * Convert Web ReadableStream to Buffer
+     */
+    async webStreamToBuffer(stream) {
+        const reader = stream.getReader();
+        const chunks = [];
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            chunks.push(value);
+        }
+        return Buffer.concat(chunks);
+    }
+    /**
+     * Convert Node.js Readable stream to Buffer
+     */
+    async nodeStreamToBuffer(stream) {
+        const chunks = [];
+        return new Promise((resolve, reject) => {
+            stream.on('data', (chunk) => chunks.push(chunk));
+            stream.on('error', reject);
+            stream.on('end', () => resolve(Buffer.concat(chunks)));
+        });
+    }
+}
+exports.BaseAttachmentManager = BaseAttachmentManager;

package/dist/services/attachment-manager/local-file-attachment-manager.d.ts

@@ -0,0 +1,58 @@
+import type { AttachmentFile, AttachmentFileRecord, FileAttachment } from '../../types/attachment';
+import { BaseAttachmentManager } from './base-attachment-manager';
+/**
+ * Configuration options for LocalFileAttachmentManager
+ */
+export interface LocalFileAttachmentManagerConfig {
+    /**
+     * Base directory where attachment files will be stored
+     * Defaults to './attachments' relative to process.cwd()
+     */
+    baseDirectory?: string;
+    /**
+     * Whether to create the base directory if it doesn't exist
+     * Defaults to true
+     */
+    createDirectoryIfNotExists?: boolean;
+}
+/**
+ * Local filesystem-based attachment manager for development and testing.
+ *
+ * WARNING: This implementation is NOT recommended for production use.
+ * Use cloud storage solutions (S3, Azure Blob, GCS) for production.
+ *
+ * Features:
+ * - Simple filesystem-based storage
+ * - No external dependencies beyond Node.js
+ * - Useful for development and testing
+ * - Quick setup for prototyping
+ *
+ * Limitations:
+ * - Not scalable across multiple servers
+ * - No built-in redundancy or backup
+ * - File URLs are local file paths, not HTTP URLs
+ * - Performance degrades with large numbers of files
+ *
+ * @example
+ * ```typescript
+ * const attachmentManager = new LocalFileAttachmentManager({
+ *   baseDirectory: './uploads/attachments'
+ * });
+ * ```
+ */
+export declare class LocalFileAttachmentManager extends BaseAttachmentManager {
+    private baseDirectory;
+    constructor(config?: LocalFileAttachmentManagerConfig);
+    /**
+     * Upload a file to the local filesystem
+     */
+    uploadFile(file: FileAttachment, filename: string, contentType?: string): Promise<AttachmentFileRecord>;
+    /**
+     * Delete a file from the local filesystem
+     */
+    deleteFile(fileId: string): Promise<void>;
+    /**
+     * Reconstruct an AttachmentFile interface from stored metadata
+     */
+    reconstructAttachmentFile(storageMetadata: Record<string, unknown>): AttachmentFile;
+}

package/dist/services/attachment-manager/local-file-attachment-manager.js

@@ -0,0 +1,192 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalFileAttachmentManager = void 0;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_stream_1 = require("node:stream");
+const node_util_1 = require("node:util");
+const base_attachment_manager_1 = require("./base-attachment-manager");
+const writeFile = (0, node_util_1.promisify)(fs.writeFile);
+const readFile = (0, node_util_1.promisify)(fs.readFile);
+const unlink = (0, node_util_1.promisify)(fs.unlink);
+const access = (0, node_util_1.promisify)(fs.access);
+/**
+ * Local filesystem-based attachment manager for development and testing.
+ *
+ * WARNING: This implementation is NOT recommended for production use.
+ * Use cloud storage solutions (S3, Azure Blob, GCS) for production.
+ *
+ * Features:
+ * - Simple filesystem-based storage
+ * - No external dependencies beyond Node.js
+ * - Useful for development and testing
+ * - Quick setup for prototyping
+ *
+ * Limitations:
+ * - Not scalable across multiple servers
+ * - No built-in redundancy or backup
+ * - File URLs are local file paths, not HTTP URLs
+ * - Performance degrades with large numbers of files
+ *
+ * @example
+ * ```typescript
+ * const attachmentManager = new LocalFileAttachmentManager({
+ *   baseDirectory: './uploads/attachments'
+ * });
+ * ```
+ */
+class LocalFileAttachmentManager extends base_attachment_manager_1.BaseAttachmentManager {
+    constructor(config = {}) {
+        super();
+        this.baseDirectory = config.baseDirectory || './attachments';
+        if (config.createDirectoryIfNotExists !== false) {
+            // Create directory synchronously during construction
+            if (!fs.existsSync(this.baseDirectory)) {
+                fs.mkdirSync(this.baseDirectory, { recursive: true });
+            }
+        }
+    }
+    /**
+     * Upload a file to the local filesystem
+     */
+    async uploadFile(file, filename, contentType) {
+        // Convert file to buffer
+        const buffer = await this.fileToBuffer(file);
+        // Detect content type if not provided
+        const finalContentType = contentType || this.detectContentType(filename);
+        // Calculate checksum
+        const checksum = this.calculateChecksum(buffer);
+        // Generate unique file ID
+        const fileId = `${Date.now()}-${Math.random().toString(36).substring(2, 15)}`;
+        // Sanitize filename to prevent directory traversal
+        const sanitizedFilename = path.basename(filename);
+        // Create file path
+        const filePath = path.join(this.baseDirectory, fileId);
+        // Write file to disk
+        await writeFile(filePath, buffer);
+        // Get file size
+        const size = buffer.length;
+        // Return file record
+        return {
+            id: fileId,
+            filename: sanitizedFilename,
+            contentType: finalContentType,
+            size,
+            checksum,
+            storageMetadata: {
+                path: filePath,
+                backend: 'local-filesystem',
+            },
+            createdAt: new Date(),
+            updatedAt: new Date(),
+        };
+    }
+    /**
+     * Delete a file from the local filesystem
+     */
+    async deleteFile(fileId) {
+        const filePath = path.join(this.baseDirectory, fileId);
+        try {
+            await access(filePath, fs.constants.F_OK);
+            await unlink(filePath);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                // File doesn't exist, consider it already deleted
+                return;
+            }
+            throw error;
+        }
+    }
+    /**
+     * Reconstruct an AttachmentFile interface from stored metadata
+     */
+    reconstructAttachmentFile(storageMetadata) {
+        if (!storageMetadata.path || typeof storageMetadata.path !== 'string') {
+            throw new Error('Invalid storage metadata: missing path');
+        }
+        const filePath = storageMetadata.path;
+        return new LocalAttachmentFile(filePath, this);
+    }
+}
+exports.LocalFileAttachmentManager = LocalFileAttachmentManager;
+/**
+ * Local filesystem implementation of AttachmentFile interface
+ */
+class LocalAttachmentFile {
+    constructor(filePath, manager) {
+        this.filePath = filePath;
+        this.manager = manager;
+    }
+    /**
+     * Read the entire file into memory as a Buffer
+     */
+    async read() {
+        try {
+            return await readFile(this.filePath);
+        }
+        catch (error) {
+            throw new Error(`Failed to read file ${this.filePath}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Get a readable stream for the file
+     */
+    async stream() {
+        const nodeStream = fs.createReadStream(this.filePath);
+        // Convert Node.js Readable to Web ReadableStream
+        return node_stream_1.Readable.toWeb(nodeStream);
+    }
+    /**
+     * Get a local file path (not an HTTP URL)
+     *
+     * WARNING: This returns a local file path, not an HTTP URL.
+     * This is only useful for development/testing scenarios.
+     */
+    async url(_expiresIn) {
+        // For local files, just return the absolute file path
+        // Note: This is not an HTTP URL and won't work in browsers
+        return `file://${path.resolve(this.filePath)}`;
+    }
+    /**
+     * Delete the file from local filesystem
+     */
+    async delete() {
+        // Extract file ID from path (last component)
+        const fileId = path.basename(this.filePath);
+        await this.manager.deleteFile(fileId);
+    }
+}

package/dist/services/notification-adapters/base-notification-adapter.d.ts

@@ -1,16 +1,48 @@
-import type { NotificationType } from '../../types/notification-type';
-import type { DatabaseNotification } from '../../types/notification';
-import type { BaseNotificationTemplateRenderer } from '../notification-template-renderers/base-notification-template-renderer';
+import type { StoredAttachment } from '../../types/attachment';
 import type { JsonValue } from '../../types/json-values';
+import type { AnyDatabaseNotification, DatabaseOneOffNotification } from '../../types/notification';
+import type { NotificationType } from '../../types/notification-type';
 import type { BaseNotificationTypeConfig } from '../../types/notification-type-config';
+import type { BaseLogger } from '../loggers/base-logger';
 import type { BaseNotificationBackend } from '../notification-backends/base-notification-backend';
+import type { BaseNotificationTemplateRenderer } from '../notification-template-renderers/base-notification-template-renderer';
+/**
+ * Type guard to check if a notification is a one-off notification
+ */
+export declare function isOneOffNotification<Config extends BaseNotificationTypeConfig>(notification: AnyDatabaseNotification<Config>): notification is DatabaseOneOffNotification<Config>;
 export declare abstract class BaseNotificationAdapter<TemplateRenderer extends BaseNotificationTemplateRenderer<Config>, Config extends BaseNotificationTypeConfig> {
     protected templateRenderer: TemplateRenderer;
     readonly notificationType: NotificationType;
     readonly enqueueNotifications: boolean;
     key: string | null;
     backend: BaseNotificationBackend<Config> | null;
+    logger: BaseLogger | null;
     constructor(templateRenderer: TemplateRenderer, notificationType: NotificationType, enqueueNotifications: boolean);
-    send(notification: DatabaseNotification<Config>, context: JsonValue): Promise<void>;
+    send(_notification: AnyDatabaseNotification<Config>, _context: JsonValue): Promise<void>;
+    /**
+     * Check if this adapter supports attachments
+     */
+    get supportsAttachments(): boolean;
+    /**
+     * Prepare attachments for sending
+     * Override in adapters that support attachments
+     */
+    protected prepareAttachments(attachments: StoredAttachment[]): Promise<unknown>;
+    /**
+     * Get the recipient email address from a notification.
+     * For one-off notifications, returns the emailOrPhone field directly.
+     * For regular notifications, fetches the email from the user via backend.
+     */
+    protected getRecipientEmail(notification: AnyDatabaseNotification<Config>): Promise<string>;
+    /**
+     * Get the recipient name from a notification.
+     * For one-off notifications, returns the firstName and lastName fields directly.
+     * For regular notifications, attempts to extract from context or returns empty strings.
+     */
+    protected getRecipientName(notification: AnyDatabaseNotification<Config>, context: JsonValue): {
+        firstName: string;
+        lastName: string;
+    };
     injectBackend(backend: BaseNotificationBackend<Config>): void;
+    injectLogger(logger: BaseLogger): void;
 }