@thetechfossil/auth2 1.2.18 → 1.2.20

package/dist/index.next.server.d.mts

@@ -14,6 +14,8 @@ interface User {
     phoneNumber?: string;
     avatar?: string;
     role: string;
+    emailVerified?: boolean;
+    twoFactorEnabled?: boolean;
     linkedAccounts?: LinkedAccount[];
     createdAt: string;
     updatedAt: string;
@@ -63,6 +65,7 @@ interface AuthConfig {
     localStorageKey?: string;
     token?: string;
     csrfEnabled?: boolean;
+    enableSocket?: boolean;
     upfilesConfig?: UpfilesConfig;
 }
 interface UpfilesConfig {
@@ -130,17 +133,57 @@ interface UseAuthReturn {
     }>;
     revokeSession: (sessionId: string) => Promise<AuthResponse>;
     revokeAllSessions: () => Promise<AuthResponse>;
+    adminCreateUser: (data: {
+        email: string;
+        name: string;
+        phoneNumber?: string;
+        password?: string;
+    }) => Promise<AuthResponse & {
+        user?: User;
+    }>;
+    adminVerifyUser: (userId: string) => Promise<AuthResponse>;
+    adminSuspendUser: (userId: string) => Promise<AuthResponse>;
+    adminActivateUser: (userId: string) => Promise<AuthResponse>;
 }
 
+type SocketEventHandler<T = any> = (data: T) => void;
+
 declare class AuthService {
     private httpClient;
+    private socketService;
     private config;
     private token;
     private upfilesClient;
+    private cachedUser;
+    private userCacheTimestamp;
+    private readonly USER_CACHE_TTL;
     constructor(config: AuthConfig);
     private loadTokenFromStorage;
     private saveTokenToStorage;
     private removeTokenFromStorage;
+    private connectSocket;
+    private disconnectSocket;
+    onUserUpdated(handler: SocketEventHandler<{
+        user: User;
+    }>): () => void;
+    onSessionRevoked(handler: SocketEventHandler<{
+        sessionId?: string;
+    }>): () => void;
+    onAllSessionsRevoked(handler: SocketEventHandler<{}>): () => void;
+    onPasswordChanged(handler: SocketEventHandler<{}>): () => void;
+    on2FAChanged(handler: SocketEventHandler<{
+        enabled: boolean;
+    }>): () => void;
+    onSocketConnected(handler: SocketEventHandler<{}>): () => void;
+    onSocketDisconnected(handler: SocketEventHandler<{
+        reason: string;
+    }>): () => void;
+    onSocketError(handler: SocketEventHandler<{
+        error: string;
+    }>): () => void;
+    isSocketConnected(): boolean;
+    clearUserCache(): void;
+    private isCacheValid;
     isAuthenticated(): boolean;
     getToken(): string | null;
     getCurrentUser(): User | null;
@@ -154,7 +197,7 @@ declare class AuthService {
     verify(data: VerifyData): Promise<AuthResponse>;
     verifyEmailToken(token: string): Promise<AuthResponse>;
     logout(): Promise<void>;
-    getProfile(): Promise<User>;
+    getProfile(forceRefresh?: boolean): Promise<User>;
     updateProfile(data: UpdateUserData): Promise<AuthResponse>;
     getAllUsers(): Promise<User[]>;
     getUserById(id: string): Promise<User>;
@@ -185,6 +228,14 @@ declare class AuthService {
         success: boolean;
         logs: any[];
     }>;
+    adminCreateUser(data: {
+        email: string;
+        name: string;
+        phoneNumber?: string;
+        password?: string;
+    }): Promise<AuthResponse & {
+        user?: User;
+    }>;
     adminVerifyUser(userId: string): Promise<AuthResponse>;
     adminForcePasswordReset(userId: string): Promise<AuthResponse>;
     adminSuspendUser(userId: string): Promise<AuthResponse>;
@@ -224,6 +275,33 @@ declare class AuthClient extends AuthService {
     getAllUsers(): Promise<User[]>;
 }
 
+interface TokenVerifierConfig {
+    authServiceUrl: string;
+    cacheTTL?: number;
+    cacheEnabled?: boolean;
+}
+declare class TokenVerifier {
+    private config;
+    private cache;
+    private cleanupInterval;
+    constructor(config: TokenVerifierConfig);
+    verifyToken(token: string): Promise<User | null>;
+    invalidateToken(token: string): void;
+    clearCache(): void;
+    getCacheStats(): {
+        size: number;
+        enabled: boolean;
+        ttl: number;
+    };
+    destroy(): void;
+    private getFromCache;
+    private setCache;
+    private startCleanup;
+}
+declare function createTokenVerifier(config: TokenVerifierConfig): TokenVerifier;
+declare function getTokenVerifier(): TokenVerifier;
+declare function verifyToken(token: string): Promise<User | null>;
+
 declare class NextServerAuth extends AuthClient {
     constructor(config: AuthConfig);
     static parseTokenFromHeaders(headers: Headers): string | null;
@@ -281,4 +359,4 @@ interface AuthMiddlewareConfig {
 declare function authMiddleware(config?: AuthMiddlewareConfig): (request: NextRequestLike) => NextResponseLike;
 declare function createAuthMiddleware(config?: AuthMiddlewareConfig): (request: NextRequestLike) => NextResponseLike;
 
-export { type AuditLog, AuthClient, type AuthConfig, type AuthResponse, AuthServer, AuthService, type CsrfTokenResponse, HttpClient, type LinkedAccount, type LoginData, type MFASetup, NextServerAuth, type OAuthConfig, type OAuthProvider, type RegisterData, type Session, type UpdateUserData, type UpfilesConfig, type UseAuthReturn, type User, type VerifyData, auth, authMiddleware, createAuthMiddleware, currentUser, getAuthServer, redirectIfAuthenticated, requireAuth };
+export { type AuditLog, AuthClient, type AuthConfig, type AuthResponse, AuthServer, AuthService, type CsrfTokenResponse, HttpClient, type LinkedAccount, type LoginData, type MFASetup, NextServerAuth, type OAuthConfig, type OAuthProvider, type RegisterData, type Session, TokenVerifier, type UpdateUserData, type UpfilesConfig, type UseAuthReturn, type User, type VerifyData, auth, authMiddleware, createAuthMiddleware, createTokenVerifier, currentUser, getAuthServer, getTokenVerifier, redirectIfAuthenticated, requireAuth, verifyToken };

package/dist/index.next.server.d.ts

@@ -14,6 +14,8 @@ interface User {
     phoneNumber?: string;
     avatar?: string;
     role: string;
+    emailVerified?: boolean;
+    twoFactorEnabled?: boolean;
     linkedAccounts?: LinkedAccount[];
     createdAt: string;
     updatedAt: string;
@@ -63,6 +65,7 @@ interface AuthConfig {
     localStorageKey?: string;
     token?: string;
     csrfEnabled?: boolean;
+    enableSocket?: boolean;
     upfilesConfig?: UpfilesConfig;
 }
 interface UpfilesConfig {
@@ -130,17 +133,57 @@ interface UseAuthReturn {
     }>;
     revokeSession: (sessionId: string) => Promise<AuthResponse>;
     revokeAllSessions: () => Promise<AuthResponse>;
+    adminCreateUser: (data: {
+        email: string;
+        name: string;
+        phoneNumber?: string;
+        password?: string;
+    }) => Promise<AuthResponse & {
+        user?: User;
+    }>;
+    adminVerifyUser: (userId: string) => Promise<AuthResponse>;
+    adminSuspendUser: (userId: string) => Promise<AuthResponse>;
+    adminActivateUser: (userId: string) => Promise<AuthResponse>;
 }
 
+type SocketEventHandler<T = any> = (data: T) => void;
+
 declare class AuthService {
     private httpClient;
+    private socketService;
     private config;
     private token;
     private upfilesClient;
+    private cachedUser;
+    private userCacheTimestamp;
+    private readonly USER_CACHE_TTL;
     constructor(config: AuthConfig);
     private loadTokenFromStorage;
     private saveTokenToStorage;
     private removeTokenFromStorage;
+    private connectSocket;
+    private disconnectSocket;
+    onUserUpdated(handler: SocketEventHandler<{
+        user: User;
+    }>): () => void;
+    onSessionRevoked(handler: SocketEventHandler<{
+        sessionId?: string;
+    }>): () => void;
+    onAllSessionsRevoked(handler: SocketEventHandler<{}>): () => void;
+    onPasswordChanged(handler: SocketEventHandler<{}>): () => void;
+    on2FAChanged(handler: SocketEventHandler<{
+        enabled: boolean;
+    }>): () => void;
+    onSocketConnected(handler: SocketEventHandler<{}>): () => void;
+    onSocketDisconnected(handler: SocketEventHandler<{
+        reason: string;
+    }>): () => void;
+    onSocketError(handler: SocketEventHandler<{
+        error: string;
+    }>): () => void;
+    isSocketConnected(): boolean;
+    clearUserCache(): void;
+    private isCacheValid;
     isAuthenticated(): boolean;
     getToken(): string | null;
     getCurrentUser(): User | null;
@@ -154,7 +197,7 @@ declare class AuthService {
     verify(data: VerifyData): Promise<AuthResponse>;
     verifyEmailToken(token: string): Promise<AuthResponse>;
     logout(): Promise<void>;
-    getProfile(): Promise<User>;
+    getProfile(forceRefresh?: boolean): Promise<User>;
     updateProfile(data: UpdateUserData): Promise<AuthResponse>;
     getAllUsers(): Promise<User[]>;
     getUserById(id: string): Promise<User>;
@@ -185,6 +228,14 @@ declare class AuthService {
         success: boolean;
         logs: any[];
     }>;
+    adminCreateUser(data: {
+        email: string;
+        name: string;
+        phoneNumber?: string;
+        password?: string;
+    }): Promise<AuthResponse & {
+        user?: User;
+    }>;
     adminVerifyUser(userId: string): Promise<AuthResponse>;
     adminForcePasswordReset(userId: string): Promise<AuthResponse>;
     adminSuspendUser(userId: string): Promise<AuthResponse>;
@@ -224,6 +275,33 @@ declare class AuthClient extends AuthService {
     getAllUsers(): Promise<User[]>;
 }
 
+interface TokenVerifierConfig {
+    authServiceUrl: string;
+    cacheTTL?: number;
+    cacheEnabled?: boolean;
+}
+declare class TokenVerifier {
+    private config;
+    private cache;
+    private cleanupInterval;
+    constructor(config: TokenVerifierConfig);
+    verifyToken(token: string): Promise<User | null>;
+    invalidateToken(token: string): void;
+    clearCache(): void;
+    getCacheStats(): {
+        size: number;
+        enabled: boolean;
+        ttl: number;
+    };
+    destroy(): void;
+    private getFromCache;
+    private setCache;
+    private startCleanup;
+}
+declare function createTokenVerifier(config: TokenVerifierConfig): TokenVerifier;
+declare function getTokenVerifier(): TokenVerifier;
+declare function verifyToken(token: string): Promise<User | null>;
+
 declare class NextServerAuth extends AuthClient {
     constructor(config: AuthConfig);
     static parseTokenFromHeaders(headers: Headers): string | null;
@@ -281,4 +359,4 @@ interface AuthMiddlewareConfig {
 declare function authMiddleware(config?: AuthMiddlewareConfig): (request: NextRequestLike) => NextResponseLike;
 declare function createAuthMiddleware(config?: AuthMiddlewareConfig): (request: NextRequestLike) => NextResponseLike;
 
-export { type AuditLog, AuthClient, type AuthConfig, type AuthResponse, AuthServer, AuthService, type CsrfTokenResponse, HttpClient, type LinkedAccount, type LoginData, type MFASetup, NextServerAuth, type OAuthConfig, type OAuthProvider, type RegisterData, type Session, type UpdateUserData, type UpfilesConfig, type UseAuthReturn, type User, type VerifyData, auth, authMiddleware, createAuthMiddleware, currentUser, getAuthServer, redirectIfAuthenticated, requireAuth };
+export { type AuditLog, AuthClient, type AuthConfig, type AuthResponse, AuthServer, AuthService, type CsrfTokenResponse, HttpClient, type LinkedAccount, type LoginData, type MFASetup, NextServerAuth, type OAuthConfig, type OAuthProvider, type RegisterData, type Session, TokenVerifier, type UpdateUserData, type UpfilesConfig, type UseAuthReturn, type User, type VerifyData, auth, authMiddleware, createAuthMiddleware, createTokenVerifier, currentUser, getAuthServer, getTokenVerifier, redirectIfAuthenticated, requireAuth, verifyToken };

package/dist/index.next.server.js

@@ -1,6 +1,7 @@
 'use strict';
 
 var axios = require('axios');
+var socket_ioClient = require('socket.io-client');
 var upfiles = require('@thetechfossil/upfiles');
 var headers = require('next/headers');
 var navigation = require('next/navigation');
@@ -126,16 +127,134 @@ var HttpClient = class {
     }
   }
 };
+var SocketService = class {
+  constructor(config) {
+    this.socket = null;
+    this.token = null;
+    this.eventHandlers = /* @__PURE__ */ new Map();
+    this.isConnecting = false;
+    this.config = {
+      autoConnect: false,
+      reconnection: true,
+      reconnectionAttempts: 5,
+      reconnectionDelay: 1e3,
+      ...config
+    };
+  }
+  connect(token) {
+    if (this.socket?.connected || this.isConnecting) {
+      return;
+    }
+    this.token = token;
+    this.isConnecting = true;
+    this.socket = socket_ioClient.io(this.config.baseUrl, {
+      auth: { token },
+      autoConnect: true,
+      reconnection: this.config.reconnection,
+      reconnectionAttempts: this.config.reconnectionAttempts,
+      reconnectionDelay: this.config.reconnectionDelay,
+      transports: ["websocket", "polling"]
+    });
+    this.setupEventListeners();
+  }
+  setupEventListeners() {
+    if (!this.socket) return;
+    this.socket.on("connect", () => {
+      this.isConnecting = false;
+      console.log("[Auth SDK] Socket connected");
+      this.emit("connected", {});
+    });
+    this.socket.on("disconnect", (reason) => {
+      console.log("[Auth SDK] Socket disconnected:", reason);
+      this.emit("disconnected", { reason });
+    });
+    this.socket.on("connect_error", (error) => {
+      this.isConnecting = false;
+      console.error("[Auth SDK] Socket connection error:", error.message);
+      this.emit("error", { error: error.message });
+    });
+    this.socket.on("user:updated", (data) => {
+      this.emit("user:updated", data);
+    });
+    this.socket.on("session:revoked", (data) => {
+      this.emit("session:revoked", data);
+    });
+    this.socket.on("session:all-revoked", () => {
+      this.emit("session:all-revoked", {});
+    });
+    this.socket.on("auth:password-changed", () => {
+      this.emit("auth:password-changed", {});
+    });
+    this.socket.on("auth:2fa-changed", (data) => {
+      this.emit("auth:2fa-changed", data);
+    });
+    this.socket.on("user:refresh", () => {
+      this.emit("user:refresh", {});
+    });
+  }
+  disconnect() {
+    if (this.socket) {
+      this.socket.disconnect();
+      this.socket = null;
+      this.token = null;
+      this.isConnecting = false;
+    }
+  }
+  isConnected() {
+    return this.socket?.connected ?? false;
+  }
+  // Event subscription
+  on(event, handler) {
+    if (!this.eventHandlers.has(event)) {
+      this.eventHandlers.set(event, /* @__PURE__ */ new Set());
+    }
+    this.eventHandlers.get(event).add(handler);
+    return () => {
+      this.eventHandlers.get(event)?.delete(handler);
+    };
+  }
+  off(event, handler) {
+    if (handler) {
+      this.eventHandlers.get(event)?.delete(handler);
+    } else {
+      this.eventHandlers.delete(event);
+    }
+  }
+  emit(event, data) {
+    const handlers = this.eventHandlers.get(event);
+    if (handlers) {
+      handlers.forEach((handler) => {
+        try {
+          handler(data);
+        } catch (error) {
+          console.error(`[Auth SDK] Error in event handler for ${event}:`, error);
+        }
+      });
+    }
+  }
+  // Request fresh user data from server
+  requestUserRefresh() {
+    if (this.socket?.connected) {
+      this.socket.emit("request:user");
+    }
+  }
+};
 var AuthService = class {
+  // 5 minutes cache
   constructor(config) {
     this.token = null;
     this.upfilesClient = null;
+    this.cachedUser = null;
+    this.userCacheTimestamp = 0;
+    this.USER_CACHE_TTL = 5 * 60 * 1e3;
     this.config = {
       localStorageKey: "auth_token",
       csrfEnabled: true,
+      enableSocket: true,
       ...config
     };
     this.httpClient = new HttpClient(this.config.baseUrl);
+    this.socketService = new SocketService({ baseUrl: this.config.baseUrl });
     this.loadTokenFromStorage();
     if (this.config.upfilesConfig) {
       this.upfilesClient = new upfiles.UpfilesClient({
@@ -152,6 +271,9 @@ var AuthService = class {
         this.httpClient.setFrontendBaseUrl(frontendBaseUrl);
       }
     }
+    if (this.token && this.config.enableSocket !== false) {
+      this.connectSocket();
+    }
   }
   loadTokenFromStorage() {
     if (typeof window !== "undefined" && this.config.localStorageKey) {
@@ -184,6 +306,57 @@ var AuthService = class {
       }
     }
   }
+  // Socket connection management
+  connectSocket() {
+    if (this.token && this.config.enableSocket !== false && typeof window !== "undefined") {
+      this.socketService.connect(this.token);
+    }
+  }
+  disconnectSocket() {
+    this.socketService.disconnect();
+  }
+  // Socket event subscription
+  onUserUpdated(handler) {
+    return this.socketService.on("user:updated", (data) => {
+      if (data.user) {
+        this.cachedUser = data.user;
+        this.userCacheTimestamp = Date.now();
+      }
+      handler(data);
+    });
+  }
+  onSessionRevoked(handler) {
+    return this.socketService.on("session:revoked", handler);
+  }
+  onAllSessionsRevoked(handler) {
+    return this.socketService.on("session:all-revoked", handler);
+  }
+  onPasswordChanged(handler) {
+    return this.socketService.on("auth:password-changed", handler);
+  }
+  on2FAChanged(handler) {
+    return this.socketService.on("auth:2fa-changed", handler);
+  }
+  onSocketConnected(handler) {
+    return this.socketService.on("connected", handler);
+  }
+  onSocketDisconnected(handler) {
+    return this.socketService.on("disconnected", handler);
+  }
+  onSocketError(handler) {
+    return this.socketService.on("error", handler);
+  }
+  isSocketConnected() {
+    return this.socketService.isConnected();
+  }
+  // Cache management
+  clearUserCache() {
+    this.cachedUser = null;
+    this.userCacheTimestamp = 0;
+  }
+  isCacheValid() {
+    return this.cachedUser !== null && Date.now() - this.userCacheTimestamp < this.USER_CACHE_TTL;
+  }
   isAuthenticated() {
     return !!this.token;
   }
@@ -249,6 +422,11 @@ var AuthService = class {
       this.token = response.token;
       this.httpClient.setAuthToken(response.token);
       this.saveTokenToStorage(response.token);
+      if (response.user) {
+        this.cachedUser = response.user;
+        this.userCacheTimestamp = Date.now();
+      }
+      this.connectSocket();
       return response;
     }
     if (response.success && (response.message === "OTP sent to your email." || response.message === "OTP sent to your phone number.")) {
@@ -258,6 +436,11 @@ var AuthService = class {
       this.token = response.token;
       this.httpClient.setAuthToken(response.token);
       this.saveTokenToStorage(response.token);
+      if (response.user) {
+        this.cachedUser = response.user;
+        this.userCacheTimestamp = Date.now();
+      }
+      this.connectSocket();
       return response;
     }
     throw new Error(response.message || "Login failed");
@@ -301,21 +484,29 @@ var AuthService = class {
     }
   }
   async logout() {
+    this.disconnectSocket();
     try {
       await this.httpClient.post("/api/v1/auth/logout", {});
     } catch (error) {
       console.warn("Failed to call logout endpoint:", error);
     }
     this.token = null;
+    this.cachedUser = null;
+    this.userCacheTimestamp = 0;
     this.httpClient.removeAuthToken();
     this.httpClient.removeCsrfToken();
     this.removeTokenFromStorage();
   }
-  async getProfile() {
+  async getProfile(forceRefresh = false) {
     if (!this.token) {
       throw new Error("Not authenticated");
     }
+    if (!forceRefresh && this.isCacheValid() && this.cachedUser) {
+      return this.cachedUser;
+    }
     const response = await this.httpClient.get("/api/v1/user/me");
+    this.cachedUser = response.user;
+    this.userCacheTimestamp = Date.now();
     return response.user;
   }
   async updateProfile(data) {
@@ -479,6 +670,16 @@ var AuthService = class {
     );
     return response;
   }
+  async adminCreateUser(data) {
+    if (!this.token) {
+      throw new Error("Not authenticated");
+    }
+    const response = await this.httpClient.post(
+      "/api/v1/admin/create-user",
+      data
+    );
+    return response;
+  }
   async adminVerifyUser(userId) {
     if (!this.token) {
       throw new Error("Not authenticated");
@@ -587,6 +788,135 @@ var AuthClient = class extends AuthService {
   }
 };
 
+// src/node/token-verifier.ts
+var TokenVerifier = class {
+  constructor(config) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.cleanupInterval = null;
+    this.config = {
+      cacheTTL: 6e4,
+      // 1 minute default
+      cacheEnabled: true,
+      ...config
+    };
+    if (this.config.cacheEnabled) {
+      this.startCleanup();
+    }
+  }
+  /**
+   * Verify a JWT token and get user data
+   * Returns cached user if available and valid
+   */
+  async verifyToken(token) {
+    if (!token) {
+      return null;
+    }
+    if (this.config.cacheEnabled) {
+      const cached = this.getFromCache(token);
+      if (cached) {
+        return cached;
+      }
+    }
+    try {
+      const response = await fetch(`${this.config.authServiceUrl}/api/v1/user/me`, {
+        headers: {
+          "Authorization": `Bearer ${token}`,
+          "Content-Type": "application/json"
+        }
+      });
+      if (!response.ok) {
+        this.cache.delete(token);
+        return null;
+      }
+      const data = await response.json();
+      const user = data.user || null;
+      if (user && this.config.cacheEnabled) {
+        this.setCache(token, user);
+      }
+      return user;
+    } catch (error) {
+      console.error("[TokenVerifier] Auth service verification failed:", error);
+      return null;
+    }
+  }
+  /**
+   * Invalidate cache for a specific token
+   */
+  invalidateToken(token) {
+    this.cache.delete(token);
+  }
+  /**
+   * Clear all cached tokens
+   */
+  clearCache() {
+    this.cache.clear();
+  }
+  /**
+   * Get cache statistics
+   */
+  getCacheStats() {
+    return {
+      size: this.cache.size,
+      enabled: this.config.cacheEnabled,
+      ttl: this.config.cacheTTL
+    };
+  }
+  /**
+   * Stop the cleanup interval (call when shutting down)
+   */
+  destroy() {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = null;
+    }
+    this.cache.clear();
+  }
+  getFromCache(token) {
+    const entry = this.cache.get(token);
+    if (!entry) {
+      return null;
+    }
+    if (Date.now() > entry.expiresAt) {
+      this.cache.delete(token);
+      return null;
+    }
+    return entry.user;
+  }
+  setCache(token, user) {
+    this.cache.set(token, {
+      user,
+      expiresAt: Date.now() + this.config.cacheTTL
+    });
+  }
+  startCleanup() {
+    this.cleanupInterval = setInterval(() => {
+      const now = Date.now();
+      for (const [token, entry] of this.cache.entries()) {
+        if (now > entry.expiresAt) {
+          this.cache.delete(token);
+        }
+      }
+    }, 6e4);
+    if (this.cleanupInterval && this.cleanupInterval.unref) {
+      this.cleanupInterval.unref();
+    }
+  }
+};
+var defaultVerifier = null;
+function createTokenVerifier(config) {
+  defaultVerifier = new TokenVerifier(config);
+  return defaultVerifier;
+}
+function getTokenVerifier() {
+  if (!defaultVerifier) {
+    throw new Error("TokenVerifier not initialized. Call createTokenVerifier() first.");
+  }
+  return defaultVerifier;
+}
+async function verifyToken(token) {
+  return getTokenVerifier().verifyToken(token);
+}
+
 // src/nextjs/server-auth.ts
 var NextServerAuth = class _NextServerAuth extends AuthClient {
   constructor(config) {
@@ -790,12 +1120,16 @@ exports.AuthServer = AuthServer;
 exports.AuthService = AuthService;
 exports.HttpClient = HttpClient;
 exports.NextServerAuth = NextServerAuth;
+exports.TokenVerifier = TokenVerifier;
 exports.auth = auth;
 exports.authMiddleware = authMiddleware;
 exports.createAuthMiddleware = createAuthMiddleware;
+exports.createTokenVerifier = createTokenVerifier;
 exports.currentUser = currentUser;
 exports.getAuthServer = getAuthServer;
+exports.getTokenVerifier = getTokenVerifier;
 exports.redirectIfAuthenticated = redirectIfAuthenticated;
 exports.requireAuth = requireAuth;
+exports.verifyToken = verifyToken;
 //# sourceMappingURL=index.next.server.js.map
 //# sourceMappingURL=index.next.server.js.map