import { z } from 'zod';

interface BaseEvent {
    type: string;
    payload?: unknown;
    timestamp?: number;
    sessionId?: string;
}
declare enum ConnectionStatus {
    CONNECTING = "connecting",
    CONNECTED = "connected",
    DISCONNECTED = "disconnected",
    RECONNECTING = "reconnecting",
    ERROR = "error"
}
interface SessionMetadata {
    id: string;
    userId?: string;
    tabId?: string;
    userAgent?: string;
    ip?: string;
    connectedAt: Date;
    lastSeenAt: Date;
    metadata?: Record<string, unknown>;
}
interface SearchQuery {
    query: string;
    limit?: number;
    offset?: number;
    filters?: Record<string, unknown>;
    streaming?: boolean;
}
interface SearchResult<T = unknown> {
    id: string;
    score: number;
    data: T;
    highlights?: string[];
}
interface SearchResponse<T = unknown> {
    query: string;
    results: SearchResult<T>[];
    total: number;
    took: number;
    hasMore?: boolean;
}
interface Logger {
    debug(message: string, meta?: Record<string, unknown>): void;
    info(message: string, meta?: Record<string, unknown>): void;
    warn(message: string, meta?: Record<string, unknown>): void;
    error(message: string, meta?: Record<string, unknown>): void;
}
declare class ConsoleLogger implements Logger {
    debug(message: string, meta?: Record<string, unknown>): void;
    info(message: string, meta?: Record<string, unknown>): void;
    warn(message: string, meta?: Record<string, unknown>): void;
    error(message: string, meta?: Record<string, unknown>): void;
}
interface ServerConfig {
    port?: number;
    cors?: {
        origin?: string | string[] | boolean;
        methods?: string[];
        credentials?: boolean;
    };
    heartbeatInterval?: number;
    heartbeatTimeout?: number;
    logger?: Logger;
    adapter?: IAdapter;
    gracefulShutdownTimeout?: number;
    maxConnections?: number;
}
interface ClientConfig {
    url: string;
    autoConnect?: boolean;
    reconnection?: boolean;
    reconnectionAttempts?: number;
    reconnectionDelay?: number;
    reconnectionDelayMax?: number;
    timeout?: number;
    forceNew?: boolean;
    searchTimeout?: number;
    logger?: Logger;
    auth?: Record<string, unknown>;
}
interface IAdapter {
    setSession(sessionId: string, metadata: SessionMetadata): Promise<void>;
    getSession(sessionId: string): Promise<SessionMetadata | null>;
    deleteSession(sessionId: string): Promise<void>;
    getAllSessions(): Promise<SessionMetadata[]>;
    updateLastSeen(sessionId: string): Promise<void>;
    indexDocument(id: string, content: string, metadata?: Record<string, unknown>): Promise<void>;
    removeDocument(id: string): Promise<void>;
    search(query: SearchQuery): Promise<SearchResponse>;
    cleanup(): Promise<void>;
    disconnect(): Promise<void>;
}
interface EventMap extends Record<string, unknown> {
    connect: {
        sessionId: string;
        metadata: SessionMetadata;
    };
    disconnect: {
        sessionId: string;
        reason: string;
    };
    error: {
        sessionId: string;
        error: Error;
    };
    ping: {
        timestamp: number;
    };
    pong: {
        timestamp: number;
    };
    search: SearchQuery;
    'search-result': SearchResponse;
    'search-stream': {
        chunk: SearchResult;
        isLast: boolean;
    };
    message: {
        content: string;
        from?: string;
    };
    notification: {
        title: string;
        body: string;
        type?: string;
    };
}
interface TypedEventEmitter<T extends Record<string, unknown> = EventMap> {
    on<K extends keyof T>(event: K, listener: (data: T[K]) => void): this;
    off<K extends keyof T>(event: K, listener: (data: T[K]) => void): this;
    emit<K extends keyof T>(event: K, data: T[K]): boolean;
    once<K extends keyof T>(event: K, listener: (data: T[K]) => void): this;
    removeAllListeners<K extends keyof T>(event?: K): this;
}
declare const SessionMetadataSchema: z.ZodObject<{
    id: z.ZodString;
    userId: z.ZodOptional<z.ZodString>;
    tabId: z.ZodOptional<z.ZodString>;
    userAgent: z.ZodOptional<z.ZodString>;
    ip: z.ZodOptional<z.ZodString>;
    connectedAt: z.ZodDate;
    lastSeenAt: z.ZodDate;
    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
}, "strip", z.ZodTypeAny, {
    id: string;
    connectedAt: Date;
    lastSeenAt: Date;
    userId?: string | undefined;
    tabId?: string | undefined;
    userAgent?: string | undefined;
    ip?: string | undefined;
    metadata?: Record<string, unknown> | undefined;
}, {
    id: string;
    connectedAt: Date;
    lastSeenAt: Date;
    userId?: string | undefined;
    tabId?: string | undefined;
    userAgent?: string | undefined;
    ip?: string | undefined;
    metadata?: Record<string, unknown> | undefined;
}>;
declare const SearchQuerySchema: z.ZodObject<{
    query: z.ZodString;
    limit: z.ZodDefault<z.ZodNumber>;
    offset: z.ZodDefault<z.ZodNumber>;
    filters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
    streaming: z.ZodDefault<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    query: string;
    limit: number;
    offset: number;
    streaming: boolean;
    filters?: Record<string, unknown> | undefined;
}, {
    query: string;
    limit?: number | undefined;
    offset?: number | undefined;
    filters?: Record<string, unknown> | undefined;
    streaming?: boolean | undefined;
}>;
declare const SearchResultSchema: z.ZodObject<{
    id: z.ZodString;
    score: z.ZodNumber;
    data: z.ZodUnknown;
    highlights: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
}, "strip", z.ZodTypeAny, {
    id: string;
    score: number;
    data?: unknown;
    highlights?: string[] | undefined;
}, {
    id: string;
    score: number;
    data?: unknown;
    highlights?: string[] | undefined;
}>;
declare const SearchResponseSchema: z.ZodObject<{
    query: z.ZodString;
    results: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        score: z.ZodNumber;
        data: z.ZodUnknown;
        highlights: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
    }, "strip", z.ZodTypeAny, {
        id: string;
        score: number;
        data?: unknown;
        highlights?: string[] | undefined;
    }, {
        id: string;
        score: number;
        data?: unknown;
        highlights?: string[] | undefined;
    }>, "many">;
    total: z.ZodNumber;
    took: z.ZodNumber;
    hasMore: z.ZodOptional<z.ZodBoolean>;
}, "strip", z.ZodTypeAny, {
    query: string;
    results: {
        id: string;
        score: number;
        data?: unknown;
        highlights?: string[] | undefined;
    }[];
    total: number;
    took: number;
    hasMore?: boolean | undefined;
}, {
    query: string;
    results: {
        id: string;
        score: number;
        data?: unknown;
        highlights?: string[] | undefined;
    }[];
    total: number;
    took: number;
    hasMore?: boolean | undefined;
}>;
type EventData<T extends Record<string, unknown>, K extends keyof T> = T[K];
type ExtendEventMap<T extends Record<string, unknown>> = EventMap & T;

export { type BaseEvent as B, ConnectionStatus as C, type EventMap as E, type IAdapter as I, type Logger as L, type SessionMetadata as S, type TypedEventEmitter as T, type SearchQuery as a, type SearchResult as b, type SearchResponse as c, ConsoleLogger as d, type ServerConfig as e, type ClientConfig as f, SessionMetadataSchema as g, SearchQuerySchema as h, SearchResultSchema as i, SearchResponseSchema as j, type EventData as k, type ExtendEventMap as l };