vintasend-prisma 0.3.0 → 0.4.0

package/dist/prisma-notification-backend.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PrismaNotificationBackendFactory = exports.PrismaNotificationBackend = exports.NotificationTypeEnum = exports.NotificationStatusEnum = void 0;
+const attachment_1 = require("vintasend/dist/types/attachment");
 exports.NotificationStatusEnum = {
     PENDING_SEND: 'PENDING_SEND',
     SENT: 'SENT',
@@ -14,6 +15,14 @@ exports.NotificationTypeEnum = {
     SMS: 'SMS',
     IN_APP: 'IN_APP',
 };
+// Centralized attachment include shape for DRY
+const notificationWithAttachmentsInclude = {
+    attachments: {
+        include: {
+            attachmentFile: true,
+        },
+    },
+};
 function convertJsonValueToRecord(jsonValue) {
     if (typeof jsonValue === 'object' && !Array.isArray(jsonValue)) {
         return jsonValue;
@@ -21,8 +30,15 @@ function convertJsonValueToRecord(jsonValue) {
     throw new Error('Invalid JSON value. It should be an object.');
 }
 class PrismaNotificationBackend {
-    constructor(prismaClient) {
+    constructor(prismaClient, attachmentManager) {
         this.prismaClient = prismaClient;
+        this.attachmentManager = attachmentManager;
+    }
+    /**
+     * Inject attachment manager (called by VintaSend when both service and backend exist)
+     */
+    injectAttachmentManager(manager) {
+        this.attachmentManager = manager;
     }
     /**
      * Build a where clause for status-based updates
@@ -62,6 +78,10 @@ class PrismaNotificationBackend {
             readAt: notification.readAt,
             createdAt: notification.createdAt,
             updatedAt: notification.updatedAt,
+            // Serialize attachments if present and attachmentManager is available
+            attachments: notification.attachments && this.attachmentManager
+                ? notification.attachments.map((att) => this.serializeStoredAttachment(att))
+                : undefined,
         };
         // Check if this is a one-off notification (has emailOrPhone but no userId)
         // Use explicit null checks to avoid misclassification with empty strings or other falsy values
@@ -125,21 +145,26 @@ class PrismaNotificationBackend {
             sendAfter: notification.sendAfter,
             subjectTemplate: notification.subjectTemplate,
             extraParams: notification.extraParams,
+            // Only include one-off fields if this is actually a one-off notification
+            ...(isOneOff && {
+                emailOrPhone: 'emailOrPhone' in notification ? notification.emailOrPhone : null,
+                firstName: 'firstName' in notification ? (_a = notification.firstName) !== null && _a !== void 0 ? _a : null : null,
+                lastName: 'lastName' in notification ? (_b = notification.lastName) !== null && _b !== void 0 ? _b : null : null,
+            }),
         };
         if (isOneOff) {
             return {
                 ...base,
                 userId: null,
-                emailOrPhone: 'emailOrPhone' in notification ? notification.emailOrPhone : '',
-                firstName: (_a = ('firstName' in notification ? notification.firstName : null)) !== null && _a !== void 0 ? _a : null,
-                lastName: (_b = ('lastName' in notification ? notification.lastName : null)) !== null && _b !== void 0 ? _b : null,
                 status: exports.NotificationStatusEnum.PENDING_SEND,
+                user: undefined,
             };
         }
         // At this point we know hasUserId is true, so userId exists and is not null
         const userId = ('userId' in notification ? notification.userId : null);
         return {
             ...base,
+            userId,
             user: {
                 connect: { id: userId },
             },
@@ -240,6 +265,123 @@ class PrismaNotificationBackend {
         }
         return data;
     }
+    /**
+     * Get or create file record for attachment upload with deduplication (transaction-aware)
+     * @private
+     */
+    async getOrCreateFileRecordForUploadInTransaction(tx, att) {
+        const manager = this.getAttachmentManager();
+        const buffer = await manager.fileToBuffer(att.file);
+        const checksum = manager.calculateChecksum(buffer);
+        let fileRecord = await this.findAttachmentFileByChecksumInTransaction(tx, checksum);
+        if (!fileRecord) {
+            fileRecord = await manager.uploadFile(att.file, att.filename, att.contentType);
+            await tx.attachmentFile.create({
+                data: {
+                    id: fileRecord.id,
+                    filename: fileRecord.filename,
+                    contentType: fileRecord.contentType,
+                    size: fileRecord.size,
+                    checksum: fileRecord.checksum,
+                    storageMetadata: fileRecord.storageMetadata,
+                },
+            });
+        }
+        return fileRecord;
+    }
+    /**
+     * Get or create file record for attachment upload with deduplication (non-transactional)
+     * @private
+     */
+    async getOrCreateFileRecordForUpload(att) {
+        return this.getOrCreateFileRecordForUploadInTransaction(this.prismaClient, att);
+    }
+    /**
+     * Create notification attachment link (transaction-aware)
+     * @private
+     */
+    async createNotificationAttachmentLinkInTransaction(tx, notificationId, fileId, description) {
+        await tx.notificationAttachment.create({
+            data: {
+                notificationId,
+                fileId,
+                description: description !== null && description !== void 0 ? description : null,
+            },
+        });
+    }
+    /**
+     * Create notification attachment link (non-transactional)
+     * @private
+     */
+    async createNotificationAttachmentLink(notificationId, fileId, description) {
+        return this.createNotificationAttachmentLinkInTransaction(this.prismaClient, notificationId, fileId, description);
+    }
+    /**
+     * Get attachment file by ID (transaction-aware)
+     * @private
+     */
+    async getAttachmentFileInTransaction(tx, fileId) {
+        const file = await tx.attachmentFile.findUnique({
+            where: { id: fileId },
+        });
+        if (!file)
+            return null;
+        return this.serializeAttachmentFileRecord(file);
+    }
+    /**
+     * Find attachment file by checksum (transaction-aware)
+     * @private
+     */
+    async findAttachmentFileByChecksumInTransaction(tx, checksum) {
+        const file = await tx.attachmentFile.findUnique({
+            where: { checksum },
+        });
+        if (!file)
+            return null;
+        return this.serializeAttachmentFileRecord(file);
+    }
+    /**
+     * Core helper for creating notifications with attachments (both regular and one-off)
+     * Uses transactions to ensure atomicity - if attachment processing fails, the notification won't be created
+     * @private
+     */
+    async createNotificationWithAttachments(input, buildData, serialize) {
+        const { attachments, ...notificationData } = input;
+        // If no attachments, skip transaction overhead
+        if (!attachments || attachments.length === 0) {
+            const created = await this.prismaClient.notification.create({
+                data: buildData(notificationData),
+                include: notificationWithAttachmentsInclude,
+            });
+            return serialize(created);
+        }
+        // Use transaction to ensure atomicity of notification + attachments
+        return await this.prismaClient.$transaction(async (tx) => {
+            const created = await tx.notification.create({
+                data: buildData(notificationData),
+                include: notificationWithAttachmentsInclude,
+            });
+            await this.processAndStoreAttachmentsInTransaction(tx, created.id, attachments);
+            const withAttachments = await tx.notification.findUnique({
+                where: { id: created.id },
+                include: notificationWithAttachmentsInclude,
+            });
+            if (!withAttachments) {
+                throw new Error('Failed to retrieve notification after creating attachments');
+            }
+            return serialize(withAttachments);
+        });
+    }
+    /**
+     * Get attachment manager with null check
+     * @private
+     */
+    getAttachmentManager() {
+        if (!this.attachmentManager) {
+            throw new Error('AttachmentManager is required but not provided');
+        }
+        return this.attachmentManager;
+    }
     deserializeNotification(notification) {
         return this.buildCreateData(notification);
     }
@@ -342,10 +484,7 @@ class PrismaNotificationBackend {
         return notifications.map((n) => this.serializeAnyNotification(n));
     }
     async persistNotification(notification) {
-        const created = await this.prismaClient.notification.create({
-            data: this.deserializeRegularNotification(notification),
-        });
-        return this.serializeRegularNotification(created);
+        return this.createNotificationWithAttachments(notification, (n) => this.deserializeRegularNotification(n), (db) => this.serializeRegularNotification(db));
     }
     async persistNotificationUpdate(notificationId, notification) {
         const updated = await this.prismaClient.notification.update({
@@ -358,10 +497,7 @@ class PrismaNotificationBackend {
     }
     /* One-off notification persistence and query methods */
     async persistOneOffNotification(notification) {
-        const created = await this.prismaClient.notification.create({
-            data: this.buildOneOffNotificationData(notification),
-        });
-        return this.serializeOneOffNotification(created);
+        return this.createNotificationWithAttachments(notification, (n) => this.buildOneOffNotificationData(n), (db) => this.serializeOneOffNotification(db));
     }
     async persistOneOffNotificationUpdate(notificationId, notification) {
         const updated = await this.prismaClient.notification.update({
@@ -460,6 +596,7 @@ class PrismaNotificationBackend {
     async getNotification(notificationId, _forUpdate) {
         const notification = await this.prismaClient.notification.findUnique({
             where: { id: notificationId },
+            include: notificationWithAttachmentsInclude,
         });
         if (!notification)
             return null;
@@ -502,19 +639,158 @@ class PrismaNotificationBackend {
     async storeContextUsed(notificationId, context) {
         await this.prismaClient.notification.update({
             where: { id: notificationId },
-            data: { contextUsed: context }
+            data: { contextUsed: context },
         });
     }
     async bulkPersistNotifications(notifications) {
-        return this.prismaClient.notification.createMany({
+        const created = await this.prismaClient.notification.createManyAndReturn({
             data: notifications.map((notification) => this.deserializeNotification(notification)),
         });
+        return created.map((n) => n.id);
+    }
+    /* Attachment management methods */
+    async getAttachmentFile(fileId) {
+        const file = await this.prismaClient.attachmentFile.findUnique({
+            where: { id: fileId },
+        });
+        if (!file)
+            return null;
+        return this.serializeAttachmentFileRecord(file);
+    }
+    /**
+     * Find an attachment file by checksum for deduplication.
+     * This allows the backend to check if a file already exists before uploading.
+     */
+    async findAttachmentFileByChecksum(checksum) {
+        const file = await this.prismaClient.attachmentFile.findUnique({
+            where: { checksum },
+        });
+        if (!file)
+            return null;
+        return this.serializeAttachmentFileRecord(file);
+    }
+    async deleteAttachmentFile(fileId) {
+        const file = await this.prismaClient.attachmentFile.findUnique({
+            where: { id: fileId },
+        });
+        // If there's no DB record, there's nothing to delete
+        if (!file)
+            return;
+        // First delete the underlying stored file so DB and storage stay in sync
+        const manager = this.getAttachmentManager();
+        await manager.deleteFile(fileId);
+        // Only after successful storage deletion, remove the DB record
+        await this.prismaClient.attachmentFile.delete({
+            where: { id: fileId },
+        });
+    }
+    async getOrphanedAttachmentFiles() {
+        const orphanedFiles = await this.prismaClient.attachmentFile.findMany({
+            where: {
+                notificationAttachments: { none: {} },
+            },
+        });
+        return orphanedFiles.map((file) => this.serializeAttachmentFileRecord(file));
+    }
+    async getAttachments(notificationId) {
+        const attachments = await this.prismaClient.notificationAttachment.findMany({
+            where: { notificationId },
+            include: { attachmentFile: true },
+        });
+        this.getAttachmentManager(); // Validate attachment manager exists
+        return attachments.map((att) => this.serializeStoredAttachment(att));
+    }
+    async deleteNotificationAttachment(notificationId, attachmentId) {
+        const result = await this.prismaClient.notificationAttachment.deleteMany({
+            where: {
+                id: attachmentId,
+                notificationId,
+            },
+        });
+        if (result.count === 0) {
+            throw new Error(`Attachment ${attachmentId} not found for notification ${notificationId}`);
+        }
+    }
+    /**
+     * Process and store attachments for a notification within a transaction.
+     * Handles both new file uploads and references to existing files.
+     * Uses attachmentManager for checksum calculation and storage operations.
+     * @private
+     */
+    async processAndStoreAttachmentsInTransaction(tx, notificationId, attachments) {
+        this.getAttachmentManager(); // Validate attachment manager exists
+        // Process each attachment
+        for (const att of attachments) {
+            if ((0, attachment_1.isAttachmentReference)(att)) {
+                // Reference existing file - just create the notification link
+                const fileRecord = await this.getAttachmentFileInTransaction(tx, att.fileId);
+                if (!fileRecord) {
+                    throw new Error(`Referenced file ${att.fileId} not found`);
+                }
+                await this.createNotificationAttachmentLinkInTransaction(tx, notificationId, att.fileId, att.description);
+            }
+            else {
+                // Upload new file with deduplication
+                const fileRecord = await this.getOrCreateFileRecordForUploadInTransaction(tx, att);
+                await this.createNotificationAttachmentLinkInTransaction(tx, notificationId, fileRecord.id, att.description);
+            }
+        }
+    }
+    /**
+     * Process and store attachments for a notification (non-transactional version).
+     * Handles both new file uploads and references to existing files.
+     * Uses attachmentManager for checksum calculation and storage operations.
+     * @private
+     */
+    async processAndStoreAttachments(notificationId, attachments) {
+        return this.processAndStoreAttachmentsInTransaction(this.prismaClient, notificationId, attachments);
+    }
+    /**
+     * Serialize a Prisma attachment file model to AttachmentFileRecord
+     * @private
+     */
+    serializeAttachmentFileRecord(file) {
+        return {
+            id: file.id,
+            filename: file.filename,
+            contentType: file.contentType,
+            size: file.size,
+            checksum: file.checksum,
+            storageMetadata: file.storageMetadata,
+            createdAt: file.createdAt,
+            updatedAt: file.updatedAt,
+        };
+    }
+    /**
+     * Serialize a Prisma notification attachment model to StoredAttachment
+     * @private
+     */
+    serializeStoredAttachment(attachment) {
+        var _a;
+        const manager = this.getAttachmentManager();
+        if (!attachment.attachmentFile) {
+            throw new Error('AttachmentFile is required to reconstruct stored attachment');
+        }
+        const fileRecord = this.serializeAttachmentFileRecord(attachment.attachmentFile);
+        const attachmentFile = manager.reconstructAttachmentFile(fileRecord.storageMetadata);
+        return {
+            id: attachment.id,
+            fileId: attachment.fileId,
+            filename: fileRecord.filename,
+            contentType: fileRecord.contentType,
+            size: fileRecord.size,
+            checksum: fileRecord.checksum,
+            createdAt: attachment.createdAt,
+            file: attachmentFile,
+            description: (_a = attachment.description) !== null && _a !== void 0 ? _a : undefined,
+            storageMetadata: fileRecord.storageMetadata,
+        };
     }
 }
 exports.PrismaNotificationBackend = PrismaNotificationBackend;
 class PrismaNotificationBackendFactory {
-    create(prismaClient) {
-        return new PrismaNotificationBackend(prismaClient);
+    create(prismaClient, attachmentManager) {
+        return new PrismaNotificationBackend(prismaClient, attachmentManager);
     }
 }
 exports.PrismaNotificationBackendFactory = PrismaNotificationBackendFactory;

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

@@ -1,30 +1,89 @@
 import type { InputJsonValue } from '../../types/json-values';
-import type { DatabaseNotification, Notification, DatabaseOneOffNotification, OneOffNotificationInput, AnyDatabaseNotification } from '../../types/notification';
+import type {
+  AnyDatabaseNotification,
+  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>[]>;
-    getPendingNotifications(page: number, pageSize: number): Promise<AnyDatabaseNotification<Config>[]>;
-    getAllFutureNotifications(): Promise<AnyDatabaseNotification<Config>[]>;
-    getFutureNotifications(page: number, pageSize: number): Promise<AnyDatabaseNotification<Config>[]>;
-    getAllFutureNotificationsFromUser(userId: Config['UserIdType']): Promise<DatabaseNotification<Config>[]>;
-    getFutureNotificationsFromUser(userId: Config['UserIdType'], page: number, pageSize: number): Promise<DatabaseNotification<Config>[]>;
-    persistNotification(notification: Omit<Notification<Config>, 'id'>): Promise<DatabaseNotification<Config>>;
-    getAllNotifications(): Promise<AnyDatabaseNotification<Config>[]>;
-    getNotifications(page: number, pageSize: number): Promise<AnyDatabaseNotification<Config>[]>;
-    bulkPersistNotifications(notifications: Omit<Notification<Config>, 'id'>[]): Promise<Config['NotificationIdType'][]>;
-    persistNotificationUpdate(notificationId: Config['NotificationIdType'], notification: Partial<Omit<Notification<Config>, 'id'>>): Promise<DatabaseNotification<Config>>;
-    markAsSent(notificationId: Config['NotificationIdType'], checkIsPending: boolean): Promise<AnyDatabaseNotification<Config>>;
-    markAsFailed(notificationId: Config['NotificationIdType'], checkIsPending: boolean): Promise<AnyDatabaseNotification<Config>>;
-    markAsRead(notificationId: Config['NotificationIdType'], checkIsSent: boolean): Promise<DatabaseNotification<Config>>;
-    cancelNotification(notificationId: Config['NotificationIdType']): Promise<void>;
-    getNotification(notificationId: Config['NotificationIdType'], forUpdate: boolean): Promise<AnyDatabaseNotification<Config> | null>;
-    filterAllInAppUnreadNotifications(userId: Config['UserIdType']): Promise<DatabaseNotification<Config>[]>;
-    filterInAppUnreadNotifications(userId: Config['UserIdType'], page: number, pageSize: number): Promise<DatabaseNotification<Config>[]>;
-    getUserEmailFromNotification(notificationId: Config['NotificationIdType']): Promise<string | undefined>;
-    storeContextUsed(notificationId: Config['NotificationIdType'], context: InputJsonValue): Promise<void>;
-    persistOneOffNotification(notification: Omit<OneOffNotificationInput<Config>, 'id'>): Promise<DatabaseOneOffNotification<Config>>;
-    persistOneOffNotificationUpdate(notificationId: Config['NotificationIdType'], notification: Partial<Omit<OneOffNotificationInput<Config>, 'id'>>): Promise<DatabaseOneOffNotification<Config>>;
-    getOneOffNotification(notificationId: Config['NotificationIdType'], forUpdate: boolean): Promise<DatabaseOneOffNotification<Config> | null>;
-    getAllOneOffNotifications(): Promise<DatabaseOneOffNotification<Config>[]>;
-    getOneOffNotifications(page: number, pageSize: number): Promise<DatabaseOneOffNotification<Config>[]>;
+  getAllPendingNotifications(): Promise<AnyDatabaseNotification<Config>[]>;
+  getPendingNotifications(
+    page: number,
+    pageSize: number,
+  ): Promise<AnyDatabaseNotification<Config>[]>;
+  getAllFutureNotifications(): Promise<AnyDatabaseNotification<Config>[]>;
+  getFutureNotifications(
+    page: number,
+    pageSize: number,
+  ): Promise<AnyDatabaseNotification<Config>[]>;
+  getAllFutureNotificationsFromUser(
+    userId: Config['UserIdType'],
+  ): Promise<DatabaseNotification<Config>[]>;
+  getFutureNotificationsFromUser(
+    userId: Config['UserIdType'],
+    page: number,
+    pageSize: number,
+  ): Promise<DatabaseNotification<Config>[]>;
+  persistNotification(
+    notification: Omit<Notification<Config>, 'id'>,
+  ): Promise<DatabaseNotification<Config>>;
+  getAllNotifications(): Promise<AnyDatabaseNotification<Config>[]>;
+  getNotifications(page: number, pageSize: number): Promise<AnyDatabaseNotification<Config>[]>;
+  bulkPersistNotifications(
+    notifications: Omit<Notification<Config>, 'id'>[],
+  ): Promise<Config['NotificationIdType'][]>;
+  persistNotificationUpdate(
+    notificationId: Config['NotificationIdType'],
+    notification: Partial<Omit<Notification<Config>, 'id'>>,
+  ): Promise<DatabaseNotification<Config>>;
+  markAsSent(
+    notificationId: Config['NotificationIdType'],
+    checkIsPending: boolean,
+  ): Promise<AnyDatabaseNotification<Config>>;
+  markAsFailed(
+    notificationId: Config['NotificationIdType'],
+    checkIsPending: boolean,
+  ): Promise<AnyDatabaseNotification<Config>>;
+  markAsRead(
+    notificationId: Config['NotificationIdType'],
+    checkIsSent: boolean,
+  ): Promise<DatabaseNotification<Config>>;
+  cancelNotification(notificationId: Config['NotificationIdType']): Promise<void>;
+  getNotification(
+    notificationId: Config['NotificationIdType'],
+    forUpdate: boolean,
+  ): Promise<AnyDatabaseNotification<Config> | null>;
+  filterAllInAppUnreadNotifications(
+    userId: Config['UserIdType'],
+  ): Promise<DatabaseNotification<Config>[]>;
+  filterInAppUnreadNotifications(
+    userId: Config['UserIdType'],
+    page: number,
+    pageSize: number,
+  ): Promise<DatabaseNotification<Config>[]>;
+  getUserEmailFromNotification(
+    notificationId: Config['NotificationIdType'],
+  ): Promise<string | undefined>;
+  storeContextUsed(
+    notificationId: Config['NotificationIdType'],
+    context: InputJsonValue,
+  ): Promise<void>;
+  persistOneOffNotification(
+    notification: Omit<OneOffNotificationInput<Config>, 'id'>,
+  ): Promise<DatabaseOneOffNotification<Config>>;
+  persistOneOffNotificationUpdate(
+    notificationId: Config['NotificationIdType'],
+    notification: Partial<Omit<OneOffNotificationInput<Config>, 'id'>>,
+  ): Promise<DatabaseOneOffNotification<Config>>;
+  getOneOffNotification(
+    notificationId: Config['NotificationIdType'],
+    forUpdate: boolean,
+  ): Promise<DatabaseOneOffNotification<Config> | null>;
+  getAllOneOffNotifications(): Promise<DatabaseOneOffNotification<Config>[]>;
+  getOneOffNotifications(
+    page: number,
+    pageSize: number,
+  ): Promise<DatabaseOneOffNotification<Config>[]>;
 }

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

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+Object.defineProperty(exports, '__esModule', { value: true });

package/dist/types/identifier.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+Object.defineProperty(exports, '__esModule', { value: true });

package/dist/types/json-values.d.ts

@@ -1,15 +1,19 @@
 export type JsonPrimitive = string | number | boolean | null;
-export interface JsonArray extends Array<JsonValue> {
-}
+export interface JsonArray extends Array<JsonValue> {}
 export type JsonObject = {
-    [Key in string]?: JsonValue;
+  [Key in string]?: JsonValue;
 };
 export type JsonValue = string | number | boolean | JsonObject | JsonArray | null;
 export type InputJsonObject = {
-    readonly [Key in string]?: InputJsonValue | null;
-};
-export interface InputJsonArray extends ReadonlyArray<InputJsonValue | null> {
-}
-export type InputJsonValue = string | number | boolean | InputJsonObject | InputJsonArray | {
-    toJSON(): unknown;
+  readonly [Key in string]?: InputJsonValue | null;
 };
+export interface InputJsonArray extends ReadonlyArray<InputJsonValue | null> {}
+export type InputJsonValue =
+  | string
+  | number
+  | boolean
+  | InputJsonObject
+  | InputJsonArray
+  | {
+      toJSON(): unknown;
+    };

package/dist/types/json-values.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+Object.defineProperty(exports, '__esModule', { value: true });

package/dist/types/notification-context-generators.d.ts

@@ -1,4 +1,6 @@
 import type { JsonObject, JsonPrimitive } from './json-values';
-export interface ContextGenerator<Params extends Record<string, JsonPrimitive> = Record<string, JsonPrimitive>> {
-    generate(params: Params): JsonObject | Promise<JsonObject>;
+export interface ContextGenerator<
+  Params extends Record<string, JsonPrimitive> = Record<string, JsonPrimitive>,
+> {
+  generate(params: Params): JsonObject | Promise<JsonObject>;
 }

package/dist/types/notification-context-generators.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+Object.defineProperty(exports, '__esModule', { value: true });

package/dist/types/notification-status.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+Object.defineProperty(exports, '__esModule', { value: true });

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

@@ -1,7 +1,7 @@
-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;
-    UserIdType: Identifier;
+  ContextMap: Record<string, ContextGenerator>;
+  NotificationIdType: Identifier;
+  UserIdType: Identifier;
 };

package/dist/types/notification-type-config.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+Object.defineProperty(exports, '__esModule', { value: true });

package/dist/types/notification-type.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+Object.defineProperty(exports, '__esModule', { value: true });