@lastshotlabs/bunshot 0.0.8 → 0.0.10

package/dist/lib/resetPassword.js

@@ -0,0 +1,95 @@
+import { createHash } from "crypto";
+import { getRedis } from "./redis";
+import { appConnection } from "./mongo";
+import { getAppName, getResetTokenExpiry } from "./appConfig";
+import { Schema } from "mongoose";
+import { sqliteCreateResetToken, sqliteConsumeResetToken, } from "../adapters/sqliteAuth";
+import { memoryCreateResetToken, memoryConsumeResetToken, } from "../adapters/memoryAuth";
+// ---------------------------------------------------------------------------
+// Token hashing — store SHA-256(token); raw token is only in the email link.
+// If the store is ever leaked, outstanding tokens cannot be replayed directly.
+// ---------------------------------------------------------------------------
+const hashToken = (token) => createHash("sha256").update(token).digest("hex");
+const resetSchema = new Schema({
+    token: { type: String, required: true, unique: true },
+    userId: { type: String, required: true },
+    email: { type: String, required: true },
+    expiresAt: { type: Date, required: true, index: { expireAfterSeconds: 0 } },
+}, { collection: "password_resets" });
+function getResetModel() {
+    return appConnection.models["PasswordReset"] ??
+        appConnection.model("PasswordReset", resetSchema);
+}
+// ---------------------------------------------------------------------------
+// Redis helpers
+// ---------------------------------------------------------------------------
+/** Atomically GET+DEL a key. Uses native GETDEL (Redis >= 6.2) with a Lua fallback. */
+async function redisGetDel(key) {
+    const redis = getRedis();
+    if (typeof redis.getdel === "function") {
+        try {
+            return await redis.getdel(key);
+        }
+        catch (err) {
+            const msg = err?.message ?? "";
+            if (!/unknown command|ERR unknown command/i.test(msg))
+                throw err;
+            // Fall through to Lua on "unknown command"
+        }
+    }
+    const result = await redis.eval("local v = redis.call('GET', KEYS[1])\nif v then redis.call('DEL', KEYS[1]) end\nreturn v", 1, key);
+    return result ?? null;
+}
+let _store = "redis";
+export const setPasswordResetStore = (store) => { _store = store; };
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/** Create a reset token. Returns the raw token (to embed in the email link).
+ *  Only the SHA-256 hash is persisted in the store. */
+export const createResetToken = async (userId, email) => {
+    const token = crypto.randomUUID();
+    const hash = hashToken(token);
+    const ttl = getResetTokenExpiry();
+    if (_store === "memory") {
+        memoryCreateResetToken(hash, userId, email, ttl);
+        return token;
+    }
+    if (_store === "sqlite") {
+        sqliteCreateResetToken(hash, userId, email, ttl);
+        return token;
+    }
+    if (_store === "mongo") {
+        await getResetModel().create({
+            token: hash,
+            userId,
+            email,
+            expiresAt: new Date(Date.now() + ttl * 1000),
+        });
+        return token;
+    }
+    await getRedis().set(`reset:${getAppName()}:${hash}`, JSON.stringify({ userId, email }), "EX", ttl);
+    return token;
+};
+/** Atomically consume a reset token — returns its payload and deletes it in one operation.
+ *  Returns null if the token is invalid, expired, or already used. */
+export const consumeResetToken = async (token) => {
+    const hash = hashToken(token);
+    if (_store === "memory")
+        return memoryConsumeResetToken(hash);
+    if (_store === "sqlite")
+        return sqliteConsumeResetToken(hash);
+    if (_store === "mongo") {
+        const doc = await getResetModel()
+            .findOneAndDelete({ token: hash, expiresAt: { $gt: new Date() } })
+            .lean();
+        if (!doc)
+            return null;
+        return { userId: doc.userId, email: doc.email };
+    }
+    // Redis: atomically return and remove the key (GETDEL or Lua fallback)
+    const raw = await redisGetDel(`reset:${getAppName()}:${hash}`);
+    if (!raw)
+        return null;
+    return JSON.parse(raw);
+};

