@goscribe/server 1.2.0 → 1.3.1

package/dist/lib/notification-service.js

@@ -0,0 +1,473 @@
+import PusherService from './pusher.js';
+export const NotificationType = {
+    GENERAL: 'GENERAL',
+    USER_SIGNED_UP: 'USER_SIGNED_UP',
+    ACCOUNT_DELETION_SCHEDULED: 'ACCOUNT_DELETION_SCHEDULED',
+    ACCOUNT_PERMANENTLY_DELETED: 'ACCOUNT_PERMANENTLY_DELETED',
+    WORKSPACE_INVITE_RECEIVED: 'WORKSPACE_INVITE_RECEIVED',
+    WORKSPACE_INVITE_ACCEPTED: 'WORKSPACE_INVITE_ACCEPTED',
+    WORKSPACE_DELETED: 'WORKSPACE_DELETED',
+    PAYMENT_SUCCEEDED: 'PAYMENT_SUCCEEDED',
+    SUBSCRIPTION_ACTIVATED: 'SUBSCRIPTION_ACTIVATED',
+    SUBSCRIPTION_PAYMENT_SUCCEEDED: 'SUBSCRIPTION_PAYMENT_SUCCEEDED',
+    SUBSCRIPTION_CANCELED: 'SUBSCRIPTION_CANCELED',
+    PAYMENT_FAILED: 'PAYMENT_FAILED',
+    WORKSPACE_ROLE_CHANGED: 'WORKSPACE_ROLE_CHANGED',
+    WORKSPACE_MEMBERSHIP_REMOVED: 'WORKSPACE_MEMBERSHIP_REMOVED',
+    STUDY_GUIDE_COMMENT_ADDED: 'STUDY_GUIDE_COMMENT_ADDED',
+    ARTIFACT_READY: 'ARTIFACT_READY',
+    ARTIFACT_FAILED: 'ARTIFACT_FAILED',
+};
+export function artifactTypeLabel(artifactType) {
+    const map = {
+        STUDY_GUIDE: 'Study guide',
+        FLASHCARD_SET: 'Flashcards',
+        WORKSHEET: 'Worksheet',
+        PODCAST_EPISODE: 'Podcast episode',
+        MEETING_SUMMARY: 'Meeting summary',
+    };
+    return map[artifactType] ?? artifactType;
+}
+export function buildArtifactActionUrl(workspaceId, artifactId, artifactType) {
+    switch (artifactType) {
+        case 'STUDY_GUIDE':
+            return `/workspace/${workspaceId}/study-guide`;
+        case 'FLASHCARD_SET':
+            return `/workspace/${workspaceId}/flashcards`;
+        case 'WORKSHEET':
+            return artifactId
+                ? `/workspace/${workspaceId}/worksheet/${artifactId}`
+                : `/workspace/${workspaceId}/worksheet`;
+        case 'PODCAST_EPISODE':
+            return artifactId
+                ? `/workspace/${workspaceId}/podcasts/${artifactId}`
+                : `/workspace/${workspaceId}/podcasts`;
+        case 'MEETING_SUMMARY':
+            return `/workspace/${workspaceId}`;
+        default:
+            return `/workspace/${workspaceId}`;
+    }
+}
+function extractMentionEmails(text) {
+    const re = /@([a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,})/g;
+    const out = [];
+    let m;
+    while ((m = re.exec(text)) !== null) {
+        out.push(m[1].toLowerCase());
+    }
+    return [...new Set(out)];
+}
+async function resolveUserIdsByEmailsInWorkspace(db, workspaceId, emails) {
+    if (!emails.length)
+        return [];
+    const ids = new Set();
+    for (const raw of emails) {
+        const user = await db.user.findFirst({
+            where: { email: { equals: raw, mode: 'insensitive' }, deletedAt: null },
+            select: { id: true },
+        });
+        if (!user)
+            continue;
+        const member = await db.workspaceMember.findFirst({
+            where: { workspaceId, userId: user.id },
+            select: { id: true },
+        });
+        const owned = await db.workspace.findFirst({
+            where: { id: workspaceId, ownerId: user.id },
+            select: { id: true },
+        });
+        if (member || owned)
+            ids.add(user.id);
+    }
+    return [...ids];
+}
+async function getUnreadCount(db, userId) {
+    return db.notification.count({
+        where: { userId, read: false },
+    });
+}
+export async function createNotification(db, input) {
+    if (input.sourceId) {
+        const existing = await db.notification.findFirst({
+            where: {
+                userId: input.userId,
+                type: input.type,
+                sourceId: input.sourceId,
+            },
+            // Avoid selecting all columns (including drifted optional columns) for idempotency check.
+            select: { id: true },
+        });
+        if (existing) {
+            return existing;
+        }
+    }
+    const created = await db.notification.create({
+        data: {
+            userId: input.userId,
+            actorUserId: input.actorUserId,
+            workspaceId: input.workspaceId,
+            type: input.type,
+            title: input.title,
+            body: input.body,
+            content: input.body,
+            actionUrl: input.actionUrl,
+            metadata: input.metadata,
+            priority: input.priority ?? 'NORMAL',
+            sourceId: input.sourceId,
+        },
+    });
+    const unreadCount = await getUnreadCount(db, input.userId);
+    await PusherService.emitNotificationNew(input.userId, {
+        notificationId: created.id,
+        type: created.type,
+        title: created.title,
+        unreadCount,
+        createdAt: created.createdAt.toISOString(),
+    });
+    return created;
+}
+export async function createManyNotifications(db, inputs) {
+    if (!inputs.length)
+        return [];
+    const created = [];
+    for (const input of inputs) {
+        created.push(await createNotification(db, input));
+    }
+    return created;
+}
+export async function getSystemAdminIds(db) {
+    const admins = await db.user.findMany({
+        where: {
+            role: { name: 'System Admin' },
+            deletedAt: null,
+        },
+        select: { id: true },
+    });
+    return admins.map((admin) => admin.id);
+}
+export async function notifyAdminsOnSignup(db, user) {
+    const adminIds = await getSystemAdminIds(db);
+    if (!adminIds.length)
+        return;
+    const displayName = user.name || user.email || 'New user';
+    await createManyNotifications(db, adminIds.map((adminId) => ({
+        userId: adminId,
+        actorUserId: user.id,
+        type: NotificationType.USER_SIGNED_UP,
+        title: 'New user signed up',
+        body: `${displayName} just created an account.`,
+        actionUrl: '/admin/users',
+        metadata: { newUserId: user.id, email: user.email },
+        sourceId: `signup:${user.id}`,
+        priority: 'NORMAL',
+    })));
+}
+export async function notifyAdminsAccountDeletionScheduled(db, user) {
+    const adminIds = await getSystemAdminIds(db);
+    const targets = adminIds.filter((id) => id !== user.id);
+    if (!targets.length)
+        return;
+    const displayName = user.name || user.email || 'A user';
+    await createManyNotifications(db, targets.map((adminId) => ({
+        userId: adminId,
+        actorUserId: user.id,
+        type: NotificationType.ACCOUNT_DELETION_SCHEDULED,
+        title: `${displayName} scheduled account deletion`,
+        body: 'Their account will be permanently deleted after the grace period unless they restore it.',
+        actionUrl: '/admin/users',
+        metadata: { deletedUserId: user.id, email: user.email },
+        sourceId: `account-deletion-scheduled:${user.id}`,
+        priority: 'HIGH',
+    })));
+}
+export async function notifyAdminsAccountPermanentlyDeleted(db, user) {
+    const adminIds = await getSystemAdminIds(db);
+    const targets = adminIds.filter((id) => id !== user.id);
+    if (!targets.length)
+        return;
+    const displayName = user.name || user.email || 'A user';
+    await createManyNotifications(db, targets.map((adminId) => ({
+        userId: adminId,
+        type: NotificationType.ACCOUNT_PERMANENTLY_DELETED,
+        title: `${displayName} permanently deleted`,
+        body: 'Their account and data have been removed after the grace period.',
+        actionUrl: '/admin/users',
+        metadata: { deletedUserId: user.id, email: user.email },
+        sourceId: `account-purged:${user.id}`,
+        priority: 'HIGH',
+    })));
+}
+export async function notifyInviteRecipient(db, input) {
+    await createNotification(db, {
+        userId: input.invitedUserId,
+        actorUserId: input.inviterUserId,
+        workspaceId: input.workspaceId,
+        type: NotificationType.WORKSPACE_INVITE_RECEIVED,
+        title: 'Workspace invite received',
+        body: `${input.inviterName || 'A teammate'} invited you to join "${input.workspaceTitle}".`,
+        actionUrl: `/accept-invite?token=${encodeURIComponent(input.invitationToken)}`,
+        metadata: {
+            workspaceId: input.workspaceId,
+            workspaceName: input.workspaceTitle,
+            invitationId: input.invitationId,
+            inviterUserId: input.inviterUserId,
+        },
+        sourceId: `invite:${input.invitationId}`,
+    });
+}
+export async function notifyInviteAccepted(db, input) {
+    const uniqueRecipients = Array.from(new Set(input.recipientUserIds.filter(Boolean)));
+    await createManyNotifications(db, uniqueRecipients.map((userId) => ({
+        userId,
+        actorUserId: input.actorUserId,
+        workspaceId: input.workspaceId,
+        type: NotificationType.WORKSPACE_INVITE_ACCEPTED,
+        title: 'Workspace invite accepted',
+        body: `${input.memberName || 'A user'} joined "${input.workspaceTitle}".`,
+        actionUrl: `/workspace/${input.workspaceId}`,
+        metadata: {
+            workspaceId: input.workspaceId,
+            workspaceTitle: input.workspaceTitle,
+            invitationId: input.invitationId,
+        },
+        sourceId: `invite-accepted:${input.invitationId}:${userId}`,
+    })));
+}
+export async function notifyWorkspaceDeleted(db, input) {
+    const uniqueRecipients = Array.from(new Set(input.recipientUserIds.filter((id) => id && id !== input.actorUserId)));
+    if (!uniqueRecipients.length)
+        return;
+    await createManyNotifications(db, uniqueRecipients.map((userId) => ({
+        userId,
+        actorUserId: input.actorUserId,
+        workspaceId: input.workspaceId,
+        type: NotificationType.WORKSPACE_DELETED,
+        title: `${input.actorName} deleted workspace`,
+        body: `"${input.workspaceTitle}" was deleted.`,
+        actionUrl: '/storage',
+        metadata: {
+            workspaceId: input.workspaceId,
+            workspaceTitle: input.workspaceTitle,
+            actorName: input.actorName,
+        },
+        sourceId: `workspace-deleted:${input.workspaceId}:${userId}`,
+        priority: 'HIGH',
+    })));
+}
+async function createBillingNotificationsForUserAndAdmins(db, input) {
+    await createNotification(db, input);
+    const adminIds = await getSystemAdminIds(db);
+    const adminTargets = adminIds.filter((id) => id !== input.userId);
+    if (!adminTargets.length)
+        return;
+    await createManyNotifications(db, adminTargets.map((adminId) => ({
+        userId: adminId,
+        actorUserId: input.userId,
+        workspaceId: input.workspaceId,
+        type: input.type,
+        title: input.adminTitle || input.title,
+        body: input.adminBody,
+        actionUrl: '/admin/users',
+        metadata: input.metadata,
+        priority: input.priority,
+        sourceId: input.sourceId ? `${input.sourceId}:admin:${adminId}` : undefined,
+    })));
+}
+export async function notifyPaymentSucceeded(db, input) {
+    const planLabel = input.planName || 'selected plan';
+    await createBillingNotificationsForUserAndAdmins(db, {
+        userId: input.userId,
+        type: NotificationType.PAYMENT_SUCCEEDED,
+        title: 'Payment successful',
+        adminTitle: 'User payment successful',
+        body: `Your payment succeeded for ${planLabel}.`,
+        adminBody: `A user completed a successful payment for ${planLabel}.`,
+        actionUrl: '/settings',
+        metadata: {
+            planId: input.planId,
+            planName: input.planName,
+            stripeSessionId: input.stripeSessionId,
+            amountPaid: input.amountPaid,
+        },
+        sourceId: input.stripeSessionId ? `checkout:${input.stripeSessionId}` : undefined,
+    });
+}
+export async function notifySubscriptionActivated(db, input) {
+    const planLabel = input.planName || 'your plan';
+    await createBillingNotificationsForUserAndAdmins(db, {
+        userId: input.userId,
+        type: NotificationType.SUBSCRIPTION_ACTIVATED,
+        title: `You subscribed to ${planLabel}`,
+        adminTitle: `User subscribed to ${planLabel}`,
+        body: `Your ${planLabel} subscription is active.`,
+        adminBody: `A user started a ${planLabel} subscription.`,
+        actionUrl: '/settings',
+        metadata: {
+            planId: input.planId,
+            planName: input.planName,
+            stripeSubscriptionId: input.stripeSubscriptionId,
+        },
+        sourceId: `subscription-created:${input.stripeSubscriptionId}`,
+    });
+}
+export async function notifySubscriptionPaymentSucceeded(db, input) {
+    const planLabel = input.planName || 'subscription';
+    await createBillingNotificationsForUserAndAdmins(db, {
+        userId: input.userId,
+        type: NotificationType.SUBSCRIPTION_PAYMENT_SUCCEEDED,
+        title: 'Subscription payment successful',
+        adminTitle: 'User subscription payment successful',
+        body: `Your ${planLabel} payment was successful.`,
+        adminBody: `A user successfully paid for ${planLabel}.`,
+        actionUrl: '/settings',
+        metadata: {
+            planId: input.planId,
+            planName: input.planName,
+            stripeInvoiceId: input.stripeInvoiceId,
+            amountPaid: input.amountPaid,
+        },
+        sourceId: `invoice-paid:${input.stripeInvoiceId}`,
+    });
+}
+export async function notifySubscriptionCanceled(db, input) {
+    const planLabel = input.planName || 'subscription';
+    await createBillingNotificationsForUserAndAdmins(db, {
+        userId: input.userId,
+        type: NotificationType.SUBSCRIPTION_CANCELED,
+        title: 'Subscription canceled',
+        adminTitle: 'User subscription canceled',
+        body: `Your ${planLabel} subscription was canceled.`,
+        adminBody: `A user canceled ${planLabel}.`,
+        actionUrl: '/settings',
+        metadata: {
+            planId: input.planId,
+            planName: input.planName,
+            stripeSubscriptionId: input.stripeSubscriptionId,
+        },
+        sourceId: `subscription-canceled:${input.stripeSubscriptionId}`,
+        priority: 'HIGH',
+    });
+}
+export async function notifyPaymentFailed(db, input) {
+    const planLabel = input.planName || 'payment';
+    const sourceId = input.stripeInvoiceId
+        ? `invoice-failed:${input.stripeInvoiceId}`
+        : input.stripePaymentIntentId
+            ? `pi-failed:${input.stripePaymentIntentId}`
+            : undefined;
+    await createBillingNotificationsForUserAndAdmins(db, {
+        userId: input.userId,
+        type: NotificationType.PAYMENT_FAILED,
+        title: 'Payment failed',
+        adminTitle: 'User payment failed',
+        body: `Your ${planLabel} payment failed. Please update billing and retry.`,
+        adminBody: `A user payment failed for ${planLabel}.`,
+        actionUrl: '/settings',
+        metadata: {
+            planId: input.planId,
+            planName: input.planName,
+            stripeInvoiceId: input.stripeInvoiceId,
+            stripePaymentIntentId: input.stripePaymentIntentId,
+        },
+        sourceId,
+        priority: 'HIGH',
+    });
+}
+export async function notifyWorkspaceRoleChanged(db, input) {
+    const roleLabel = input.newRole === 'admin' ? 'admin' : 'member';
+    const oldLabel = input.oldRole === 'admin' ? 'admin' : 'member';
+    await createNotification(db, {
+        userId: input.memberUserId,
+        actorUserId: input.actorUserId,
+        workspaceId: input.workspaceId,
+        type: NotificationType.WORKSPACE_ROLE_CHANGED,
+        title: `Your role in "${input.workspaceTitle}" changed`,
+        body: `${input.actorName} changed your role from ${oldLabel} to ${roleLabel}.`,
+        actionUrl: `/workspace/${input.workspaceId}/members`,
+        metadata: {
+            oldRole: input.oldRole,
+            newRole: input.newRole,
+            workspaceTitle: input.workspaceTitle,
+        },
+        priority: 'NORMAL',
+    });
+}
+export async function notifyWorkspaceMembershipRemoved(db, input) {
+    await createNotification(db, {
+        userId: input.memberUserId,
+        actorUserId: input.actorUserId,
+        workspaceId: input.workspaceId,
+        type: NotificationType.WORKSPACE_MEMBERSHIP_REMOVED,
+        title: `Removed from "${input.workspaceTitle}"`,
+        body: `${input.actorName} removed you from this workspace.`,
+        actionUrl: '/storage',
+        metadata: { workspaceTitle: input.workspaceTitle },
+        priority: 'HIGH',
+    });
+}
+export async function notifyStudyGuideCommentAdded(db, input) {
+    const mentionEmails = extractMentionEmails(input.content);
+    const mentionUserIds = await resolveUserIdsByEmailsInWorkspace(db, input.workspaceId, mentionEmails);
+    const combined = new Set([
+        ...input.recipientUserIds.filter(Boolean),
+        ...mentionUserIds,
+    ]);
+    combined.delete(input.authorUserId);
+    const targets = [...combined];
+    if (!targets.length)
+        return;
+    const preview = input.content.length > 140
+        ? `${input.content.slice(0, 137)}...`
+        : input.content;
+    await createManyNotifications(db, targets.map((userId) => ({
+        userId,
+        actorUserId: input.authorUserId,
+        workspaceId: input.workspaceId,
+        type: NotificationType.STUDY_GUIDE_COMMENT_ADDED,
+        title: `${input.authorName} commented on "${input.artifactTitle}"`,
+        body: preview,
+        actionUrl: `/workspace/${input.workspaceId}/study-guide`,
+        metadata: {
+            artifactId: input.artifactId,
+            highlightId: input.highlightId,
+            commentId: input.commentId,
+        },
+        sourceId: `comment:${input.commentId}:${userId}`,
+    })));
+}
+export async function notifyArtifactReady(db, input) {
+    const kind = artifactTypeLabel(input.artifactType);
+    await createNotification(db, {
+        userId: input.userId,
+        workspaceId: input.workspaceId,
+        type: NotificationType.ARTIFACT_READY,
+        title: `${kind} ready`,
+        body: `"${input.title}" is ready to open.`,
+        actionUrl: buildArtifactActionUrl(input.workspaceId, input.artifactId, input.artifactType),
+        metadata: {
+            artifactId: input.artifactId,
+            artifactType: input.artifactType,
+        },
+        sourceId: `artifact-ready:${input.artifactId}`,
+        priority: 'NORMAL',
+    });
+}
+export async function notifyArtifactFailed(db, input) {
+    const kind = artifactTypeLabel(input.artifactType);
+    await createNotification(db, {
+        userId: input.userId,
+        workspaceId: input.workspaceId,
+        type: NotificationType.ARTIFACT_FAILED,
+        title: `${kind} generation failed`,
+        body: input.message,
+        actionUrl: buildArtifactActionUrl(input.workspaceId, input.artifactId, input.artifactType),
+        metadata: {
+            artifactId: input.artifactId,
+            artifactType: input.artifactType,
+        },
+        sourceId: input.artifactId
+            ? `artifact-failed:${input.artifactId}`
+            : undefined,
+        priority: 'HIGH',
+    });
+}

