vintasend 0.3.0 → 0.4.3

package/dist/services/notification-adapters/base-notification-adapter.js

@@ -6,7 +6,7 @@ exports.isOneOffNotification = isOneOffNotification;
  * Type guard to check if a notification is a one-off notification
  */
 function isOneOffNotification(notification) {
-    return 'emailOrPhone' in notification && 'firstName' in notification && 'lastName' in notification;
+    return ('emailOrPhone' in notification && 'firstName' in notification && 'lastName' in notification);
 }
 class BaseNotificationAdapter {
     constructor(templateRenderer, notificationType, enqueueNotifications) {
@@ -15,15 +15,31 @@ class BaseNotificationAdapter {
         this.enqueueNotifications = enqueueNotifications;
         this.key = null;
         this.backend = null;
+        this.logger = null;
     }
-    ;
-    send(notification, context) {
+    send(_notification, _context) {
         if (this.backend === null) {
             return Promise.reject(new Error('Backend not injected'));
         }
         return Promise.resolve();
     }
-    ;
+    /**
+     * Check if this adapter supports attachments
+     */
+    get supportsAttachments() {
+        return false;
+    }
+    /**
+     * Prepare attachments for sending
+     * Override in adapters that support attachments
+     */
+    async prepareAttachments(attachments) {
+        var _a, _b;
+        if (this.supportsAttachments && attachments.length > 0) {
+            (_b = (_a = this.logger) === null || _a === void 0 ? void 0 : _a.warn) === null || _b === void 0 ? void 0 : _b.call(_a, `Adapter ${this.key} claims to support attachments but prepareAttachments is not implemented`);
+        }
+        return null;
+    }
     /**
      * Get the recipient email address from a notification.
      * For one-off notifications, returns the emailOrPhone field directly.
@@ -71,6 +87,8 @@ class BaseNotificationAdapter {
     injectBackend(backend) {
         this.backend = backend;
     }
-    ;
+    injectLogger(logger) {
+        this.logger = logger;
+    }
 }
 exports.BaseNotificationAdapter = BaseNotificationAdapter;

package/dist/services/notification-backends/base-notification-backend.d.ts

@@ -1,5 +1,6 @@
+import type { AttachmentFileRecord, StoredAttachment } from '../../types/attachment';
 import type { InputJsonValue } from '../../types/json-values';
-import type { DatabaseNotification, Notification, DatabaseOneOffNotification, OneOffNotificationInput, AnyNotification, AnyDatabaseNotification } from '../../types/notification';
+import type { AnyDatabaseNotification, AnyNotification, DatabaseNotification, DatabaseOneOffNotification, Notification, OneOffNotificationInput } from '../../types/notification';
 import type { BaseNotificationTypeConfig } from '../../types/notification-type-config';
 export interface BaseNotificationBackend<Config extends BaseNotificationTypeConfig> {
     getAllPendingNotifications(): Promise<AnyDatabaseNotification<Config>[]>;
@@ -27,4 +28,41 @@ export interface BaseNotificationBackend<Config extends BaseNotificationTypeConf
     getOneOffNotification(notificationId: Config['NotificationIdType'], forUpdate: boolean): Promise<DatabaseOneOffNotification<Config> | null>;
     getAllOneOffNotifications(): Promise<DatabaseOneOffNotification<Config>[]>;
     getOneOffNotifications(page: number, pageSize: number): Promise<DatabaseOneOffNotification<Config>[]>;
+    /**
+     * Get an attachment file record by ID
+     */
+    getAttachmentFile?(fileId: string): Promise<AttachmentFileRecord | null>;
+    /**
+     * Find an attachment file by checksum for deduplication.
+     * Backend queries its database for files with matching checksums.
+     * Used during file upload to avoid storing duplicate files.
+     */
+    findAttachmentFileByChecksum?(checksum: string): Promise<AttachmentFileRecord | null>;
+    /**
+     * Delete an attachment file (only if not referenced by any notifications)
+     */
+    deleteAttachmentFile?(fileId: string): Promise<void>;
+    /**
+     * Get all attachment files not referenced by any notifications (for cleanup)
+     */
+    getOrphanedAttachmentFiles?(): Promise<AttachmentFileRecord[]>;
+    /**
+     * Get all attachments for a specific notification
+     */
+    getAttachments?(notificationId: Config['NotificationIdType']): Promise<StoredAttachment[]>;
+    /**
+     * Delete a specific attachment from a notification
+     */
+    deleteNotificationAttachment?(notificationId: Config['NotificationIdType'], attachmentId: string): Promise<void>;
 }
+/**
+ * Type guard to check if backend supports attachment operations
+ */
+export declare function supportsAttachments<Config extends BaseNotificationTypeConfig>(backend: BaseNotificationBackend<Config>): backend is BaseNotificationBackend<Config> & {
+    getAttachmentFile(fileId: string): Promise<AttachmentFileRecord | null>;
+    findAttachmentFileByChecksum(checksum: string): Promise<AttachmentFileRecord | null>;
+    deleteAttachmentFile(fileId: string): Promise<void>;
+    getOrphanedAttachmentFiles(): Promise<AttachmentFileRecord[]>;
+    getAttachments(notificationId: Config['NotificationIdType']): Promise<StoredAttachment[]>;
+    deleteNotificationAttachment(notificationId: Config['NotificationIdType'], attachmentId: string): Promise<void>;
+};

package/dist/services/notification-backends/base-notification-backend.js

@@ -1,2 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.supportsAttachments = supportsAttachments;
+/**
+ * Type guard to check if backend supports attachment operations
+ */
+function supportsAttachments(backend) {
+    return (typeof backend.getAttachmentFile === 'function' &&
+        typeof backend.findAttachmentFileByChecksum === 'function' &&
+        typeof backend.deleteAttachmentFile === 'function' &&
+        typeof backend.getOrphanedAttachmentFiles === 'function' &&
+        typeof backend.getAttachments === 'function' &&
+        typeof backend.deleteNotificationAttachment === 'function');
+}

package/dist/services/notification-context-generators-map.d.ts

@@ -1,4 +1,4 @@
-import type { ContextGenerator } from "../types/notification-context-generators";
+import type { ContextGenerator } from '../types/notification-context-generators';
 export declare class NotificationContextGeneratorsMap<ContextMapType extends {
     [key: string]: ContextGenerator;
 }> {

package/dist/services/notification-context-registry.d.ts

@@ -1,14 +1,19 @@
 import type { JsonObject, JsonPrimitive } from '../types/json-values';
 export interface ContextGenerator {
-    generate(params: Record<string, JsonPrimitive>): JsonObject | Promise<JsonObject>;
+  generate(params: Record<string, JsonPrimitive>): JsonObject | Promise<JsonObject>;
 }
 export declare class NotificationContextRegistry<T extends Record<string, ContextGenerator>> {
-    private static instance;
-    private readonly contexts;
-    private constructor();
-    static initialize<T extends Record<string, ContextGenerator>>(contexts: T): NotificationContextRegistry<T>;
-    static getInstance<T extends Record<string, ContextGenerator>>(): NotificationContextRegistry<T>;
-    static resetInstance(): void;
-    getContext<K extends keyof T>(key: K, parameters: Parameters<T[K]['generate']>[0]): Promise<JsonObject>;
-    getAvailableContexts(): (keyof T)[];
+  private static instance;
+  private readonly contexts;
+  private constructor();
+  static initialize<T extends Record<string, ContextGenerator>>(
+    contexts: T,
+  ): NotificationContextRegistry<T>;
+  static getInstance<T extends Record<string, ContextGenerator>>(): NotificationContextRegistry<T>;
+  static resetInstance(): void;
+  getContext<K extends keyof T>(
+    key: K,
+    parameters: Parameters<T[K]['generate']>[0],
+  ): Promise<JsonObject>;
+  getAvailableContexts(): (keyof T)[];
 }

package/dist/services/notification-context-registry.js

@@ -1,40 +1,39 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+Object.defineProperty(exports, '__esModule', { value: true });
 exports.NotificationContextRegistry = void 0;
 class NotificationContextRegistry {
-    constructor(contexts) {
-        this.contexts = contexts;
+  constructor(contexts) {
+    this.contexts = contexts;
+  }
+  static initialize(contexts) {
+    if (NotificationContextRegistry.instance) {
+      throw new Error('NotificationContextRegistry already initialized');
     }
-    static initialize(contexts) {
-        if (NotificationContextRegistry.instance) {
-            throw new Error('NotificationContextRegistry already initialized');
-        }
-        NotificationContextRegistry.instance = new NotificationContextRegistry(contexts);
-        return NotificationContextRegistry.instance;
+    NotificationContextRegistry.instance = new NotificationContextRegistry(contexts);
+    return NotificationContextRegistry.instance;
+  }
+  static getInstance() {
+    if (!NotificationContextRegistry.instance) {
+      throw new Error('NotificationContextRegistry not initialized');
     }
-    static getInstance() {
-        if (!NotificationContextRegistry.instance) {
-            throw new Error('NotificationContextRegistry not initialized');
-        }
-        return NotificationContextRegistry.instance;
+    return NotificationContextRegistry.instance;
+  }
+  static resetInstance() {
+    NotificationContextRegistry.instance = null;
+  }
+  async getContext(key, parameters) {
+    const contextGenerator = this.contexts[key];
+    if (!contextGenerator) {
+      throw new Error(`Context generator not found for context: ${key}`);
     }
-    static resetInstance() {
-        NotificationContextRegistry.instance = null;
-    }
-    async getContext(key, parameters) {
-        const contextGenerator = this.contexts[key];
-        if (!contextGenerator) {
-            throw new Error(`Context generator not found for context: ${key}`);
-        }
-        const result = contextGenerator.generate(parameters);
-        if (result instanceof Promise) {
-            return await result;
-        }
-        return result;
-    }
-    getAvailableContexts() {
-        return Object.keys(this.contexts);
+    const result = contextGenerator.generate(parameters);
+    if (result instanceof Promise) {
+      return await result;
     }
+    return result;
+  }
+  getAvailableContexts() {
+    return Object.keys(this.contexts);
+  }
 }
 exports.NotificationContextRegistry = NotificationContextRegistry;
 // biome-ignore lint/suspicious/noExplicitAny: This won't be used since we'll always initialize the registry

package/dist/services/notification-queue-service/base-notification-queue-service.d.ts

@@ -1,4 +1,4 @@
-import type { BaseNotificationTypeConfig } from "../../types/notification-type-config";
+import type { BaseNotificationTypeConfig } from '../../types/notification-type-config';
 export interface BaseNotificationQueueService<Config extends BaseNotificationTypeConfig> {
     enqueueNotification(notificationId: Config['NotificationIdType']): Promise<void>;
 }

package/dist/services/notification-service.d.ts

@@ -1,26 +1,54 @@
-import type { DatabaseNotification, Notification, AnyNotification, AnyDatabaseNotification, DatabaseOneOffNotification } from '../types/notification';
-import type { OneOffNotificationInput } from '../types/one-off-notification';
 import type { JsonObject } from '../types/json-values';
+import type { AnyDatabaseNotification, AnyNotification, DatabaseNotification, DatabaseOneOffNotification, Notification } from '../types/notification';
 import type { BaseNotificationTypeConfig } from '../types/notification-type-config';
+import type { OneOffNotificationInput } from '../types/one-off-notification';
+import type { BaseAttachmentManager } from './attachment-manager/base-attachment-manager';
+import type { BaseLogger } from './loggers/base-logger';
 import { type BaseNotificationAdapter } from './notification-adapters/base-notification-adapter';
-import type { BaseNotificationTemplateRenderer } from './notification-template-renderers/base-notification-template-renderer';
 import type { BaseNotificationBackend } from './notification-backends/base-notification-backend';
-import type { BaseLogger } from './loggers/base-logger';
 import type { BaseNotificationQueueService } from './notification-queue-service/base-notification-queue-service';
+import type { BaseNotificationTemplateRenderer } from './notification-template-renderers/base-notification-template-renderer';
 type VintaSendOptions = {
     raiseErrorOnFailedSend: boolean;
 };
 export declare class VintaSendFactory<Config extends BaseNotificationTypeConfig> {
-    create<AdaptersList extends BaseNotificationAdapter<BaseNotificationTemplateRenderer<Config>, Config>[], Backend extends BaseNotificationBackend<Config>, Logger extends BaseLogger, QueueService extends BaseNotificationQueueService<Config>>(adapters: AdaptersList, backend: Backend, logger: Logger, contextGeneratorsMap: BaseNotificationTypeConfig['ContextMap'], queueService?: QueueService, options?: VintaSendOptions): VintaSend<Config, AdaptersList, Backend, Logger, QueueService>;
+    /**
+     * Creates a new VintaSend notification service instance
+     *
+     * @param adapters - Array of notification adapters (email, SMS, push, etc.)
+     * @param backend - Notification storage backend
+     * @param logger - Logger instance
+     * @param contextGeneratorsMap - Map of context generators for notification rendering
+     * @param queueService - Optional queue service for background notification processing
+     * @param attachmentManager - Optional attachment manager for file handling
+     * @param options - Optional configuration options
+     *
+     * @example
+     * // Without attachments or options
+     * factory.create(adapters, backend, logger, contextGeneratorsMap);
+     *
+     * @example
+     * // With queue service and options (note: pass undefined for attachmentManager)
+     * factory.create(adapters, backend, logger, contextGeneratorsMap, queueService, undefined, { raiseErrorOnFailedSend: true });
+     *
+     * @example
+     * // With attachments and options
+     * factory.create(adapters, backend, logger, contextGeneratorsMap, queueService, attachmentManager, { raiseErrorOnFailedSend: true });
+     *
+     * @since v0.4.0 - BREAKING CHANGE: attachmentManager parameter added before options
+     * @see https://github.com/vintasoftware/vintasend-ts/blob/main/README.md#migrating-to-v040-attachment-support
+     */
+    create<AdaptersList extends BaseNotificationAdapter<BaseNotificationTemplateRenderer<Config>, Config>[], Backend extends BaseNotificationBackend<Config>, Logger extends BaseLogger, QueueService extends BaseNotificationQueueService<Config>, AttachmentMgr extends BaseAttachmentManager>(adapters: AdaptersList, backend: Backend, logger: Logger, contextGeneratorsMap: BaseNotificationTypeConfig['ContextMap'], queueService?: QueueService, attachmentManager?: AttachmentMgr, options?: VintaSendOptions): VintaSend<Config, AdaptersList, Backend, Logger, QueueService, AttachmentMgr>;
 }
-export declare class VintaSend<Config extends BaseNotificationTypeConfig, AdaptersList extends BaseNotificationAdapter<BaseNotificationTemplateRenderer<Config>, Config>[], Backend extends BaseNotificationBackend<Config>, Logger extends BaseLogger, QueueService extends BaseNotificationQueueService<Config>> {
+export declare class VintaSend<Config extends BaseNotificationTypeConfig, AdaptersList extends BaseNotificationAdapter<BaseNotificationTemplateRenderer<Config>, Config>[], Backend extends BaseNotificationBackend<Config>, Logger extends BaseLogger, QueueService extends BaseNotificationQueueService<Config>, AttachmentMgr extends BaseAttachmentManager> {
     private adapters;
     private backend;
     private logger;
     private queueService?;
+    private attachmentManager?;
     private options;
     private contextGeneratorsMap;
-    constructor(adapters: AdaptersList, backend: Backend, logger: Logger, contextGeneratorsMap: Config['ContextMap'], queueService?: QueueService | undefined, options?: VintaSendOptions);
+    constructor(adapters: AdaptersList, backend: Backend, logger: Logger, contextGeneratorsMap: Config['ContextMap'], queueService?: QueueService | undefined, attachmentManager?: AttachmentMgr | undefined, options?: VintaSendOptions);
     registerQueueService(queueService: QueueService): void;
     send(notification: AnyDatabaseNotification<Config>): Promise<void>;
     createNotification(notification: Omit<Notification<Config>, 'id'>): Promise<DatabaseNotification<Config>>;

package/dist/services/notification-service.js

@@ -4,25 +4,69 @@ exports.VintaSend = exports.VintaSendFactory = void 0;
 const base_notification_adapter_1 = require("./notification-adapters/base-notification-adapter");
 const notification_context_generators_map_1 = require("./notification-context-generators-map");
 class VintaSendFactory {
-    create(adapters, backend, logger, contextGeneratorsMap, queueService, options = {
+    /**
+     * Creates a new VintaSend notification service instance
+     *
+     * @param adapters - Array of notification adapters (email, SMS, push, etc.)
+     * @param backend - Notification storage backend
+     * @param logger - Logger instance
+     * @param contextGeneratorsMap - Map of context generators for notification rendering
+     * @param queueService - Optional queue service for background notification processing
+     * @param attachmentManager - Optional attachment manager for file handling
+     * @param options - Optional configuration options
+     *
+     * @example
+     * // Without attachments or options
+     * factory.create(adapters, backend, logger, contextGeneratorsMap);
+     *
+     * @example
+     * // With queue service and options (note: pass undefined for attachmentManager)
+     * factory.create(adapters, backend, logger, contextGeneratorsMap, queueService, undefined, { raiseErrorOnFailedSend: true });
+     *
+     * @example
+     * // With attachments and options
+     * factory.create(adapters, backend, logger, contextGeneratorsMap, queueService, attachmentManager, { raiseErrorOnFailedSend: true });
+     *
+     * @since v0.4.0 - BREAKING CHANGE: attachmentManager parameter added before options
+     * @see https://github.com/vintasoftware/vintasend-ts/blob/main/README.md#migrating-to-v040-attachment-support
+     */
+    create(adapters, backend, logger, contextGeneratorsMap, queueService, attachmentManager, options = {
         raiseErrorOnFailedSend: false,
     }) {
-        return new VintaSend(adapters, backend, logger, contextGeneratorsMap, queueService, options);
+        return new VintaSend(adapters, backend, logger, contextGeneratorsMap, queueService, attachmentManager, options);
     }
 }
 exports.VintaSendFactory = VintaSendFactory;
+// Type guard to check if backend has attachment manager injection support
+function hasAttachmentManagerInjection(backend) {
+    return ('injectAttachmentManager' in backend &&
+        // biome-ignore lint/suspicious/noExplicitAny:: this is a necessary check
+        typeof backend.injectAttachmentManager === 'function');
+}
 class VintaSend {
-    constructor(adapters, backend, logger, contextGeneratorsMap, queueService, options = {
+    constructor(adapters, backend, logger, contextGeneratorsMap, queueService, attachmentManager, options = {
         raiseErrorOnFailedSend: false,
     }) {
         this.adapters = adapters;
         this.backend = backend;
         this.logger = logger;
         this.queueService = queueService;
+        this.attachmentManager = attachmentManager;
         this.options = options;
         this.contextGeneratorsMap = new notification_context_generators_map_1.NotificationContextGeneratorsMap(contextGeneratorsMap);
         for (const adapter of adapters) {
             adapter.injectBackend(backend);
+            adapter.injectLogger(logger);
+            // Inject logger into template renderer if it supports it
+            // biome-ignore lint/suspicious/noExplicitAny: accessing protected templateRenderer property
+            const templateRenderer = adapter.templateRenderer;
+            if (templateRenderer && typeof templateRenderer.injectLogger === 'function') {
+                templateRenderer.injectLogger(logger);
+            }
+        }
+        // Inject attachment manager into backend if both exist
+        if (this.attachmentManager && hasAttachmentManagerInjection(backend)) {
+            backend.injectAttachmentManager(this.attachmentManager);
         }
     }
     registerQueueService(queueService) {

package/dist/services/notification-template-renderers/base-email-template-renderer.d.ts

@@ -1,8 +1,9 @@
-import type { BaseNotificationTemplateRenderer } from './base-notification-template-renderer';
-import type { AnyNotification } from '../../types/notification';
 import type { Buffer } from 'node:buffer';
 import type { JsonObject } from '../../types/json-values';
+import type { AnyNotification } from '../../types/notification';
 import type { BaseNotificationTypeConfig } from '../../types/notification-type-config';
+import type { BaseLogger } from '../loggers/base-logger';
+import type { BaseNotificationTemplateRenderer } from './base-notification-template-renderer';
 export type Attachment = File | Buffer | string;
 export type EmailTemplate = {
     subject: string;
@@ -10,4 +11,8 @@ export type EmailTemplate = {
 };
 export interface BaseEmailTemplateRenderer<Config extends BaseNotificationTypeConfig> extends BaseNotificationTemplateRenderer<Config, EmailTemplate> {
     render(notification: AnyNotification<Config>, context: JsonObject): Promise<EmailTemplate>;
+    /**
+     * Inject logger into the template renderer (optional - called by VintaSend when logger exists)
+     */
+    injectLogger?(logger: BaseLogger): void;
 }

package/dist/types/attachment.d.ts

@@ -0,0 +1,42 @@
+import type { Readable } from 'node:stream';
+export type FileAttachment = Buffer | ReadableStream | Readable | string;
+export interface NotificationAttachmentUpload {
+    file: FileAttachment;
+    filename: string;
+    contentType?: string;
+    description?: string;
+}
+export interface NotificationAttachmentReference {
+    fileId: string;
+    description?: string;
+}
+export type NotificationAttachment = NotificationAttachmentUpload | NotificationAttachmentReference;
+export declare function isAttachmentReference(attachment: NotificationAttachment): attachment is NotificationAttachmentReference;
+export interface AttachmentFile {
+    read(): Promise<Buffer>;
+    stream(): Promise<ReadableStream>;
+    url(expiresIn?: number): Promise<string>;
+    delete(): Promise<void>;
+}
+export interface AttachmentFileRecord {
+    id: string;
+    filename: string;
+    contentType: string;
+    size: number;
+    checksum: string;
+    storageMetadata: Record<string, unknown>;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface StoredAttachment {
+    id: string;
+    fileId: string;
+    filename: string;
+    contentType: string;
+    size: number;
+    checksum: string;
+    createdAt: Date;
+    file: AttachmentFile;
+    description?: string;
+    storageMetadata: Record<string, unknown>;
+}

package/dist/types/attachment.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAttachmentReference = isAttachmentReference;
+// Type guard to check if attachment is a reference
+function isAttachmentReference(attachment) {
+    return 'fileId' in attachment;
+}

package/dist/types/notification-type-config.d.ts

@@ -1,5 +1,5 @@
-import type { ContextGenerator } from "./notification-context-generators";
-import type { Identifier } from "./identifier";
+import type { Identifier } from './identifier';
+import type { ContextGenerator } from './notification-context-generators';
 export type BaseNotificationTypeConfig = {
     ContextMap: Record<string, ContextGenerator>;
     NotificationIdType: Identifier;

package/dist/types/notification.d.ts

@@ -1,9 +1,10 @@
+import type { NotificationAttachment, StoredAttachment } from './attachment';
 import type { InputJsonValue, JsonValue } from './json-values';
 import type { NotificationStatus } from './notification-status';
 import type { NotificationType } from './notification-type';
 import type { BaseNotificationTypeConfig } from './notification-type-config';
 import type { DatabaseOneOffNotification, OneOffNotification, OneOffNotificationInput } from './one-off-notification';
-export type { OneOffNotificationInput, OneOffNotificationResendWithContextInput, DatabaseOneOffNotification, OneOffNotification, } from './one-off-notification';
+export type { DatabaseOneOffNotification, OneOffNotification, OneOffNotificationInput, OneOffNotificationResendWithContextInput, } from './one-off-notification';
 export type NotificationInput<Config extends BaseNotificationTypeConfig> = {
     userId: Config['UserIdType'];
     notificationType: NotificationType;
@@ -14,6 +15,7 @@ export type NotificationInput<Config extends BaseNotificationTypeConfig> = {
     sendAfter: Date | null;
     subjectTemplate: string | null;
     extraParams: InputJsonValue | null;
+    attachments?: NotificationAttachment[];
 };
 export type NotificationResendWithContextInput<Config extends BaseNotificationTypeConfig> = {
     userId: Config['UserIdType'];
@@ -26,6 +28,7 @@ export type NotificationResendWithContextInput<Config extends BaseNotificationTy
     sendAfter: Date | null;
     subjectTemplate: string | null;
     extraParams: InputJsonValue | null;
+    attachments?: NotificationAttachment[];
 };
 export type DatabaseNotification<Config extends BaseNotificationTypeConfig> = {
     id: Config['NotificationIdType'];
@@ -45,6 +48,7 @@ export type DatabaseNotification<Config extends BaseNotificationTypeConfig> = {
     readAt: Date | null;
     createdAt?: Date;
     updatedAt?: Date;
+    attachments?: StoredAttachment[];
 };
 export type Notification<Config extends BaseNotificationTypeConfig> = NotificationInput<Config> | NotificationResendWithContextInput<Config> | DatabaseNotification<Config>;
 /**

package/dist/types/one-off-notification.d.ts

@@ -1,3 +1,4 @@
+import type { NotificationAttachment, StoredAttachment } from './attachment';
 import type { InputJsonValue, JsonValue } from './json-values';
 import type { NotificationStatus } from './notification-status';
 import type { NotificationType } from './notification-type';
@@ -18,6 +19,7 @@ export type OneOffNotificationInput<Config extends BaseNotificationTypeConfig> =
     sendAfter: Date | null;
     subjectTemplate: string | null;
     extraParams: InputJsonValue | null;
+    attachments?: NotificationAttachment[];
 };
 /**
  * Input type for resending a one-off notification with stored context.
@@ -36,6 +38,7 @@ export type OneOffNotificationResendWithContextInput<Config extends BaseNotifica
     sendAfter: Date | null;
     subjectTemplate: string | null;
     extraParams: InputJsonValue | null;
+    attachments?: NotificationAttachment[];
 };
 /**
  * Database representation of a one-off notification.
@@ -61,6 +64,7 @@ export type DatabaseOneOffNotification<Config extends BaseNotificationTypeConfig
     readAt: Date | null;
     createdAt?: Date;
     updatedAt?: Date;
+    attachments?: StoredAttachment[];
 };
 /**
  * Union type representing any one-off notification (input, resend, or database).

package/package.json

@@ -1,16 +1,14 @@
 {
   "name": "vintasend",
-  "version": "0.3.0",
+  "version": "0.4.3",
   "main": "dist/index.js",
-  "files": [
-    "dist"
-  ],
+  "files": ["dist"],
   "author": "Hugo Bessa",
   "license": "MIT",
   "scripts": {
     "lint": "biome check .",
     "format": "biome format .",
-    "check": "biome check --apply .",
+    "check": "biome check --write .",
     "build": "tsc",
     "prepublishOnly": "npm run build",
     "test": "jest",
@@ -18,11 +16,15 @@
     "test:coverage": "jest --coverage"
   },
   "devDependencies": {
-    "@biomejs/biome": "1.9.4",
-    "@types/jest": "^29.5.14",
-    "@types/node": "^22.13.1",
-    "jest": "^29.7.0",
-    "ts-jest": "^29.2.6",
-    "typescript": "^5.8.2"
+    "@biomejs/biome": "^2.3.11",
+    "@types/jest": "^30.0.0",
+    "@types/mime-types": "^3.0.1",
+    "@types/node": "^25.0.8",
+    "jest": "^30.2.0",
+    "ts-jest": "^29.4.6",
+    "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "mime-types": "^3.0.2"
   }
 }