package/dist/lib/session.d.ts

@@ -1,6 +1,23 @@
+export interface SessionMetadata {
+    ipAddress?: string;
+    userAgent?: string;
+}
+export interface SessionInfo {
+    sessionId: string;
+    createdAt: number;
+    lastActiveAt: number;
+    expiresAt: number;
+    ipAddress?: string;
+    userAgent?: string;
+    isActive: boolean;
+}
 type SessionStore = "redis" | "mongo" | "sqlite" | "memory";
 export declare const setSessionStore: (store: SessionStore) => void;
-export declare const createSession: (userId: string, token: string) => Promise<void>;
-export declare const getSession: (userId: string) => Promise<any>;
-export declare const deleteSession: (userId: string) => Promise<void>;
+export declare const createSession: (userId: string, token: string, sessionId: string, metadata?: SessionMetadata) => Promise<void>;
+export declare const getSession: (sessionId: string) => Promise<string | null>;
+export declare const deleteSession: (sessionId: string) => Promise<void>;
+export declare const getUserSessions: (userId: string) => Promise<SessionInfo[]>;
+export declare const getActiveSessionCount: (userId: string) => Promise<number>;
+export declare const evictOldestSession: (userId: string) => Promise<void>;
+export declare const updateSessionLastActive: (sessionId: string) => Promise<void>;
 export {};

package/dist/lib/session.js

@@ -1,17 +1,28 @@
 import { getRedis } from "./redis";
-import { appConnection } from "./mongo";
-import { getAppName } from "./appConfig";
-import { Schema } from "mongoose";
-import { sqliteCreateSession, sqliteGetSession, sqliteDeleteSession } from "../adapters/sqliteAuth";
-import { memoryCreateSession, memoryGetSession, memoryDeleteSession } from "../adapters/memoryAuth";
-const sessionSchema = new Schema({
-    userId: { type: String, required: true, unique: true },
-    token: { type: String, required: true },
-    expiresAt: { type: Date, required: true, index: { expireAfterSeconds: 0 } },
-}, { collection: "sessions" });
+import { appConnection, mongoose } from "./mongo";
+import { getAppName, getPersistSessionMetadata, getIncludeInactiveSessions } from "./appConfig";
+import { sqliteCreateSession, sqliteGetSession, sqliteDeleteSession, sqliteGetUserSessions, sqliteGetActiveSessionCount, sqliteEvictOldestSession, sqliteUpdateSessionLastActive, } from "../adapters/sqliteAuth";
+import { memoryCreateSession, memoryGetSession, memoryDeleteSession, memoryGetUserSessions, memoryGetActiveSessionCount, memoryEvictOldestSession, memoryUpdateSessionLastActive, } from "../adapters/memoryAuth";
 function getSessionModel() {
-    return appConnection.models["Session"] ??
-        appConnection.model("Session", sessionSchema);
+    if (appConnection.models["Session"])
+        return appConnection.models["Session"];
+    const { Schema } = mongoose;
+    const sessionSchema = new Schema({
+        sessionId: { type: String, required: true, unique: true },
+        userId: { type: String, required: true, index: true },
+        token: { type: String, default: null },
+        createdAt: { type: Date, required: true },
+        lastActiveAt: { type: Date, required: true },
+        expiresAt: { type: Date, required: true },
+        ipAddress: { type: String },
+        userAgent: { type: String },
+    }, { collection: "sessions", timestamps: false });
+    // Add TTL index only when metadata is not persisted — docs auto-delete at expiresAt.
+    // When persisting, token is nulled (soft-delete) but the row is kept indefinitely.
+    if (!getPersistSessionMetadata()) {
+        sessionSchema.index({ expiresAt: 1 }, { expireAfterSeconds: 0 });
+    }
+    return appConnection.model("Session", sessionSchema);
 }
 let _store = "redis";
 export const setSessionStore = (store) => { _store = store; };
