@payez/next-mvp 3.9.1 → 4.0.1

package/dist/server/slim-middleware.js

@@ -1,89 +0,0 @@
-"use strict";
-/**
- * Slim Middleware — Cookie-Only Auth Check
- *
- * Replaces the self-fetching middleware with a cookie existence check.
- * All real auth validation happens in server-side layouts (authGuard).
- *
- * Zero self-fetches. Zero Redis calls. Zero JWT decoding.
- * Just: does the session cookie exist? Yes → pass through. No → redirect to login.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSlimMiddleware = createSlimMiddleware;
-const server_1 = require("next/server");
-const app_slug_1 = require("../lib/app-slug");
-// =============================================================================
-// DEFAULT BYPASS PATHS
-// =============================================================================
-/** Routes that must always bypass middleware (prevent infinite loops) */
-const DEFAULT_BYPASS_PREFIXES = [
-    '/api/auth/',
-    '/api/session/',
-    '/_next/',
-    '/favicon.ico',
-];
-/** Static file extensions to bypass */
-const STATIC_EXTENSIONS = /\.(svg|png|jpg|jpeg|gif|webp|ico|css|js|woff|woff2|ttf|eot|map)$/i;
-// =============================================================================
-// MAIN
-// =============================================================================
-/**
- * Create a slim middleware that only checks cookie existence.
- * Auth validation is deferred to server-side layouts (authGuard).
- */
-function createSlimMiddleware(options) {
-    const publicRoutes = options?.publicRoutes || [];
-    const loginUrl = options?.loginUrl || '/account-auth/login';
-    const extraBypass = options?.bypassPrefixes || [];
-    const allBypass = [...DEFAULT_BYPASS_PREFIXES, ...extraBypass];
-    // Pre-compile public route patterns for fast matching
-    const publicMatchers = publicRoutes.map(pattern => {
-        if (pattern.endsWith('/*')) {
-            const prefix = pattern.slice(0, -2);
-            return (p) => p === prefix || p.startsWith(prefix + '/');
-        }
-        if (pattern.endsWith('*')) {
-            const prefix = pattern.slice(0, -1);
-            return (p) => p.startsWith(prefix);
-        }
-        if (pattern.startsWith('/*.')) {
-            const ext = pattern.slice(2);
-            return (p) => p.endsWith(ext);
-        }
-        return (p) => p === pattern;
-    });
-    return function middleware(request) {
-        const { pathname } = request.nextUrl;
-        // 1. Always bypass static/internal routes
-        if (STATIC_EXTENSIONS.test(pathname)) {
-            return server_1.NextResponse.next();
-        }
-        for (const prefix of allBypass) {
-            if (pathname.startsWith(prefix)) {
-                return server_1.NextResponse.next();
-            }
-        }
-        // 2. Check if it's a public route → pass through
-        for (const matcher of publicMatchers) {
-            if (matcher(pathname)) {
-                return server_1.NextResponse.next();
-            }
-        }
-        // 3. THE ONLY AUTH CHECK: Does a session cookie exist?
-        const sessionCookieName = (0, app_slug_1.getSessionCookieName)();
-        const secureCookieName = (0, app_slug_1.getSecureSessionCookieName)();
-        const hasCookie = request.cookies.has(sessionCookieName) ||
-            request.cookies.has(secureCookieName);
-        if (!hasCookie) {
-            // No cookie on a protected route → redirect to login
-            // API routes get 401 instead of redirect
-            if (pathname.startsWith('/api/')) {
-                return server_1.NextResponse.json({ error: 'Unauthorized', message: 'No session' }, { status: 401 });
-            }
-            const callbackUrl = encodeURIComponent(pathname);
-            return server_1.NextResponse.redirect(new URL(`${loginUrl}?callbackUrl=${callbackUrl}`, request.url));
-        }
-        // Cookie exists → pass through, layout authGuard does the real validation
-        return server_1.NextResponse.next();
-    };
-}

package/dist/server/with-auth.d.ts

