cs-element/dist/workers/plugins/NetworkPlugin.d.ts

Advanced reactive data management library with state machines, blueprints, persistence, compression, networking, and multithreading support

import { CSElementPlugin } from '../types/plugin-interfaces';
export interface PluginContext {
    element: CSElement;
    operation: string;
    [key: string]: any;
}
export interface PluginResult {
    success: boolean;
    data?: any;
    error?: string;
    [key: string]: any;
}
import { CSElement } from '../core/CSElement';
export declare enum NetworkOperation {
    SYNC = "sync",
    UPLOAD = "upload",
    DOWNLOAD = "download",
    BROADCAST = "broadcast",
    SUBSCRIBE = "subscribe",
    UNSUBSCRIBE = "unsubscribe",
    PING = "ping",
    HEARTBEAT = "heartbeat"
}
export declare enum ConnectionType {
    HTTP = "http",
    WEBSOCKET = "websocket",
    TCP = "tcp",
    UDP = "udp",
    GRPC = "grpc",
    MQTT = "mqtt"
}
export declare enum SyncStrategy {
    FULL_SYNC = "full_sync",
    INCREMENTAL_SYNC = "incremental_sync",
    CONFLICT_RESOLUTION = "conflict_resolution",
    MERGE = "merge",
    OVERWRITE = "overwrite"
}
export declare enum NetworkStatus {
    CONNECTED = "connected",
    DISCONNECTED = "disconnected",
    CONNECTING = "connecting",
    RECONNECTING = "reconnecting",
    ERROR = "error"
}
export declare enum ConflictResolution {
    LOCAL_WINS = "local_wins",
    REMOTE_WINS = "remote_wins",
    TIMESTAMP_WINS = "timestamp_wins",
    MERGE_CHANGES = "merge_changes",
    MANUAL_RESOLUTION = "manual_resolution"
}
export interface NetworkEndpoint {
    id: string;
    name: string;
    url: string;
    type: ConnectionType;
    headers?: Record<string, string>;
    authentication?: AuthenticationConfig;
    timeout: number;
    retryCount: number;
    retryDelay: number;
    isActive: boolean;
    lastConnected?: Date;
    lastError?: string;
    metadata: Record<string, any>;
}
export interface AuthenticationConfig {
    type: 'none' | 'basic' | 'bearer' | 'apikey' | 'oauth2' | 'custom';
    credentials: Record<string, string>;
    refreshToken?: string;
    expiresAt?: Date;
}
export interface SyncConfiguration {
    id: string;
    name: string;
    endpointId: string;
    strategy: SyncStrategy;
    conflictResolution: ConflictResolution;
    syncInterval: number;
    enabled: boolean;
    bidirectional: boolean;
    filterRules: SyncFilter[];
    transformRules: SyncTransform[];
    lastSync?: Date;
    nextSync?: Date;
    errorCount: number;
    maxErrors: number;
}
export interface SyncFilter {
    field: string;
    operator: 'equals' | 'not_equals' | 'contains' | 'matches' | 'greater' | 'less';
    value: any;
    include: boolean;
}
export interface SyncTransform {
    field: string;
    operation: 'rename' | 'map_value' | 'calculate' | 'format' | 'custom';
    parameters: Record<string, any>;
}
export interface NetworkRequest {
    id: string;
    operation: NetworkOperation;
    endpointId: string;
    method: string;
    path: string;
    headers: Record<string, string>;
    body?: any;
    timestamp: Date;
    timeout: number;
    retryCount: number;
    priority: number;
    metadata: Record<string, any>;
}
export interface NetworkResponse {
    requestId: string;
    status: number;
    statusText: string;
    headers: Record<string, string>;
    body: any;
    duration: number;
    timestamp: Date;
    error?: string;
}
export interface SyncResult {
    id: string;
    configId: string;
    startTime: Date;
    endTime: Date;
    success: boolean;
    strategy: SyncStrategy;
    elementsProcessed: number;
    elementsUpdated: number;
    elementsCreated: number;
    elementsDeleted: number;
    conflicts: SyncConflict[];
    errors: string[];
    statistics: SyncStatistics;
}
export interface SyncConflict {
    elementId: string;
    field: string;
    localValue: any;
    remoteValue: any;
    resolution: ConflictResolution;
    resolvedValue: any;
    timestamp: Date;
}
export interface SyncStatistics {
    totalElements: number;
    syncedElements: number;
    skippedElements: number;
    conflictedElements: number;
    dataTransferred: number;
    transferSpeed: number;
    networkLatency: number;
}
export interface NetworkConnection {
    id: string;
    endpointId: string;
    type: ConnectionType;
    status: NetworkStatus;
    connectedAt?: Date;
    lastActivity?: Date;
    messagesSent: number;
    messagesReceived: number;
    bytesTransferred: number;
    latency: number;
    errorCount: number;
    socket?: any;
}
export interface NetworkMessage {
    id: string;
    connectionId: string;
    type: 'request' | 'response' | 'event' | 'notification';
    operation: NetworkOperation;
    payload: any;
    timestamp: Date;
    priority: number;
    requiresAck: boolean;
    ackReceived?: boolean;
    timeout?: number;
}
export interface NetworkEvent {
    id: string;
    type: 'connection_established' | 'connection_lost' | 'sync_completed' | 'conflict_detected' | 'error_occurred';
    connectionId?: string;
    data: Record<string, any>;
    timestamp: Date;
}
export interface NetworkPluginConfig {
    enabled?: boolean;
    priority?: number;
    enableAutoSync: boolean;
    defaultSyncInterval: number;
    maxConcurrentConnections: number;
    connectionTimeout: number;
    requestTimeout: number;
    maxRetries: number;
    retryDelay: number;
    enableOfflineMode: boolean;
    offlineQueueSize: number;
    enableCompression: boolean;
    enableEncryption: boolean;
    heartbeatInterval: number;
    reconnectDelay: number;
    maxReconnectAttempts: number;
    enableEventLogging: boolean;
    logLevel: 'debug' | 'info' | 'warn' | 'error';
}
export interface NetworkStats {
    totalConnections: number;
    activeConnections: number;
    failedConnections: number;
    totalRequests: number;
    successfulRequests: number;
    failedRequests: number;
    totalDataTransferred: number;
    averageLatency: number;
    averageResponseTime: number;
    syncOperations: number;
    successfulSyncs: number;
    failedSyncs: number;
    conflictsResolved: number;
    offlineOperations: number;
    lastSyncTime?: Date;
    uptime: number;
    errorRate: number;
}
export declare class NetworkPlugin implements CSElementPlugin {
    readonly name = "NetworkPlugin";
    readonly version = "1.0.0";
    readonly description = "\u041F\u043B\u0430\u0433\u0438\u043D \u0434\u043B\u044F \u0441\u0435\u0442\u0435\u0432\u044B\u0445 \u043E\u043F\u0435\u0440\u0430\u0446\u0438\u0439 \u0438 \u0441\u0438\u043D\u0445\u0440\u043E\u043D\u0438\u0437\u0430\u0446\u0438\u0438 \u0434\u0430\u043D\u043D\u044B\u0445";
    private config;
    private endpoints;
    private syncConfigs;
    private connections;
    private pendingRequests;
    private requestQueue;
    private offlineQueue;
    private syncResults;
    private events;
    private stats;
    private syncTimer?;
    private heartbeatTimer?;
    private isOnline;
    constructor(config?: Partial<NetworkPluginConfig>);
    install(_CSElementClass: typeof CSElement): void;
    initialize(): Promise<void>;
    destroy(): Promise<void>;
    getConfig(): NetworkPluginConfig;
    updateConfig(newConfig: Partial<NetworkPluginConfig>): void;
    afterCreate(element: CSElement, _context: PluginContext): Promise<PluginResult>;
    afterUpdate(element: CSElement, _context: PluginContext): Promise<PluginResult>;
    afterDelete(element: CSElement, _context: PluginContext): Promise<PluginResult>;
    addEndpoint(endpointData: Omit<NetworkEndpoint, 'id'>): string;
    getEndpoint(id: string): NetworkEndpoint | undefined;
    updateEndpoint(id: string, updates: Partial<NetworkEndpoint>): boolean;
    deleteEndpoint(id: string): boolean;
    createConnection(endpointId: string): Promise<string>;
    closeConnection(connectionId: string): Promise<boolean>;
    addSyncConfig(configData: Omit<SyncConfiguration, 'id' | 'lastSync' | 'nextSync' | 'errorCount'>): string;
    getSyncConfig(id: string): SyncConfiguration | undefined;
    updateSyncConfig(id: string, updates: Partial<SyncConfiguration>): boolean;
    deleteSyncConfig(id: string): boolean;
    syncData(configId: string): Promise<SyncResult>;
    sendRequest(request: Omit<NetworkRequest, 'id' | 'timestamp'>): Promise<NetworkResponse>;
    sendMessage(connectionId: string, message: Omit<NetworkMessage, 'id' | 'timestamp'>): Promise<boolean>;
    private establishConnection;
    private establishWebSocketConnection;
    private establishTCPConnection;
    private setupWebSocketHandlers;
    private setupTCPHandlers;
    private handleIncomingMessage;
    private terminateConnection;
    private closeConnectionsByEndpoint;
    private queueElementSync;
    private shouldSyncElement;
    private getElementValue;
    private evaluateFilter;
    private executeRequest;
    private addAuthentication;
    private addAxiosAuthentication;
    private queueOfflineRequest;
    private getLocalData;
    private getRemoteData;
    private performFullSync;
    private performIncrementalSync;
    private performConflictResolution;
    private transmitMessage;
    private setupNetworkMonitoring;
    private checkNetworkStatus;
    private processOfflineQueue;
    private startAutoSync;
    private runScheduledSyncs;
    private startHeartbeat;
    private sendHeartbeats;
    private startRequestProcessor;
    private processRequestQueue;
    private calculateNextSync;
    private emitEvent;
    private updateStats;
    private log;
    private shouldLog;
    private generateId;
    getStats(): NetworkStats;
    getAllEndpoints(): NetworkEndpoint[];
    getAllSyncConfigs(): SyncConfiguration[];
    getActiveConnections(): NetworkConnection[];
    getAllConnections(): NetworkConnection[];
    getPendingRequests(): NetworkRequest[];
    getRequestQueue(): NetworkRequest[];
    getOfflineQueue(): NetworkRequest[];
    getSyncResults(): SyncResult[];
    getEvents(): NetworkEvent[];
    isNetworkOnline(): boolean;
    getConnectionStatus(connectionId: string): NetworkStatus | undefined;
}
//# sourceMappingURL=NetworkPlugin.d.ts.map