@@ -19,50 +30,292 @@ export const setSessionStore = (store) => { _store = store; };
 // TTL
 // ---------------------------------------------------------------------------
 const TTL_SECONDS = 60 * 60 * 24 * 7; // 7 days
+const TTL_MS = TTL_SECONDS * 1000;
+// ---------------------------------------------------------------------------
+// Redis helpers
+// ---------------------------------------------------------------------------
+function redisSessionKey(sessionId) {
+    return `session:${getAppName()}:${sessionId}`;
+}
+function redisUserSessionsKey(userId) {
+    return `usersessions:${getAppName()}:${userId}`;
+}
+async function redisCreateSession(userId, token, sessionId, metadata) {
+    const now = Date.now();
+    const expiresAt = now + TTL_MS;
+    const record = JSON.stringify({
+        sessionId, userId, token,
+        createdAt: now, lastActiveAt: now, expiresAt,
+        ipAddress: metadata?.ipAddress,
+        userAgent: metadata?.userAgent,
+    });
+    const redis = getRedis();
+    const persist = getPersistSessionMetadata();
+    if (persist) {
+        await redis.set(redisSessionKey(sessionId), record);
+    }
+    else {
+        await redis.set(redisSessionKey(sessionId), record, "EX", TTL_SECONDS);
+    }
+    // Sorted set: score = createdAt (oldest first)
+    await redis.zadd(redisUserSessionsKey(userId), now, sessionId);
+}
+async function redisGetSession(sessionId) {
+    const raw = await getRedis().get(redisSessionKey(sessionId));
+    if (!raw)
+        return null;
+    const rec = JSON.parse(raw);
+    if (!rec.token)
+        return null;
+    if (rec.expiresAt <= Date.now())
+        return null;
+    return rec.token;
+}
+async function redisDeleteSession(sessionId) {
+    const redis = getRedis();
+    const raw = await redis.get(redisSessionKey(sessionId));
+    if (!raw)
+        return;
+    const rec = JSON.parse(raw);
+    const persist = getPersistSessionMetadata();
+    if (persist) {
+        const updated = { ...JSON.parse(raw), token: null };
+        await redis.set(redisSessionKey(sessionId), JSON.stringify(updated));
+    }
+    else {
+        await redis.del(redisSessionKey(sessionId));
+    }
+    if (!persist) {
+        await redis.zrem(redisUserSessionsKey(rec.userId), sessionId);
+    }
+}
+async function redisGetUserSessions(userId) {
+    const redis = getRedis();
+    const sessionIds = await redis.zrange(redisUserSessionsKey(userId), 0, -1);
+    if (!sessionIds.length)
+        return [];
+    const now = Date.now();
+    const raws = await redis.mget(...sessionIds.map(redisSessionKey));
+    const results = [];
+    const toRemove = [];
+    for (let i = 0; i < sessionIds.length; i++) {
+        const raw = raws[i];
+        if (!raw) {
+            toRemove.push(sessionIds[i]);
+            continue;
+        }
+        const rec = JSON.parse(raw);
+        const isActive = !!rec.token && rec.expiresAt > now;
+        if (!isActive && !getPersistSessionMetadata()) {
+            toRemove.push(sessionIds[i]);
+            continue;
+        }
+        if (!isActive && !getIncludeInactiveSessions())
+            continue;
+        results.push({
+            sessionId: rec.sessionId,
+            createdAt: Number(rec.createdAt),
+            lastActiveAt: Number(rec.lastActiveAt),
+            expiresAt: Number(rec.expiresAt),
+            ipAddress: rec.ipAddress,
+            userAgent: rec.userAgent,
+            isActive,
+        });
+    }
+    if (toRemove.length) {
+        await redis.zrem(redisUserSessionsKey(userId), ...toRemove);
+    }
+    return results;
+}
+async function redisGetActiveSessionCount(userId) {
+    const sessions = await redisGetUserSessions(userId);
+    return sessions.filter((s) => s.isActive).length;
+}
+async function redisEvictOldestSession(userId) {
+    const redis = getRedis();
+    // Sorted set is ordered oldest-first (score = createdAt)
+    const sessionIds = await redis.zrange(redisUserSessionsKey(userId), 0, -1);
+    const now = Date.now();
+    for (const sessionId of sessionIds) {
+        const raw = await redis.get(redisSessionKey(sessionId));
+        if (!raw) {
+            await redis.zrem(redisUserSessionsKey(userId), sessionId);
+            continue;
+        }
+        const rec = JSON.parse(raw);
+        if (rec.token && rec.expiresAt > now) {
+            await redisDeleteSession(sessionId);
+            return;
+        }
+    }
+}
+async function redisUpdateSessionLastActive(sessionId) {
+    const redis = getRedis();
+    const raw = await redis.get(redisSessionKey(sessionId));
+    if (!raw)
+        return;
+    const rec = JSON.parse(raw);
+    rec.lastActiveAt = Date.now();
+    if (getPersistSessionMetadata()) {
+        await redis.set(redisSessionKey(sessionId), JSON.stringify(rec));
+    }
+    else {
+        const now = Date.now();
+        if (rec.expiresAt <= now) {
+            await redisDeleteSession(sessionId);
+            return;
+        }
+        const ttlRemaining = Math.max(1, Math.ceil((rec.expiresAt - now) / 1000));
+        await redis.set(redisSessionKey(sessionId), JSON.stringify(rec), "EX", ttlRemaining);
+    }
+}
+// ---------------------------------------------------------------------------
+// Mongo helpers
+// ---------------------------------------------------------------------------
+async function mongoGetUserSessions(userId) {
+    const now = new Date();
+    const includeInactive = getIncludeInactiveSessions();
+    const persist = getPersistSessionMetadata();
+    const query = { userId };
+    if (!includeInactive) {
+        query.token = { $ne: null };
+        query.expiresAt = { $gt: now };
+    }
+    const docs = await getSessionModel().find(query).lean();
+    const results = [];
+    for (const doc of docs) {
+        const isActive = !!doc.token && doc.expiresAt > now;
+        if (!isActive && !persist)
+            continue;
+        if (!isActive && !includeInactive)
+            continue;
+        results.push({
+            sessionId: doc.sessionId,
+            createdAt: doc.createdAt.getTime(),
+            lastActiveAt: doc.lastActiveAt.getTime(),
+            expiresAt: doc.expiresAt.getTime(),
+            ipAddress: doc.ipAddress,
+            userAgent: doc.userAgent,
+            isActive,
+        });
+    }
+    return results;
+}
 // ---------------------------------------------------------------------------
 // Public API
 // ---------------------------------------------------------------------------
