@devgrid/netron/dist/remote-peer.d.ts

A powerful TypeScript library for building distributed systems with event bus, streaming capabilities, and remote object invocation. Features WebSocket-based bidirectional communication between Node.js and browser environments, service discovery, and type

import { Logger } from 'pino';
import { WebSocket } from 'ws';
import { Netron } from './netron';
import { Interface } from './interface';
import { Definition } from './definition';
import { AbstractPeer } from './abstract-peer';
import { NetronReadableStream } from './readable-stream';
import { NetronWritableStream } from './writable-stream';
import { NetronOptions, EventSubscriber } from './types';
import { Packet } from './packet';
export declare class RemotePeer extends AbstractPeer {
    private socket;
    private events;
    logger: Logger;
    private responseHandlers;
    writableStreams: Map<number, NetronWritableStream>;
    readableStreams: Map<number, NetronReadableStream>;
    eventSubscribers: Map<string, EventSubscriber[]>;
    remoteSubscriptions: Map<string, EventSubscriber>;
    services: Map<string, Definition>;
    definitions: Map<string, Definition>;
    constructor(socket: WebSocket, netron: Netron, id?: string);
    init(isConnector?: boolean, options?: NetronOptions): Promise<void>;
    exposeService(instance: any): Promise<any>;
    unexposeService(serviceName: string): Promise<void>;
    subscribe(eventName: string, handler: EventSubscriber): Promise<void>;
    unsubscribe(eventName: string, handler: EventSubscriber): Promise<void>;
    getServiceNames(): string[];
    get(defId: string, name: string): Promise<any>;
    set(defId: string, name: string, value: any): Promise<void>;
    call(defId: string, method: string, args: any[]): Promise<any>;
    disconnect(): void;
    once(event: 'manual-disconnect' | 'stream', listener: (...args: any[]) => void): void;
    private cleanup;
    runTask(name: string, ...args: any[]): Promise<any>;
    private sendRequest;
    private sendResponse;
    private sendErrorResponse;
    sendPacket(packet: Packet): Promise<void>;
    sendStreamChunk(streamId: number, chunk: any, index: number, isLast: boolean, isLive: boolean): Promise<void>;
    private handleResponse;
    handlePacket(packet: Packet): Promise<void>;
    protected releaseInterfaceInternal(iInstance: Interface): Promise<void>;
    refService(def: Definition, parentDef: Definition): Definition;
    unrefService(defId?: string): void;
    private processResult;
    private processArgs;
    private deleteResponseHandler;
    protected getDefinitionById(defId: string): Definition;
    protected getDefinitionByServiceName(name: string): Definition;
}