@@ -1,33 +0,0 @@
-/**
- * Server-Side Auth Wrapper for API Routes & Server Actions
- *
- * Wraps route handlers with session validation. Uses direct Redis reads.
- * Zero HTTP self-fetches.
- *
- * Usage:
- *   export const GET = withAuth(async (req, auth) => {
- *     return NextResponse.json({ userId: auth.userId });
- *   });
- *
- *   // With role requirement:
- *   export const POST = withAuth(async (req, auth) => { ... }, { requiredRoles: ['admin'] });
- */
-import 'server-only';
-import { NextRequest, NextResponse } from 'next/server';
-import type { SessionData } from '../lib/session-store';
-export interface ApiAuthResult {
-    userId: string;
-    email: string;
-    roles: string[];
-    sessionData: SessionData;
-    accessToken?: string;
-}
-export interface WithAuthOptions {
-    /** Roles required to access the route (any match = allowed) */
-    requiredRoles?: string[];
-}
-/**
- * Wrap an API route handler with auth validation.
- * Returns 401 if not authenticated, 403 if missing required roles.
- */
-export declare function withAuth(handler: (req: NextRequest, auth: ApiAuthResult) => Promise<NextResponse>, options?: WithAuthOptions): (req: NextRequest) => Promise<NextResponse>;

package/dist/server/with-auth.js

@@ -1,59 +0,0 @@
-"use strict";
-/**
- * Server-Side Auth Wrapper for API Routes & Server Actions
- *
- * Wraps route handlers with session validation. Uses direct Redis reads.
- * Zero HTTP self-fetches.
- *
- * Usage:
- *   export const GET = withAuth(async (req, auth) => {
- *     return NextResponse.json({ userId: auth.userId });
- *   });
- *
- *   // With role requirement:
- *   export const POST = withAuth(async (req, auth) => { ... }, { requiredRoles: ['admin'] });
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.withAuth = withAuth;
-require("server-only");
-const server_1 = require("next/server");
-const decode_session_1 = require("./decode-session");
-// =============================================================================
-// MAIN
-// =============================================================================
-/**
- * Wrap an API route handler with auth validation.
- * Returns 401 if not authenticated, 403 if missing required roles.
- */
-function withAuth(handler, options) {
-    return async (req) => {
-        try {
-            // Decode session from request cookies (direct Redis, no self-fetch)
-            const decoded = await (0, decode_session_1.decodeSession)(req.cookies);
-            if (!decoded) {
-                return server_1.NextResponse.json({ error: 'Unauthorized', message: 'No valid session' }, { status: 401 });
-            }
-            const { sessionData } = decoded;
-            // Check required roles
-            if (options?.requiredRoles && options.requiredRoles.length > 0) {
-                const userRoles = sessionData.roles || [];
-                const hasRole = options.requiredRoles.some(r => userRoles.includes(r));
-                if (!hasRole) {
-                    return server_1.NextResponse.json({ error: 'Forbidden', message: 'Insufficient permissions' }, { status: 403 });
-                }
-            }
-            const auth = {
-                userId: sessionData.userId,
-                email: sessionData.email,
-                roles: sessionData.roles || [],
-                sessionData,
-                accessToken: sessionData.idpAccessToken,
-            };
-            return handler(req, auth);
-        }
-        catch (error) {
-            console.error('[WITH-AUTH] Error:', error instanceof Error ? error.message : String(error));
-            return server_1.NextResponse.json({ error: 'Internal Server Error', message: 'Auth check failed' }, { status: 500 });
-        }
-    };
-}

package/dist/services/signalrActivityService.d.ts