-export const createSession = async (userId, token) => {
+export const createSession = async (userId, token, sessionId, metadata) => {
     if (_store === "memory") {
-        memoryCreateSession(userId, token);
+        memoryCreateSession(userId, token, sessionId, metadata);
         return;
     }
     if (_store === "sqlite") {
-        sqliteCreateSession(userId, token);
+        sqliteCreateSession(userId, token, sessionId, metadata);
         return;
     }
-    if (_store === "mongo") {
-        const expiresAt = new Date(Date.now() + TTL_SECONDS * 1000);
-        await getSessionModel().updateOne({ userId }, { $set: { token, expiresAt } }, { upsert: true });
+    if (_store === "redis") {
+        await redisCreateSession(userId, token, sessionId, metadata);
         return;
     }
-    await getRedis().set(`session:${getAppName()}:${userId}`, token, "EX", TTL_SECONDS);
+    // mongo
+    const now = new Date();
+    const expiresAt = new Date(Date.now() + TTL_MS);
+    await getSessionModel().create({
+        sessionId, userId, token,
+        createdAt: now, lastActiveAt: now, expiresAt,
+        ipAddress: metadata?.ipAddress,
+        userAgent: metadata?.userAgent,
+    });
 };
-export const getSession = async (userId) => {
+export const getSession = async (sessionId) => {
     if (_store === "memory")
-        return memoryGetSession(userId);
+        return memoryGetSession(sessionId);
     if (_store === "sqlite")
-        return sqliteGetSession(userId);
-    if (_store === "mongo") {
-        const doc = await getSessionModel()
-            .findOne({ userId, expiresAt: { $gt: new Date() } }, "token")
-            .lean();
-        return doc ? doc.token : null;
-    }
-    return getRedis().get(`session:${getAppName()}:${userId}`);
+        return sqliteGetSession(sessionId);
+    if (_store === "redis")
+        return redisGetSession(sessionId);
+    // mongo
+    const doc = await getSessionModel()
+        .findOne({ sessionId, expiresAt: { $gt: new Date() } }, "token")
+        .lean();
+    return doc?.token ?? null;
+};
+export const deleteSession = async (sessionId) => {
+    if (_store === "memory") {
+        memoryDeleteSession(sessionId);
+        return;
+    }
+    if (_store === "sqlite") {
+        sqliteDeleteSession(sessionId);
+        return;
+    }
+    if (_store === "redis") {
+        await redisDeleteSession(sessionId);
+        return;
+    }
+    // mongo
+    if (getPersistSessionMetadata()) {
+        await getSessionModel().updateOne({ sessionId }, { $set: { token: null } });
+    }
+    else {
+        await getSessionModel().deleteOne({ sessionId });
+    }
+};
+export const getUserSessions = async (userId) => {
+    if (_store === "memory")
+        return memoryGetUserSessions(userId);
+    if (_store === "sqlite")
+        return sqliteGetUserSessions(userId);
+    if (_store === "redis")
+        return redisGetUserSessions(userId);
+    return mongoGetUserSessions(userId);
+};
+export const getActiveSessionCount = async (userId) => {
+    if (_store === "memory")
+        return memoryGetActiveSessionCount(userId);
+    if (_store === "sqlite")
+        return sqliteGetActiveSessionCount(userId);
+    if (_store === "redis")
+        return redisGetActiveSessionCount(userId);
+    // mongo
+    const now = new Date();
+    return getSessionModel().countDocuments({ userId, token: { $ne: null }, expiresAt: { $gt: now } });
+};
+export const evictOldestSession = async (userId) => {
+    if (_store === "memory") {
+        memoryEvictOldestSession(userId);
+        return;
+    }
+    if (_store === "sqlite") {
+        sqliteEvictOldestSession(userId);
+        return;
+    }
+    if (_store === "redis") {
+        await redisEvictOldestSession(userId);
+        return;
+    }
+    // mongo — oldest active session by createdAt
+    const now = new Date();
+    const oldest = await getSessionModel()
+        .findOne({ userId, token: { $ne: null }, expiresAt: { $gt: now } }, "sessionId")
+        .sort({ createdAt: 1 })
+        .lean();
+    if (oldest)
+        await deleteSession(oldest.sessionId);
 };
-export const deleteSession = async (userId) => {
+export const updateSessionLastActive = async (sessionId) => {
     if (_store === "memory") {
-        memoryDeleteSession(userId);
+        memoryUpdateSessionLastActive(sessionId);
         return;
     }
     if (_store === "sqlite") {
-        sqliteDeleteSession(userId);
+        sqliteUpdateSessionLastActive(sessionId);
         return;
     }
-    if (_store === "mongo") {
-        await getSessionModel().deleteOne({ userId });
+    if (_store === "redis") {
+        await redisUpdateSessionLastActive(sessionId);
         return;
     }
-    await getRedis().del(`session:${getAppName()}:${userId}`);
+    // mongo
+    await getSessionModel().updateOne({ sessionId }, { $set: { lastActiveAt: new Date() } });
 };

package/dist/middleware/cacheResponse.js

@@ -1,17 +1,18 @@
 import { getRedis } from "../lib/redis";
 import { getAppName } from "../lib/appConfig";
-import { appConnection } from "../lib/mongo";
-import { Schema } from "mongoose";
+import { appConnection, mongoose } from "../lib/mongo";
 import { isSqliteReady, sqliteGetCache, sqliteSetCache, sqliteDelCache, sqliteDelCachePattern } from "../adapters/sqliteAuth";
 import { memoryGetCache, memorySetCache, memoryDelCache, memoryDelCachePattern } from "../adapters/memoryAuth";
-const cacheSchema = new Schema({
-    key: { type: String, required: true, unique: true },
-    value: { type: String, required: true },
-    expiresAt: { type: Date, index: { expireAfterSeconds: 0 } },
-}, { collection: "cache_entries" });
 function getCacheModel() {
-    return appConnection.models["CacheEntry"] ??
-        appConnection.model("CacheEntry", cacheSchema);
+    if (appConnection.models["CacheEntry"])
+        return appConnection.models["CacheEntry"];
+    const { Schema } = mongoose;
+    const cacheSchema = new Schema({
+        key: { type: String, required: true, unique: true },
+        value: { type: String, required: true },
+        expiresAt: { type: Date, index: { expireAfterSeconds: 0 } },
+    }, { collection: "cache_entries" });
+    return appConnection.model("CacheEntry", cacheSchema);
 }
 function isMongoReady() {
     return appConnection.readyState === 1;

package/dist/middleware/identify.js

@@ -1,25 +1,39 @@
 import { getCookie } from "hono/cookie";
 import { verifyToken } from "../lib/jwt";
-import { getSession } from "../lib/session";
+import { getSession, updateSessionLastActive } from "../lib/session";
 import { COOKIE_TOKEN, HEADER_USER_TOKEN } from "../lib/constants";
 import { log } from "../lib/logger";
+import { getTrackLastActive } from "../lib/appConfig";
 export const identify = async (c, next) => {
     c.set("authUserId", null);
     c.set("roles", null);
+    c.set("sessionId", null);
     // cookie for browsers, x-user-token header for non-browser clients
     const token = getCookie(c, COOKIE_TOKEN) ?? c.req.header(HEADER_USER_TOKEN) ?? null;
     log(`[identify] token=${token ? "present" : "absent"}`);
     if (token) {
         try {
             const payload = await verifyToken(token);
-            const stored = await getSession(payload.sub);
-            log(`[identify] token for authUserId=${payload.sub} verified, checking session...`);
-            if (stored === token) {
-                c.set("authUserId", payload.sub);
-                log(`[identify] authUserId=${payload.sub}`);
+            const sessionId = payload.sid;
+            if (!sessionId) {
+                log("[identify] token missing sid claim — unauthenticated");
             }
             else {
-                log("[identify] token/session mismatch — unauthenticated");
+                const stored = await getSession(sessionId);
+                log(`[identify] token for authUserId=${payload.sub} verified, checking session...`);
+                if (stored === token) {
+                    c.set("authUserId", payload.sub);
+                    c.set("sessionId", sessionId);
+                    log(`[identify] authUserId=${payload.sub} sessionId=${sessionId}`);
+                    if (getTrackLastActive()) {
+                        updateSessionLastActive(sessionId).catch(() => {
+                            log(`[identify] failed to update lastActiveAt for sessionId=${sessionId}`);
+                        });
+                    }
+                }
+                else {
+                    log("[identify] token/session mismatch — unauthenticated");
+                }
             }
         }
         catch {

package/dist/models/AuthUser.d.ts

@@ -1,112 +1,20 @@
-import mongoose from "mongoose";
-export declare const AuthUser: mongoose.Model<{
+import type { Document, Model } from "mongoose";
+interface IAuthUser {
+    email?: string | null;
+    password?: string | null;
+    /** Compound provider keys: ["google:123456", "apple:000111"] */
     providerIds: string[];
-    emailVerified: boolean;
+    /** App-defined roles assigned to this user: ["admin", "editor", ...] */
     roles: string[];
-    email?: string | null | undefined;
-    password?: string | null | undefined;
-} & mongoose.DefaultTimestampProps, {}, {}, {
-    id: string;
-}, mongoose.Document<unknown, {}, {
-    providerIds: string[];
+    /** Whether the user's email address has been verified. */
     emailVerified: boolean;
-    roles: string[];
-    email?: string | null | undefined;
-    password?: string | null | undefined;
-} & mongoose.DefaultTimestampProps, {
-    id: string;
-}, {
-    timestamps: true;
-}> & Omit<{
-    providerIds: string[];
-    emailVerified: boolean;
-    roles: string[];
-    email?: string | null | undefined;
-    password?: string | null | undefined;
-} & mongoose.DefaultTimestampProps & {
-    _id: mongoose.Types.ObjectId;
-} & {
+}
+type AuthUserDocument = IAuthUser & Document;
+export declare const AuthUser: Model<AuthUserDocument, {}, {}, {}, Document<unknown, {}, AuthUserDocument, {}, import("mongoose").DefaultSchemaOptions> & IAuthUser & Document<import("mongoose").Types.ObjectId, any, any, Record<string, any>, {}> & Required<{
+    _id: import("mongoose").Types.ObjectId;
+}> & {
     __v: number;
-}, "id"> & {
-    id: string;
-}, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any, any>, {}, {}, {}, {}, {
-    timestamps: true;
-}, {
-    providerIds: string[];
-    emailVerified: boolean;
-    roles: string[];
-    email?: string | null | undefined;
-    password?: string | null | undefined;
-} & mongoose.DefaultTimestampProps, mongoose.Document<unknown, {}, {
-    providerIds: string[];
-    emailVerified: boolean;
-    roles: string[];
-    email?: string | null | undefined;
-    password?: string | null | undefined;
-} & mongoose.DefaultTimestampProps, {
-    id: string;
-}, mongoose.MergeType<mongoose.DefaultSchemaOptions, {
-    timestamps: true;
-}>> & Omit<{
-    providerIds: string[];
-    emailVerified: boolean;
-    roles: string[];
-    email?: string | null | undefined;
-    password?: string | null | undefined;
-} & mongoose.DefaultTimestampProps & {
-    _id: mongoose.Types.ObjectId;
 } & {
-    __v: number;
-}, "id"> & {
     id: string;
-}, {
-    [path: string]: mongoose.SchemaDefinitionProperty<undefined, any, any>;
-} | {
-    [x: string]: mongoose.SchemaDefinitionProperty<any, any, mongoose.Document<unknown, {}, {
-        providerIds: string[];
-        emailVerified: boolean;
-        roles: string[];
-        email?: string | null | undefined;
-        password?: string | null | undefined;
-    } & mongoose.DefaultTimestampProps, {
-        id: string;
-    }, mongoose.MergeType<mongoose.DefaultSchemaOptions, {
-        timestamps: true;
-    }>> & Omit<{
-        providerIds: string[];
-        emailVerified: boolean;
-        roles: string[];
-        email?: string | null | undefined;
-        password?: string | null | undefined;
-    } & mongoose.DefaultTimestampProps & {
-        _id: mongoose.Types.ObjectId;
-    } & {
-        __v: number;
-    }, "id"> & {
-        id: string;
-    }> | undefined;
-}, {
-    providerIds: string[];
-    emailVerified: boolean;
-    roles: string[];
-    email?: string | null | undefined;
-    password?: string | null | undefined;
-    createdAt: NativeDate;
-    updatedAt: NativeDate;
-} & {
-    _id: mongoose.Types.ObjectId;
-} & {
-    __v: number;
-}>, {
-    providerIds: string[];
-    emailVerified: boolean;
-    roles: string[];
-    email?: string | null | undefined;
-    password?: string | null | undefined;
-    createdAt: NativeDate;
-    updatedAt: NativeDate;
-} & {
-    _id: mongoose.Types.ObjectId;
-} & {
-    __v: number;
-}>;
+}, any, AuthUserDocument>;
+export {};