@goscribe/server 1.3.4 → 1.5.0

package/dist/lib/usage_service.js

@@ -1,4 +1,13 @@
 import { prisma } from './prisma.js';
+const FALLBACK_PLAN_LIMITS = {
+    id: 'fallback-free',
+    planId: 'fallback-free',
+    maxStorageBytes: BigInt(1024 * 1024 * 1024), // 1GB
+    maxWorksheets: 3,
+    maxFlashcards: 20,
+    maxPodcasts: 0,
+    maxStudyGuides: 1,
+};
 /**
  * Counts all resources consumed by a user across the platform.
  */
@@ -26,34 +35,43 @@ export async function getUserUsage(userId) {
  * PLUS any extra credits purchased.
  */
 export async function getUserPlanLimits(userId) {
-    const [activeSub, userCredits] = await Promise.all([
+    const [activeSub, freePlan, userCredits] = await Promise.all([
         prisma.subscription.findFirst({
             where: { userId, status: 'active' },
             include: { plan: { include: { limit: true } } },
             orderBy: { createdAt: 'desc' }
         }),
+        prisma.plan.findFirst({
+            where: {
+                active: true,
+                price: 0,
+                limit: { isNot: null }
+            },
+            include: { limit: true },
+            orderBy: { createdAt: 'asc' }
+        }),
         prisma.userCredit.groupBy({
             by: ['resourceType'],
             where: { userId },
             _sum: { amount: true }
         })
     ]);
-    const baseLimit = activeSub?.plan?.limit;
-    // If no active subscription and no credits, user has no active limits
-    if (!baseLimit && userCredits.length === 0)
-        return null;
+    const baseLimit = activeSub?.plan?.limit ?? freePlan?.limit;
+    // Prefer subscription limits, then DB free-plan limits, then hardcoded safety fallback.
+    const base = baseLimit ?? FALLBACK_PLAN_LIMITS;
     // Fast lookup for credits
     const getCreditSum = (type) => userCredits.find(c => c.resourceType === type)?._sum.amount || 0;
     // Return the merged total limit
     return {
-        id: baseLimit?.id || 'credits-only',
-        planId: baseLimit?.planId || 'credits-only',
-        maxStorageBytes: BigInt(Number(baseLimit?.maxStorageBytes || 0) + (getCreditSum('STORAGE') * 1024 * 1024)),
-        maxWorksheets: (baseLimit?.maxWorksheets || 0) + getCreditSum('WORKSHEET'),
-        maxFlashcards: (baseLimit?.maxFlashcards || 0) + getCreditSum('FLASHCARD_SET'),
-        maxPodcasts: (baseLimit?.maxPodcasts || 0) + getCreditSum('PODCAST_EPISODE'),
-        maxStudyGuides: (baseLimit?.maxStudyGuides || 0) + getCreditSum('STUDY_GUIDE'),
+        id: base.id,
+        planId: base.planId,
+        maxStorageBytes: BigInt(Number(base.maxStorageBytes) + (getCreditSum('STORAGE') * 1024 * 1024)),
+        maxWorksheets: base.maxWorksheets + getCreditSum('WORKSHEET'),
+        maxFlashcards: base.maxFlashcards + getCreditSum('FLASHCARD_SET'),
+        maxPodcasts: base.maxPodcasts + getCreditSum('PODCAST_EPISODE'),
+        maxStudyGuides: base.maxStudyGuides + getCreditSum('STUDY_GUIDE'),
         createdAt: baseLimit?.createdAt || new Date(),
         updatedAt: baseLimit?.updatedAt || new Date(),
+        isFallbackPlan: !baseLimit,
     };
 }

package/dist/lib/worksheet-generation.js

@@ -26,16 +26,16 @@ export function parsePresetConfig(raw) {
     return worksheetPresetConfigSchema.parse(raw);
 }
 export function mergeWorksheetGenerationConfig(presetConfig, configOverride, legacy) {
-    // Precedence: legacy flat fields > configOverride > preset > defaults
-    // We place legacy AFTER configOverride because configOverride's Zod partial schema injects defaults (like medium) 
-    // that shouldn't overwrite explicit explicit user choices passing via legacy parameters.
+    // Precedence: configOverride > legacy flat fields > preset > defaults.
+    // An explicit configOverride from the caller always wins over the router's
+    // legacy top-level fields (which have zod defaults like 'medium').
     const merged = {
         ...defaultConfig,
         ...presetConfig,
-        ...configOverride,
         ...(legacy.numQuestions !== undefined ? { numQuestions: legacy.numQuestions } : {}),
         ...(legacy.difficulty !== undefined ? { difficulty: legacy.difficulty } : {}),
         ...(legacy.mode !== undefined ? { mode: legacy.mode } : {}),
+        ...configOverride,
     };
     return worksheetPresetConfigSchema.parse(merged);
 }

package/dist/lib/worksheet-generation.test.js

@@ -1,20 +1,35 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
+import { describe, it, expect } from 'vitest';
 import { mergeWorksheetGenerationConfig, normalizeWorksheetProblemForDb } from './worksheet-generation.js';
-test('mergeWorksheetGenerationConfig: override beats preset and legacy', () => {
-    const r = mergeWorksheetGenerationConfig({ mode: 'practice', numQuestions: 5, difficulty: 'easy' }, { mode: 'quiz', numQuestions: 10, difficulty: 'medium' }, { numQuestions: 3, difficulty: 'hard' });
-    assert.equal(r.mode, 'quiz');
-    assert.equal(r.numQuestions, 10);
-    assert.equal(r.difficulty, 'medium');
+describe('mergeWorksheetGenerationConfig', () => {
+    it('override beats preset and legacy', () => {
+        const r = mergeWorksheetGenerationConfig({ mode: 'practice', numQuestions: 5, difficulty: 'easy' }, { mode: 'quiz', numQuestions: 10, difficulty: 'medium' }, { numQuestions: 3, difficulty: 'hard' });
+        expect(r.mode).toBe('quiz');
+        expect(r.numQuestions).toBe(10);
+        expect(r.difficulty).toBe('medium');
+    });
+    it('legacy beats preset when no override', () => {
+        const r = mergeWorksheetGenerationConfig({ mode: 'practice', numQuestions: 5, difficulty: 'easy' }, undefined, { numQuestions: 7, difficulty: 'hard' });
+        expect(r.numQuestions).toBe(7);
+        expect(r.difficulty).toBe('hard');
+        expect(r.mode).toBe('practice');
+    });
+    it('preset supplies defaults when override and legacy absent', () => {
+        const r = mergeWorksheetGenerationConfig({ mode: 'quiz', numQuestions: 5, difficulty: 'easy' }, undefined, {});
+        expect(r.mode).toBe('quiz');
+        expect(r.numQuestions).toBe(5);
+        expect(r.difficulty).toBe('easy');
+    });
 });
-test('normalizeWorksheetProblemForDb coerces MCQ answer to option index', () => {
-    const row = normalizeWorksheetProblemForDb({
-        question: 'Capital of France?',
-        answer: 'Paris',
-        type: 'MULTIPLE_CHOICE',
-        options: ['London', 'Paris', 'Berlin'],
-    }, 0, 'MEDIUM', true);
-    assert.equal(row.type, 'MULTIPLE_CHOICE');
-    assert.equal(row.answer, '1');
-    assert.ok(row.meta.options && row.meta.options.length >= 2);
+describe('normalizeWorksheetProblemForDb', () => {
+    it('coerces MCQ answer to option index', () => {
+        const row = normalizeWorksheetProblemForDb({
+            question: 'Capital of France?',
+            answer: 'Paris',
+            type: 'MULTIPLE_CHOICE',
+            options: ['London', 'Paris', 'Berlin'],
+        }, 0, 'MEDIUM', true);
+        expect(row.type).toBe('MULTIPLE_CHOICE');
+        expect(row.answer).toBe('1');
+        expect(row.meta.options?.length).toBeGreaterThanOrEqual(2);
+    });
 });

package/dist/lib/workspace-kb.d.ts

@@ -0,0 +1,5 @@
+/** Meta.kind value for the private, auto-managed KB attached to each workspace. */
+export declare const WORKSPACE_KB_KIND = "workspace";
+export declare function isWorkspaceManagedKb(kb: {
+    meta: unknown;
+}): boolean;

package/dist/lib/workspace-kb.js

@@ -0,0 +1,7 @@
+/** Meta.kind value for the private, auto-managed KB attached to each workspace. */
+export const WORKSPACE_KB_KIND = 'workspace';
+export function isWorkspaceManagedKb(kb) {
+    if (!kb.meta || typeof kb.meta !== 'object')
+        return false;
+    return kb.meta.kind === WORKSPACE_KB_KIND;
+}

package/dist/models/controller-context.model.d.ts

@@ -0,0 +1,8 @@
+import type { Context } from '../context.js';
+export interface ControllerContext {
+    ctx: Context;
+}
+export interface Controller<Input, Output> {
+    execute(input: Input, context: ControllerContext): Promise<Output> | Output;
+}
+export type TrpcRouterModule = Record<string, unknown>;

package/dist/models/controller-context.model.js

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

package/dist/repositories/artifact.repository.d.ts

@@ -0,0 +1,60 @@
+import type { ArtifactType, Prisma, PrismaClient } from '@prisma/client';
+import { BaseRepository } from './base.repository.js';
+export declare class ArtifactRepository extends BaseRepository {
+    constructor(db: PrismaClient);
+    /**
+     * Fetch an artifact if the user can access the containing workspace
+     * (owner or member).
+     */
+    findByIdAccessible(artifactId: string, userId: string, include?: Prisma.ArtifactInclude): Prisma.Prisma__ArtifactClient<{
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        workspaceId: string;
+        type: import("@prisma/client").$Enums.ArtifactType;
+        title: string;
+        isArchived: boolean;
+        difficulty: import("@prisma/client").$Enums.Difficulty | null;
+        estimatedTime: string | null;
+        createdById: string | null;
+        description: string | null;
+        generating: boolean;
+        generatingMetadata: Prisma.JsonValue | null;
+        worksheetConfig: Prisma.JsonValue | null;
+        imageObjectKey: string | null;
+    } | null, null, import("@prisma/client/runtime/library").DefaultArgs, Prisma.PrismaClientOptions>;
+    findByIdAndTypeAccessible(artifactId: string, type: ArtifactType, userId: string, include?: Prisma.ArtifactInclude): Prisma.Prisma__ArtifactClient<{
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        workspaceId: string;
+        type: import("@prisma/client").$Enums.ArtifactType;
+        title: string;
+        isArchived: boolean;
+        difficulty: import("@prisma/client").$Enums.Difficulty | null;
+        estimatedTime: string | null;
+        createdById: string | null;
+        description: string | null;
+        generating: boolean;
+        generatingMetadata: Prisma.JsonValue | null;
+        worksheetConfig: Prisma.JsonValue | null;
+        imageObjectKey: string | null;
+    } | null, null, import("@prisma/client/runtime/library").DefaultArgs, Prisma.PrismaClientOptions>;
+    listByWorkspaceAndType(workspaceId: string, type: ArtifactType, userId: string, args?: Omit<Prisma.ArtifactFindManyArgs, 'where'>): Prisma.PrismaPromise<{
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        workspaceId: string;
+        type: import("@prisma/client").$Enums.ArtifactType;
+        title: string;
+        isArchived: boolean;
+        difficulty: import("@prisma/client").$Enums.Difficulty | null;
+        estimatedTime: string | null;
+        createdById: string | null;
+        description: string | null;
+        generating: boolean;
+        generatingMetadata: Prisma.JsonValue | null;
+        worksheetConfig: Prisma.JsonValue | null;
+        imageObjectKey: string | null;
+    }[]>;
+}

package/dist/repositories/artifact.repository.js

@@ -0,0 +1,40 @@
+import { BaseRepository } from './base.repository.js';
+import { workspaceAccessWhere } from './workspace.repository.js';
+export class ArtifactRepository extends BaseRepository {
+    constructor(db) {
+        super(db);
+    }
+    /**
+     * Fetch an artifact if the user can access the containing workspace
+     * (owner or member).
+     */
+    findByIdAccessible(artifactId, userId, include) {
+        return this.db.artifact.findFirst({
+            where: {
+                id: artifactId,
+                workspace: workspaceAccessWhere(userId),
+            },
+            include,
+        });
+    }
+    findByIdAndTypeAccessible(artifactId, type, userId, include) {
+        return this.db.artifact.findFirst({
+            where: {
+                id: artifactId,
+                type,
+                workspace: workspaceAccessWhere(userId),
+            },
+            include,
+        });
+    }
+    listByWorkspaceAndType(workspaceId, type, userId, args) {
+        return this.db.artifact.findMany({
+            ...args,
+            where: {
+                workspaceId,
+                type,
+                workspace: workspaceAccessWhere(userId),
+            },
+        });
+    }
+}

package/dist/repositories/base.repository.d.ts

@@ -0,0 +1,14 @@
+import type { PrismaClient } from '@prisma/client';
+import { logger } from '../lib/logger.js';
+/**
+ * Shared base class for repositories.
+ *
+ * Repositories own data access. They wrap a Prisma client and expose
+ * intent-revealing methods (e.g. `findAccessibleById(workspaceId, userId)`)
+ * so that the shape of `where` clauses doesn't leak into services/routers.
+ */
+export declare abstract class BaseRepository {
+    protected readonly db: PrismaClient;
+    protected readonly logger: typeof logger;
+    constructor(db: PrismaClient);
+}

package/dist/repositories/base.repository.js

@@ -0,0 +1,14 @@
+import { logger } from '../lib/logger.js';
+/**
+ * Shared base class for repositories.
+ *
+ * Repositories own data access. They wrap a Prisma client and expose
+ * intent-revealing methods (e.g. `findAccessibleById(workspaceId, userId)`)
+ * so that the shape of `where` clauses doesn't leak into services/routers.
+ */
+export class BaseRepository {
+    constructor(db) {
+        this.db = db;
+        this.logger = logger;
+    }
+}

package/dist/repositories/invitation.repository.d.ts

@@ -0,0 +1,94 @@
+import type { Prisma, PrismaClient } from '@prisma/client';
+import { BaseRepository } from './base.repository.js';
+/**
+ * Data access for `WorkspaceInvitation`. Members router currently performs
+ * invitation CRUD + token validation directly against Prisma — this
+ * repository is the target of that extraction during Phase 4.
+ */
+export declare class InvitationRepository extends BaseRepository {
+    constructor(db: PrismaClient);
+    findById(id: string, include?: Prisma.WorkspaceInvitationInclude): Prisma.Prisma__WorkspaceInvitationClient<{
+        id: string;
+        email: string;
+        createdAt: Date;
+        updatedAt: Date;
+        workspaceId: string;
+        role: string;
+        token: string;
+        invitedById: string;
+        acceptedAt: Date | null;
+        expiresAt: Date;
+    } | null, null, import("@prisma/client/runtime/library").DefaultArgs, Prisma.PrismaClientOptions>;
+    findFirst(args: Prisma.WorkspaceInvitationFindFirstArgs): Prisma.Prisma__WorkspaceInvitationClient<{
+        id: string;
+        email: string;
+        createdAt: Date;
+        updatedAt: Date;
+        workspaceId: string;
+        role: string;
+        token: string;
+        invitedById: string;
+        acceptedAt: Date | null;
+        expiresAt: Date;
+    } | null, null, import("@prisma/client/runtime/library").DefaultArgs, Prisma.PrismaClientOptions>;
+    listByWorkspace(workspaceId: string, args?: Omit<Prisma.WorkspaceInvitationFindManyArgs, 'where'>): Prisma.PrismaPromise<{
+        id: string;
+        email: string;
+        createdAt: Date;
+        updatedAt: Date;
+        workspaceId: string;
+        role: string;
+        token: string;
+        invitedById: string;
+        acceptedAt: Date | null;
+        expiresAt: Date;
+    }[]>;
+    listForUserEmail(email: string, args?: Omit<Prisma.WorkspaceInvitationFindManyArgs, 'where'>): Prisma.PrismaPromise<{
+        id: string;
+        email: string;
+        createdAt: Date;
+        updatedAt: Date;
+        workspaceId: string;
+        role: string;
+        token: string;
+        invitedById: string;
+        acceptedAt: Date | null;
+        expiresAt: Date;
+    }[]>;
+    create(data: Prisma.WorkspaceInvitationCreateInput): Prisma.Prisma__WorkspaceInvitationClient<{
+        id: string;
+        email: string;
+        createdAt: Date;
+        updatedAt: Date;
+        workspaceId: string;
+        role: string;
+        token: string;
+        invitedById: string;
+        acceptedAt: Date | null;
+        expiresAt: Date;
+    }, never, import("@prisma/client/runtime/library").DefaultArgs, Prisma.PrismaClientOptions>;
+    update(id: string, data: Prisma.WorkspaceInvitationUpdateInput): Prisma.Prisma__WorkspaceInvitationClient<{
+        id: string;
+        email: string;
+        createdAt: Date;
+        updatedAt: Date;
+        workspaceId: string;
+        role: string;
+        token: string;
+        invitedById: string;
+        acceptedAt: Date | null;
+        expiresAt: Date;
+    }, never, import("@prisma/client/runtime/library").DefaultArgs, Prisma.PrismaClientOptions>;
+    delete(id: string): Prisma.Prisma__WorkspaceInvitationClient<{
+        id: string;
+        email: string;
+        createdAt: Date;
+        updatedAt: Date;
+        workspaceId: string;
+        role: string;
+        token: string;
+        invitedById: string;
+        acceptedAt: Date | null;
+        expiresAt: Date;
+    }, never, import("@prisma/client/runtime/library").DefaultArgs, Prisma.PrismaClientOptions>;
+}

package/dist/repositories/invitation.repository.js

@@ -0,0 +1,44 @@
+import { BaseRepository } from './base.repository.js';
+/**
+ * Data access for `WorkspaceInvitation`. Members router currently performs
+ * invitation CRUD + token validation directly against Prisma — this
+ * repository is the target of that extraction during Phase 4.
+ */
+export class InvitationRepository extends BaseRepository {
+    constructor(db) {
+        super(db);
+    }
+    findById(id, include) {
+        return this.db.workspaceInvitation.findFirst({
+            where: { id },
+            include,
+        });
+    }
+    findFirst(args) {
+        return this.db.workspaceInvitation.findFirst(args);
+    }
+    listByWorkspace(workspaceId, args) {
+        return this.db.workspaceInvitation.findMany({
+            ...args,
+            where: { workspaceId },
+        });
+    }
+    listForUserEmail(email, args) {
+        return this.db.workspaceInvitation.findMany({
+            ...args,
+            where: { email },
+        });
+    }
+    create(data) {
+        return this.db.workspaceInvitation.create({ data });
+    }
+    update(id, data) {
+        return this.db.workspaceInvitation.update({
+            where: { id },
+            data,
+        });
+    }
+    delete(id) {
+        return this.db.workspaceInvitation.delete({ where: { id } });
+    }
+}

package/dist/repositories/notification.repository.d.ts

@@ -0,0 +1,72 @@
+import type { Prisma, PrismaClient } from '@prisma/client';
+import { BaseRepository } from './base.repository.js';
+/**
+ * Thin data-access wrapper around `Notification`. `NotificationService`
+ * currently calls `ctx.db.notification.*` directly; Phase 4 will migrate it
+ * to use this repository so services don't need Prisma-specific types at
+ * their API boundary.
+ */
+export declare class NotificationRepository extends BaseRepository {
+    constructor(db: PrismaClient);
+    findFirst(args: Prisma.NotificationFindFirstArgs): Prisma.Prisma__NotificationClient<{
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        workspaceId: string | null;
+        type: string;
+        title: string;
+        content: string | null;
+        userId: string;
+        actorUserId: string | null;
+        body: string;
+        actionUrl: string | null;
+        metadata: Prisma.JsonValue | null;
+        priority: import("@prisma/client").$Enums.NotificationPriority;
+        sourceId: string | null;
+        read: boolean;
+        readAt: Date | null;
+        deliveredAt: Date | null;
+    } | null, null, import("@prisma/client/runtime/library").DefaultArgs, Prisma.PrismaClientOptions>;
+    listByUser(userId: string, args?: Omit<Prisma.NotificationFindManyArgs, 'where'>): Prisma.PrismaPromise<{
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        workspaceId: string | null;
+        type: string;
+        title: string;
+        content: string | null;
+        userId: string;
+        actorUserId: string | null;
+        body: string;
+        actionUrl: string | null;
+        metadata: Prisma.JsonValue | null;
+        priority: import("@prisma/client").$Enums.NotificationPriority;
+        sourceId: string | null;
+        read: boolean;
+        readAt: Date | null;
+        deliveredAt: Date | null;
+    }[]>;
+    count(args: Prisma.NotificationCountArgs): Prisma.PrismaPromise<number>;
+    create(data: Prisma.NotificationCreateInput): Prisma.Prisma__NotificationClient<{
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        workspaceId: string | null;
+        type: string;
+        title: string;
+        content: string | null;
+        userId: string;
+        actorUserId: string | null;
+        body: string;
+        actionUrl: string | null;
+        metadata: Prisma.JsonValue | null;
+        priority: import("@prisma/client").$Enums.NotificationPriority;
+        sourceId: string | null;
+        read: boolean;
+        readAt: Date | null;
+        deliveredAt: Date | null;
+    }, never, import("@prisma/client/runtime/library").DefaultArgs, Prisma.PrismaClientOptions>;
+    markRead(id: string, userId: string): Prisma.PrismaPromise<Prisma.BatchPayload>;
+    markAllRead(userId: string): Prisma.PrismaPromise<Prisma.BatchPayload>;
+    delete(id: string, userId: string): Prisma.PrismaPromise<Prisma.BatchPayload>;
+}

package/dist/repositories/notification.repository.js

@@ -0,0 +1,44 @@
+import { BaseRepository } from './base.repository.js';
+/**
+ * Thin data-access wrapper around `Notification`. `NotificationService`
+ * currently calls `ctx.db.notification.*` directly; Phase 4 will migrate it
+ * to use this repository so services don't need Prisma-specific types at
+ * their API boundary.
+ */
+export class NotificationRepository extends BaseRepository {
+    constructor(db) {
+        super(db);
+    }
+    findFirst(args) {
+        return this.db.notification.findFirst(args);
+    }
+    listByUser(userId, args) {
+        return this.db.notification.findMany({
+            ...args,
+            where: { userId },
+        });
+    }
+    count(args) {
+        return this.db.notification.count(args);
+    }
+    create(data) {
+        return this.db.notification.create({ data });
+    }
+    markRead(id, userId) {
+        return this.db.notification.updateMany({
+            where: { id, userId },
+            data: { read: true },
+        });
+    }
+    markAllRead(userId) {
+        return this.db.notification.updateMany({
+            where: { userId, read: false },
+            data: { read: true },
+        });
+    }
+    delete(id, userId) {
+        return this.db.notification.deleteMany({
+            where: { id, userId },
+        });
+    }
+}

package/dist/repositories/router-module.repository.d.ts

@@ -0,0 +1,10 @@
+import { BaseRepository } from './base.repository.js';
+/**
+ * Adapter repository for legacy router modules during MVC migration.
+ * Keeps the transport contract stable while moving ownership boundaries.
+ */
+export declare class RouterModuleRepository<TModule> extends BaseRepository {
+    private readonly module;
+    constructor(db: ConstructorParameters<typeof BaseRepository>[0], module: TModule);
+    getModule(): TModule;
+}

package/dist/repositories/router-module.repository.js

@@ -0,0 +1,14 @@
+import { BaseRepository } from './base.repository.js';
+/**
+ * Adapter repository for legacy router modules during MVC migration.
+ * Keeps the transport contract stable while moving ownership boundaries.
+ */
+export class RouterModuleRepository extends BaseRepository {
+    constructor(db, module) {
+        super(db);
+        this.module = module;
+    }
+    getModule() {
+        return this.module;
+    }
+}

package/dist/repositories/user.repository.d.ts

@@ -0,0 +1,74 @@
+import type { Prisma, PrismaClient } from '@prisma/client';
+import { BaseRepository } from './base.repository.js';
+export declare class UserRepository extends BaseRepository {
+    constructor(db: PrismaClient);
+    findById(id: string, args?: Omit<Prisma.UserFindUniqueArgs, 'where'>): Prisma.Prisma__UserClient<{
+        name: string | null;
+        id: string;
+        email: string | null;
+        emailVerified: Date | null;
+        passwordHash: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+        fileAssetId: string | null;
+        roleId: string | null;
+        deletedAt: Date | null;
+        stripe_customer_id: string | null;
+    } | null, null, import("@prisma/client/runtime/library").DefaultArgs, Prisma.PrismaClientOptions>;
+    findByEmail(email: string, args?: Omit<Prisma.UserFindUniqueArgs, 'where'>): Prisma.Prisma__UserClient<{
+        name: string | null;
+        id: string;
+        email: string | null;
+        emailVerified: Date | null;
+        passwordHash: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+        fileAssetId: string | null;
+        roleId: string | null;
+        deletedAt: Date | null;
+        stripe_customer_id: string | null;
+    } | null, null, import("@prisma/client/runtime/library").DefaultArgs, Prisma.PrismaClientOptions>;
+    create(data: Prisma.UserCreateInput): Prisma.Prisma__UserClient<{
+        name: string | null;
+        id: string;
+        email: string | null;
+        emailVerified: Date | null;
+        passwordHash: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+        fileAssetId: string | null;
+        roleId: string | null;
+        deletedAt: Date | null;
+        stripe_customer_id: string | null;
+    }, never, import("@prisma/client/runtime/library").DefaultArgs, Prisma.PrismaClientOptions>;
+    update(id: string, data: Prisma.UserUpdateInput): Prisma.Prisma__UserClient<{
+        name: string | null;
+        id: string;
+        email: string | null;
+        emailVerified: Date | null;
+        passwordHash: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+        fileAssetId: string | null;
+        roleId: string | null;
+        deletedAt: Date | null;
+        stripe_customer_id: string | null;
+    }, never, import("@prisma/client/runtime/library").DefaultArgs, Prisma.PrismaClientOptions>;
+    /**
+     * Soft-delete marker: set `deletedAt`. Hard-delete happens in
+     * `scripts/purge-deleted-users.ts`.
+     */
+    softDelete(id: string): Prisma.Prisma__UserClient<{
+        name: string | null;
+        id: string;
+        email: string | null;
+        emailVerified: Date | null;
+        passwordHash: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+        fileAssetId: string | null;
+        roleId: string | null;
+        deletedAt: Date | null;
+        stripe_customer_id: string | null;
+    }, never, import("@prisma/client/runtime/library").DefaultArgs, Prisma.PrismaClientOptions>;
+}