@@ -1,44 +0,0 @@
-export interface HealthStatus {
-    isHealthy: boolean;
-    message: string;
-    lastHeartbeat: Date | null;
-    connectionId: string | null | undefined;
-    responseTime?: string;
-}
-export type HealthStatusCallback = (status: HealthStatus) => void;
-/**
- * SignalR-based health service following Occam's Razor principle:
- * - If SignalR connection is alive = Service is working
- * - If SignalR connection is dead = Service is not working
- * - No complex orchestration, just connection state monitoring
- */
-declare class SignalRActivityService {
-    private connection;
-    private subscribers;
-    private currentStatus;
-    private heartbeatTimeout;
-    private readonly heartbeatTimeoutMs;
-    /**
-     * Start the health monitoring connection
-     * @param idpBaseUrl - The base URL of the IDP server (e.g., 'http://localhost:32785')
-     */
-    start(idpBaseUrl: string): Promise<void>;
-    /**
-     * Stop the health monitoring connection
-     */
-    stop(): Promise<void>;
-    /**
-     * Subscribe to health status changes
-     */
-    subscribe(callback: HealthStatusCallback): () => void;
-    /**
-     * Get current health status
-     */
-    getCurrentStatus(): HealthStatus;
-    private updateStatus;
-    private notifySubscribers;
-    private resetHeartbeatTimeout;
-    private clearHeartbeatTimeout;
-}
-export declare const signalRActivityService: SignalRActivityService;
-export {};

package/dist/services/signalrActivityService.js

