@klastra/ksync/dist/types.d.ts

Real-time sync engine for modern applications with 300k+ ops/sec performance

import { z } from 'zod';
export interface KSyncEvent {
    id: string;
    type: string;
    data: any;
    timestamp: number;
    version: number;
    userId: string;
    clientId?: string;
    metadata?: Record<string, any>;
    ttl?: number;
    priority?: 'low' | 'normal' | 'high';
}
export interface StreamChunk {
    data: any;
    metadata?: Record<string, any>;
    complete?: boolean;
}
export interface StreamState {
    id: string;
    chunks: StreamChunk[];
    isComplete: boolean;
    lastSequence: number;
    content: string;
}
export type WSMessageType = 'event' | 'event-batch' | 'sync-request' | 'sync-response' | 'ping' | 'pong' | 'stream-start' | 'stream-chunk' | 'stream-end' | 'stream-complete' | 'presence-update' | 'join' | 'leave' | 'auth';
export interface WebSocketMessage {
    type: string;
    data?: any;
    events?: any[];
    room?: string;
    messageId?: string;
    timestamp?: number;
}
export interface PresenceState {
    [clientId: string]: {
        username?: string;
        lastSeen: number;
        data: Record<string, any>;
    };
}
export interface KSyncConfig {
    serverUrl?: string;
    clientId?: string;
    debug?: boolean;
    reconnectAttempts?: number;
    reconnectDelay?: number;
    presenceUpdateInterval?: number;
    eventBatchSize?: number;
    streamBufferSize?: number;
}
export interface KSyncStorage {
    saveEvents(events: KSyncEvent[]): Promise<void>;
    loadEvents(): Promise<KSyncEvent[]>;
    clear(): Promise<void>;
}
export interface KSyncSync {
    connect(): Promise<void>;
    disconnect(): Promise<void>;
    send(message: WebSocketMessage): Promise<void>;
    onMessage(handler: (message: WebSocketMessage) => void): void;
    onConnect(handler: () => void): void;
    onDisconnect(handler: () => void): void;
}
export type EventSchema<T> = z.ZodSchema<T>;
export interface EventBatch {
    events: KSyncEvent[];
    fromVersion: number;
    toVersion: number;
    timestamp: number;
}
export declare class KSyncError extends Error {
    code: string;
    constructor(message: string, code: string);
}
export interface StreamOptions {
    streamId?: string;
    bufferSize?: number;
    onChunk?: (chunk: string) => void;
    onComplete?: (fullContent: string) => void;
    onError?: (error: Error) => void;
}
export interface PresenceOptions {
    updateInterval?: number;
    data?: Record<string, any>;
}
export type EventListener<T = any> = (event: KSyncEvent) => void;
export type StreamListener = (chunk: StreamChunk) => void;
export type PresenceListener = (presence: PresenceState) => void;
export interface CRDTConfig {
    enableCRDT?: boolean;
    crdtTypes?: Record<string, 'lww' | 'gset' | 'gcounter' | 'map'>;
}
export interface PresenceInfo {
    userId: string;
    status: 'online' | 'away' | 'offline';
    lastSeen: number;
    metadata?: Record<string, any>;
}
//# sourceMappingURL=types.d.ts.map