@push.rocks/smartipc/dist_ts/classes.ipcchannel.d.ts

A library for node inter process communication, providing an easy-to-use API for IPC.

import * as plugins from './smartipc.plugins.js';
import type { IIpcTransportOptions } from './classes.transports.js';
/**
 * Options for IPC channel
 */
export interface IIpcChannelOptions extends IIpcTransportOptions {
    /** Enable automatic reconnection */
    autoReconnect?: boolean;
    /** Initial reconnect delay in ms */
    reconnectDelay?: number;
    /** Maximum reconnect delay in ms */
    maxReconnectDelay?: number;
    /** Reconnect delay multiplier */
    reconnectMultiplier?: number;
    /** Maximum number of reconnect attempts */
    maxReconnectAttempts?: number;
    /** Enable heartbeat */
    heartbeat?: boolean;
    /** Heartbeat interval in ms */
    heartbeatInterval?: number;
    /** Heartbeat timeout in ms */
    heartbeatTimeout?: number;
    /** Initial grace period before heartbeat timeout in ms */
    heartbeatInitialGracePeriodMs?: number;
    /** Throw on heartbeat timeout (default: true, set false to emit event instead) */
    heartbeatThrowOnTimeout?: boolean;
}
/**
 * IPC Channel with connection management, auto-reconnect, and typed messaging
 */
export declare class IpcChannel<TRequest = any, TResponse = any> extends plugins.EventEmitter {
    private transport;
    private options;
    private pendingRequests;
    private messageHandlers;
    private reconnectAttempts;
    private reconnectTimer?;
    private heartbeatTimer?;
    private heartbeatCheckTimer?;
    private heartbeatGraceTimer?;
    private lastHeartbeat;
    private connectionStartTime;
    private isReconnecting;
    private isClosing;
    private metrics;
    constructor(options: IIpcChannelOptions);
    /**
     * Setup transport event handlers
     */
    private setupTransportHandlers;
    /**
     * Connect the channel
     */
    connect(): Promise<void>;
    /**
     * Disconnect the channel
     */
    disconnect(): Promise<void>;
    /**
     * Schedule a reconnection attempt
     */
    private scheduleReconnect;
    /**
     * Cancel scheduled reconnection
     */
    private cancelReconnect;
    /**
     * Start heartbeat mechanism
     */
    private startHeartbeat;
    /**
     * Start heartbeat timeout checking (separated for grace period handling)
     */
    private startHeartbeatCheck;
    /**
     * Stop heartbeat mechanism
     */
    private stopHeartbeat;
    /**
     * Handle incoming messages
     */
    private handleMessage;
    /**
     * Send a message without expecting a response
     */
    sendMessage(type: string, payload: any, headers?: Record<string, any>): Promise<void>;
    /**
     * Send a request and wait for response
     */
    request<TReq = TRequest, TRes = TResponse>(type: string, payload: TReq, options?: {
        timeout?: number;
        headers?: Record<string, any>;
    }): Promise<TRes>;
    /**
     * Register a message handler
     */
    on(event: string, handler: (payload: any) => any | Promise<any>): this;
    /**
     * Clear all pending requests
     */
    private clearPendingRequests;
    /**
     * Check if channel is connected
     */
    isConnected(): boolean;
    /**
     * Get channel statistics
     */
    getStats(): {
        connected: boolean;
        reconnectAttempts: number;
        pendingRequests: number;
        isReconnecting: boolean;
        metrics: {
            messagesSent: number;
            messagesReceived: number;
            bytesSent: number;
            bytesReceived: number;
            reconnects: number;
            heartbeatTimeouts: number;
            errors: number;
            requestTimeouts: number;
            uptime?: number;
        };
    };
}