package/dist/lib/notification-service.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/notification-service.test.js

@@ -0,0 +1,87 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import PusherService from './pusher.js';
+import { NotificationType, createNotification } from './notification-service.js';
+function createFakeDb() {
+    const store = [];
+    const db = {
+        notification: {
+            async findFirst(args) {
+                const where = args?.where ?? {};
+                return (store.find((item) => {
+                    if (where.userId && item.userId !== where.userId)
+                        return false;
+                    if (where.type && item.type !== where.type)
+                        return false;
+                    if (where.sourceId && item.sourceId !== where.sourceId)
+                        return false;
+                    return true;
+                }) ?? null);
+            },
+            async create(args) {
+                const data = args.data;
+                const item = {
+                    id: `n_${store.length + 1}`,
+                    userId: data.userId,
+                    type: data.type,
+                    title: data.title,
+                    body: data.body,
+                    content: data.content,
+                    sourceId: data.sourceId,
+                    createdAt: new Date(),
+                    read: false,
+                };
+                store.push(item);
+                return item;
+            },
+            async count(args) {
+                const where = args?.where ?? {};
+                return store.filter((item) => {
+                    if (where.userId && item.userId !== where.userId)
+                        return false;
+                    if (where.read !== undefined && item.read !== where.read)
+                        return false;
+                    return true;
+                }).length;
+            },
+        },
+    };
+    return { db, store };
+}
+test('createNotification deduplicates by sourceId', async () => {
+    const { db, store } = createFakeDb();
+    const originalEmit = PusherService.emitNotificationNew;
+    PusherService.emitNotificationNew = async () => { };
+    await createNotification(db, {
+        userId: 'u1',
+        type: NotificationType.PAYMENT_SUCCEEDED,
+        title: 'Payment successful',
+        body: 'Paid',
+        sourceId: 'source-1',
+    });
+    await createNotification(db, {
+        userId: 'u1',
+        type: NotificationType.PAYMENT_SUCCEEDED,
+        title: 'Payment successful',
+        body: 'Paid',
+        sourceId: 'source-1',
+    });
+    assert.equal(store.length, 1);
+    PusherService.emitNotificationNew = originalEmit;
+});
+test('createNotification emits unread count payload', async () => {
+    const { db } = createFakeDb();
+    const originalEmit = PusherService.emitNotificationNew;
+    let capturedUnread = -1;
+    PusherService.emitNotificationNew = async (_userId, payload) => {
+        capturedUnread = payload.unreadCount;
+    };
+    await createNotification(db, {
+        userId: 'u1',
+        type: NotificationType.GENERAL,
+        title: 'Hello',
+        body: 'World',
+    });
+    assert.equal(capturedUnread, 1);
+    PusherService.emitNotificationNew = originalEmit;
+});

