/**
 * Session Store Interface and Implementations
 *
 * Provides session management for SERV with support for
 * in-memory (development) and Redis (production) backends
 */
import type { Session, SessionCreateOptions } from '../types/index.js';
export interface SessionStore {
    /**
     * Create a new session
     */
    create(options: SessionCreateOptions): Promise<Session>;
    /**
     * Get session by ID
     */
    get(sessionId: string): Promise<Session | null>;
    /**
     * Get sessions by user ID within a tenant
     */
    getByUser(tenantId: string, userId: string): Promise<Session[]>;
    /**
     * Update last activity time (sliding expiration)
     */
    touch(sessionId: string): Promise<void>;
    /**
     * Invalidate a session
     */
    destroy(sessionId: string): Promise<void>;
    /**
     * Invalidate all sessions for a user in a tenant
     */
    destroyByUser(tenantId: string, userId: string): Promise<number>;
    /**
     * Clean up expired sessions
     */
    cleanup(): Promise<number>;
    /**
     * Close the store connection
     */
    close(): Promise<void>;
}
export interface SessionConfig {
    /** Default session TTL in seconds (default: 15 minutes) */
    defaultTtlSeconds: number;
    /** Maximum session TTL in seconds (default: 24 hours) */
    maxTtlSeconds: number;
    /** Cleanup interval in milliseconds (default: 5 minutes) */
    cleanupIntervalMs: number;
}
export declare class MemorySessionStore implements SessionStore {
    private sessions;
    private userSessions;
    private cleanupTimer?;
    private config;
    constructor(config?: Partial<SessionConfig>);
    create(options: SessionCreateOptions): Promise<Session>;
    get(sessionId: string): Promise<Session | null>;
    getByUser(tenantId: string, userId: string): Promise<Session[]>;
    touch(sessionId: string): Promise<void>;
    destroy(sessionId: string): Promise<void>;
    destroyByUser(tenantId: string, userId: string): Promise<number>;
    cleanup(): Promise<number>;
    close(): Promise<void>;
    private startCleanup;
}
export interface RedisSessionStoreOptions {
    /** Redis client instance or connection URL */
    redis: RedisClient | string;
    /** Key prefix for session storage */
    keyPrefix?: string;
    /** Session configuration */
    config?: Partial<SessionConfig>;
}
export interface RedisClient {
    get(key: string): Promise<string | null>;
    set(key: string, value: string, options?: {
        EX?: number;
    }): Promise<unknown>;
    del(key: string | string[]): Promise<number>;
    keys(pattern: string): Promise<string[]>;
    sadd(key: string, ...members: string[]): Promise<number>;
    srem(key: string, ...members: string[]): Promise<number>;
    smembers(key: string): Promise<string[]>;
    expire(key: string, seconds: number): Promise<number>;
    quit(): Promise<unknown>;
}
export declare class RedisSessionStore implements SessionStore {
    private redis;
    private keyPrefix;
    private config;
    private cleanupTimer?;
    constructor(options: RedisSessionStoreOptions);
    private sessionKey;
    private userSessionsKey;
    create(options: SessionCreateOptions): Promise<Session>;
    get(sessionId: string): Promise<Session | null>;
    getByUser(tenantId: string, userId: string): Promise<Session[]>;
    touch(sessionId: string): Promise<void>;
    destroy(sessionId: string): Promise<void>;
    destroyByUser(tenantId: string, userId: string): Promise<number>;
    cleanup(): Promise<number>;
    close(): Promise<void>;
    private startCleanup;
}
export type SessionStoreType = 'memory' | 'redis' | 'kv';
export interface CreateSessionStoreOptions {
    type: SessionStoreType;
    redis?: RedisClient;
    kv?: unknown;
    config?: Partial<SessionConfig>;
}
export declare function createSessionStore(options: CreateSessionStoreOptions): SessionStore;
//# sourceMappingURL=store.d.ts.map