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

Event bus, streams and remote object invocation.

import { WebSocket } from 'ws';
import { Netron } from './netron';
import { Interface } from './interface';
import { Definition } from './definition';
import { AbstractPeer } from './abstract-peer';
import { WritableStream } from './writable-stream';
import { ReadableStream } from './readable-stream';
import { Abilities, EventSubscriber } from './types';
import { Packet } from './packet';
export declare class RemotePeer extends AbstractPeer {
    private socket;
    private responseHandlers;
    writableStreams: Map<number, WritableStream>;
    readableStreams: Map<number, ReadableStream>;
    eventSubscribers: Map<string, EventSubscriber[]>;
    remoteSubscriptions: Map<string, EventSubscriber>;
    abilities: Abilities;
    services: Map<string, Definition>;
    definitions: Map<string, Definition>;
    constructor(socket: WebSocket, netron: Netron, id?: string);
    init(isConnector?: boolean, abilities?: Abilities): 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;
    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;
}