@@ -1,257 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.signalRActivityService = void 0;
-const signalR = __importStar(require("@microsoft/signalr"));
-/**
- * SignalR-based health service following Occam's Razor principle:
- * - If SignalR connection is alive = Service is working
- * - If SignalR connection is dead = Service is not working
- * - No complex orchestration, just connection state monitoring
- */
-class SignalRActivityService {
-    connection = null;
-    subscribers = new Set();
-    currentStatus = {
-        isHealthy: false,
-        message: 'Disconnected',
-        lastHeartbeat: null,
-        connectionId: null
-    };
-    heartbeatTimeout = null;
-    heartbeatTimeoutMs = 45000; // 45 seconds (server sends every 30s)
-    /**
-     * Start the health monitoring connection
-     * @param idpBaseUrl - The base URL of the IDP server (e.g., 'http://localhost:32785')
-     */
-    async start(idpBaseUrl) {
-        // If we already have a connected or connecting connection, don't start again
-        if (this.connection &&
-            (this.connection.state === signalR.HubConnectionState.Connected ||
-                this.connection.state === signalR.HubConnectionState.Connecting)) {
-            console.info('[SignalRHealth] Connection already active, skipping start');
-            return;
-        }
-        // Stop existing connection if it exists
-        if (this.connection) {
-            await this.stop();
-        }
-        try {
-            if (!idpBaseUrl) {
-                throw new Error('IDP base URL is required for health monitoring');
-            }
-            // Construct absolute hub URL safely
-            const activityHubUrl = new URL('/healthHub', idpBaseUrl).toString();
-            console.info('[SignalRHealth] Using hub URL:', activityHubUrl);
-            this.connection = new signalR.HubConnectionBuilder()
-                .withUrl(activityHubUrl, {
-                withCredentials: false,
-                transport: signalR.HttpTransportType.WebSockets | signalR.HttpTransportType.ServerSentEvents | signalR.HttpTransportType.LongPolling,
-            })
-                .withAutomaticReconnect({
-                nextRetryDelayInMilliseconds: (retryContext) => {
-                    // More conservative backoff: 5s, 15s, 45s, then stop trying
-                    const delays = [5000, 15000, 45000];
-                    if (retryContext.previousRetryCount >= delays.length) {
-                        return null; // Stop automatic reconnection
-                    }
-                    return delays[retryContext.previousRetryCount];
-                }
-            })
-                .configureLogging(signalR.LogLevel.Critical) // Only critical errors, hide connection noise
-                .build();
-            // Handle connection events
-            this.connection.onclose(() => {
-                this.updateStatus({
-                    isHealthy: false,
-                    message: 'Service unavailable',
-                    lastHeartbeat: null,
-                    connectionId: null
-                });
-                this.clearHeartbeatTimeout();
-            });
-            this.connection.onreconnecting(() => {
-                this.updateStatus({
-                    isHealthy: false,
-                    message: 'Service unavailable',
-                    lastHeartbeat: this.currentStatus.lastHeartbeat,
-                    connectionId: null
-                });
-            });
-            this.connection.onreconnected((connectionId) => {
-                this.updateStatus({
-                    isHealthy: true,
-                    message: 'Service operational',
-                    lastHeartbeat: new Date(),
-                    connectionId
-                });
-                this.resetHeartbeatTimeout();
-            });
-            // Handle heartbeat messages - this is the core health indicator
-            this.connection.on('Heartbeat', (data) => {
-                this.updateStatus({
-                    isHealthy: true,
-                    message: 'Service operational',
-                    lastHeartbeat: new Date(),
-                    connectionId: this.connection?.connectionId || null
-                });
-                this.resetHeartbeatTimeout();
-            });
-            // Handle initial health status
-            this.connection.on('HealthStatus', (data) => {
-                this.updateStatus({
-                    isHealthy: data.status === 'healthy',
-                    message: data.message || 'Service connected',
-                    lastHeartbeat: new Date(),
-                    connectionId: this.connection?.connectionId || null
-                });
-                this.resetHeartbeatTimeout();
-            });
-            // Start the connection
-            await this.connection.start();
-            console.info('[SignalRHealth] Connection started, connectionId:', this.connection.connectionId);
-            this.updateStatus({
-                isHealthy: true,
-                message: 'Service connected',
-                lastHeartbeat: new Date(),
-                connectionId: this.connection.connectionId
-            });
-            this.resetHeartbeatTimeout();
-        }
-        catch (error) {
-            // Reduce console noise for expected connection failures
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            console.warn('[SignalRHealth] Connection start failed:', errorMessage);
-            const isConnectionRefused = errorMessage.includes('ERR_CONNECTION_REFUSED') ||
-                errorMessage.includes('Failed to fetch') ||
-                errorMessage.includes('Failed to complete negotiation');
-            if (isConnectionRefused) {
-                // Service is down - this is expected, log at info level
-                console.info('SignalR Health Service: Backend service unavailable');
-            }
-            else {
-                // Unexpected error - log as error
-                console.error('SignalR Health Service failed to start:', error);
-            }
-            this.updateStatus({
-                isHealthy: false,
-                message: 'Service unavailable',
-                lastHeartbeat: null,
-                connectionId: null
-            });
-        }
-    }
-    /**
-     * Stop the health monitoring connection
-     */
-    async stop() {
-        this.clearHeartbeatTimeout();
-        if (this.connection) {
-            try {
-                // Check if connection is in a state that can be stopped
-                if (this.connection.state !== signalR.HubConnectionState.Disconnected) {
-                    await this.connection.stop();
-                }
-            }
-            catch (error) {
-                // Ignore "connection was stopped before the hub handshake could complete" errors
-                // as these are expected during rapid start/stop cycles
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                if (!errorMessage.includes('stopped before the hub handshake could complete')) {
-                    console.error('Error stopping SignalR health connection:', error);
-                }
-            }
-            this.connection = null;
-        }
-        this.updateStatus({
-            isHealthy: false,
-            message: 'Disconnected',
-            lastHeartbeat: null,
-            connectionId: null
-        });
-    }
-    /**
-     * Subscribe to health status changes
-     */
-    subscribe(callback) {
-        this.subscribers.add(callback);
-        // Immediately notify with current status
-        callback(this.currentStatus);
-        // Return unsubscribe function
-        return () => {
-            this.subscribers.delete(callback);
-        };
-    }
-    /**
-     * Get current health status
-     */
-    getCurrentStatus() {
-        return { ...this.currentStatus };
-    }
-    updateStatus(newStatus) {
-        this.currentStatus = newStatus;
-        this.notifySubscribers();
-    }
-    notifySubscribers() {
-        this.subscribers.forEach(callback => {
-            try {
-                callback(this.currentStatus);
-            }
-            catch (error) {
-                console.error('Error in health status subscriber:', error);
-            }
-        });
-    }
-    resetHeartbeatTimeout() {
-        this.clearHeartbeatTimeout();
-        // If we don't receive a heartbeat within the timeout period, consider service unhealthy
-        this.heartbeatTimeout = setTimeout(() => {
-            this.updateStatus({
-                isHealthy: false,
-                message: 'Service unavailable',
-                lastHeartbeat: this.currentStatus.lastHeartbeat,
-                connectionId: this.currentStatus.connectionId
-            });
-        }, this.heartbeatTimeoutMs);
-    }
-    clearHeartbeatTimeout() {
-        if (this.heartbeatTimeout) {
-            clearTimeout(this.heartbeatTimeout);
-            this.heartbeatTimeout = null;
-        }
-    }
-}
-// Export singleton instance
-exports.signalRActivityService = new SignalRActivityService();