package/dist/lib/prisma.d.ts

@@ -1,2 +1,3 @@
-import { PrismaClient } from "@prisma/client";
+import { PrismaClient } from "../../node_modules/.prisma/client/index.js";
+export { ArtifactType } from "../../node_modules/.prisma/client/index.js";
 export declare const prisma: PrismaClient<import("@prisma/client").Prisma.PrismaClientOptions, never, import("@prisma/client/runtime/library").DefaultArgs>;

package/dist/lib/prisma.js

@@ -1,4 +1,8 @@
-import { PrismaClient } from "@prisma/client";
+// Resolve the client from this package's generated output so types always match
+// `prisma/schema.prisma` (the `@prisma/client` entry can resolve to a different
+// generated client in multi-folder workspaces and lose model delegates in the IDE).
+import { PrismaClient } from "../../node_modules/.prisma/client/index.js";
+export { ArtifactType } from "../../node_modules/.prisma/client/index.js";
 const globalForPrisma = globalThis;
 export const prisma = globalForPrisma.prisma ??
     new PrismaClient({

package/dist/lib/pusher.d.ts

@@ -1,15 +1,38 @@
 import Pusher from 'pusher';
 export declare const pusher: Pusher;
 export declare class PusherService {
+    static emitUserEvent(userId: string, eventName: string, data: any): Promise<void>;
     static emitTaskComplete(workspaceId: string, event: string, data: any): Promise<void>;
     static emitAnalysisComplete(workspaceId: string, analysisType: string, result: any): Promise<void>;
     static emitStudyGuideComplete(workspaceId: string, artifact: any): Promise<void>;
     static emitFlashcardComplete(workspaceId: string, artifact: any): Promise<void>;
     static emitWorksheetComplete(workspaceId: string, artifact: any): Promise<void>;
+    static emitWorksheetGenerationStart(workspaceId: string): Promise<void>;
+    static emitWorksheetNew(workspaceId: string, worksheet: any): Promise<void>;
+    static emitWorksheetGenerationComplete(workspaceId: string, worksheet: any): Promise<void>;
     static emitPodcastComplete(workspaceId: string, artifact: any): Promise<void>;
     static emitOverallComplete(workspaceId: string, filename: string, artifacts: any): Promise<void>;
     static emitError(workspaceId: string, error: string, analysisType?: string): Promise<void>;
     static emitAnalysisProgress(workspaceId: string, progress: any): Promise<void>;
     static emitChannelEvent(channelId: string, event: string, data: any): Promise<void>;
+    static emitMemberJoined(workspaceId: string, member: any): Promise<void>;
+    static emitProfileUpdate(userId: string): Promise<void>;
+    static emitLibraryUpdate(userId: string): Promise<void>;
+    static emitNotificationNew(userId: string, data: {
+        notificationId: string;
+        type: string;
+        title: string;
+        unreadCount: number;
+        createdAt: string;
+    }): Promise<void>;
+    static emitNotificationReadState(userId: string, data: {
+        unreadCount: number;
+        timestamp?: string;
+    }): Promise<void>;
+    static emitPaymentSuccess(userId: string, data: {
+        type: 'topup' | 'subscription';
+        resourceType?: string;
+        quantity?: string;
+    }): Promise<void>;
 }
 export default PusherService;