package/dist/stores/authStore.d.ts

@@ -1,154 +0,0 @@
-/**
- * 🚀 CENTRALIZED AUTH STORE - THE SINGLE SOURCE OF TRUTH
- *
- * This Zustand store replaces ALL scattered useState patterns for auth-related state.
- * No more prop drilling, no more duplicate loading states, no more auth chaos.
- *
- * Features:
- * - Centralized session, token, and user state
- * - Built-in API calling with auto token refresh
- * - Loading state management for all async operations
- * - Type-safe throughout
- * - Integrates seamlessly with existing NextAuth
- */
-import { AppSession } from '../lib/session';
-import { HubConnection, HubConnectionState } from '@microsoft/signalr';
-export interface User {
-    id: string;
-    email: string;
-    roles: string[];
-    twoFactorSessionVerified: boolean;
-    requiresTwoFactor: boolean;
-    twoFactorMethod?: string;
-    authenticationMethods?: string[];
-    authenticationLevel?: string;
-    isApproved: boolean;
-    isSuspended: boolean;
-    lockoutEnabled: boolean;
-    lockoutEnd?: Date | null;
-    pausedAt?: Date | null;
-    pausedBy?: string | null;
-    suspensionReason?: string | null;
-}
-export interface UserStateChangeEvent {
-    userId: string;
-    action: 'APPROVE' | 'DISAPPROVE' | 'PAUSE' | 'RESUME' | 'HALT' | 'UNLOCK';
-    newState: {
-        isApproved?: boolean;
-        isSuspended?: boolean;
-        lockoutEnabled?: boolean;
-        lockoutEnd?: string | null;
-        pausedAt?: string | null;
-        pausedBy?: string | null;
-        suspensionReason?: string | null;
-    };
-    reason?: string;
-    changedBy: string;
-    timestamp: string;
-}
-export interface SecurityNotificationEvent {
-    type: 'USER_LOCKOUT' | 'IP_THROTTLE' | 'BRUTE_FORCE' | 'DISTRIBUTED_ATTACK';
-    userId?: string;
-    ipAddress?: string;
-    message: string;
-    severity: 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL';
-    timestamp: string;
-}
-export interface AuthState {
-    session: AppSession | null;
-    user: User | null;
-    accessToken: string | null;
-    refreshToken: string | null;
-    isAuthenticated: boolean;
-    isInitialized: boolean;
-    isLoading: boolean;
-    isRefreshingToken: boolean;
-    isLoadingUserStats: boolean;
-    isLoadingClients: boolean;
-    isLoadingRoles: boolean;
-    isLoadingUsers: boolean;
-    isLoadingUserDetails: Record<string, boolean>;
-    isLoadingRoleCategories: boolean;
-    isLoadingUserAssignments: Record<string, boolean>;
-    isLoadingClientAuthorizations: Record<string, boolean>;
-    error: string | null;
-    tokenError: string | null;
-    userStats: any | null;
-    clients: any[] | null;
-    roles: any[] | null;
-    users: any[] | null;
-    userDetails: Record<string, any>;
-    userAssignments: Record<string, any>;
-    roleCategories: any[] | null;
-    clientAuthorizations: Record<string, any[] | undefined>;
-    userStatsLastFetch: number | null;
-    clientsLastFetch: number | null;
-    rolesLastFetch: number | null;
-    usersLastFetch: number | null;
-    roleCategoriesLastFetch: number | null;
-    signalrConnection: HubConnection | null;
-    signalrConnectionState: HubConnectionState;
-    isConnectedToSignalR: boolean;
-}
-export interface AuthActions {
-    setSession: (session: AppSession | null) => void;
-    clearSession: () => void;
-    refreshSession: () => Promise<void>;
-    refreshTokens: () => Promise<void>;
-    rehydrateSessionAfterRefresh: () => Promise<void>;
-    signIn: (credentials: {
-        email: string;
-        password: string;
-    }) => Promise<boolean>;
-    signOut: () => Promise<void>;
-    forceLogoutAndRedirect: (reason: string) => Promise<void>;
-    apiCall: <T = any>(url: string, options?: RequestInit, maxRetries?: number) => Promise<T>;
-    makeApiCall: <T = any>(url: string, options?: RequestInit, attempt?: number) => Promise<T>;
-    fetchUserStats: (force?: boolean) => Promise<void>;
-    fetchClients: (force?: boolean) => Promise<void>;
-    fetchRoles: (force?: boolean) => Promise<void>;
-    fetchUsers: (params?: any, force?: boolean) => Promise<void>;
-    fetchUserDetails: (userId: string, force?: boolean) => Promise<void>;
-    fetchUserClientAuthorizations: (userId: string, force?: boolean) => Promise<void>;
-    fetchUserRoleAssignments: (userId: string, force?: boolean) => Promise<void>;
-    fetchRoleCategories: (force?: boolean) => Promise<void>;
-    createUser: (userData: any) => Promise<any>;
-    updateUser: (userId: string, updates: any) => Promise<any>;
-    deleteUser: (userId: string) => Promise<void>;
-    createRole: (roleData: any) => Promise<any>;
-    updateRole: (roleId: string, updates: any) => Promise<any>;
-    deleteRole: (roleId: string) => Promise<void>;
-    assignUserToRole: (userId: string, roleId: string) => Promise<void>;
-    removeUserFromRole: (userId: string, roleId: string) => Promise<void>;
-    assignUserToClient: (userId: string, clientId: string) => Promise<void>;
-    removeUserFromClient: (userId: string, clientId: string) => Promise<void>;
-    hasRole: (role: string) => boolean;
-    hasAnyRole: (roles: string[]) => boolean;
-    hasAllRoles: (roles: string[]) => boolean;
-    isFullyAuthenticated: () => boolean;
-    setError: (error: string | null) => void;
-    clearError: () => void;
-    approveUser: (userId: string, reason?: string) => Promise<void>;
-    disapproveUser: (userId: string, reason?: string) => Promise<void>;
-    pauseUser: (userId: string, reason?: string) => Promise<void>;
-    resumeUser: (userId: string) => Promise<void>;
-    haltUser: (userId: string, reason?: string) => Promise<void>;
-    unlockUser: (userId: string) => Promise<void>;
-    canUserAccess: () => boolean;
-    getUserStateDisplay: () => string;
-    isUserLocked: () => boolean;
-    initializeSignalR: () => Promise<void>;
-    disconnectSignalR: () => Promise<void>;
-    handleUserStateChanged: (data: UserStateChangeEvent) => void;
-}
-export type AuthStore = AuthState & AuthActions;
-export declare const useAuthStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<AuthStore>, "setState"> & {
-    setState<A extends string | {
-        type: string;
-    }>(partial: AuthStore | Partial<AuthStore> | ((state: AuthStore) => AuthStore | Partial<AuthStore>), replace?: boolean | undefined, action?: A | undefined): void;
-}>;
-/**
- * Initialize the auth store with a session (typically called in layout)
- */
-export declare const initializeAuthStore: (session: AppSession | null) => void;
-export default useAuthStore;