@streamr/dht 103.1.2 → 103.2.0-experiment.0

package/dist/exports-browser.d.ts

@@ -0,0 +1,1321 @@
+import { BrandedString, MetricsContext } from '@streamr/utils';
+import { EventEmitter } from 'eventemitter3';
+import { MessageType, IMessageType, BinaryReadOptions, JsonWriteOptions, JsonValue, JsonReadOptions, PartialMessage, IBinaryReader, IBinaryWriter, BinaryWriteOptions } from '@protobuf-ts/runtime';
+import { ProtoRpcOptions, ProtoCallContext, RpcCommunicator, RpcCommunicatorOptions, ClassType, ClientTransport, ProtoRpcClient } from '@streamr/proto-rpc';
+import { ServiceInfo } from '@protobuf-ts/runtime-rpc';
+import { w3cwebsocket } from 'websocket';
+
+declare class Any$Type extends MessageType<Any> {
+    constructor();
+    /**
+     * Pack the message into a new `Any`.
+     *
+     * Uses 'type.googleapis.com/full.type.name' as the type URL.
+     */
+    pack<T extends object>(message: T, type: IMessageType<T>): Any;
+    /**
+     * Unpack the message from the `Any`.
+     */
+    unpack<T extends object>(any: Any, type: IMessageType<T>, options?: Partial<BinaryReadOptions>): T;
+    /**
+     * Does the given `Any` contain a packed message of the given type?
+     */
+    contains(any: Any, type: IMessageType<any> | string): boolean;
+    /**
+     * Convert the message to canonical JSON value.
+     *
+     * You have to provide the `typeRegistry` option so that the
+     * packed message can be converted to JSON.
+     *
+     * The `typeRegistry` option is also required to read
+     * `google.protobuf.Any` from JSON format.
+     */
+    internalJsonWrite(any: Any, options: JsonWriteOptions): JsonValue;
+    internalJsonRead(json: JsonValue, options: JsonReadOptions, target?: Any): Any;
+    typeNameToUrl(name: string): string;
+    typeUrlToName(url: string): string;
+    create(value?: PartialMessage<Any>): Any;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Any): Any;
+    internalBinaryWrite(message: Any, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * `Any` contains an arbitrary serialized protocol buffer message along with a
+ * URL that describes the type of the serialized message.
+ *
+ * Protobuf library provides support to pack/unpack Any values in the form
+ * of utility functions or additional generated methods of the Any type.
+ *
+ * Example 1: Pack and unpack a message in C++.
+ *
+ *     Foo foo = ...;
+ *     Any any;
+ *     any.PackFrom(foo);
+ *     ...
+ *     if (any.UnpackTo(&foo)) {
+ *       ...
+ *     }
+ *
+ * Example 2: Pack and unpack a message in Java.
+ *
+ *     Foo foo = ...;
+ *     Any any = Any.pack(foo);
+ *     ...
+ *     if (any.is(Foo.class)) {
+ *       foo = any.unpack(Foo.class);
+ *     }
+ *     // or ...
+ *     if (any.isSameTypeAs(Foo.getDefaultInstance())) {
+ *       foo = any.unpack(Foo.getDefaultInstance());
+ *     }
+ *
+ *  Example 3: Pack and unpack a message in Python.
+ *
+ *     foo = Foo(...)
+ *     any = Any()
+ *     any.Pack(foo)
+ *     ...
+ *     if any.Is(Foo.DESCRIPTOR):
+ *       any.Unpack(foo)
+ *       ...
+ *
+ *  Example 4: Pack and unpack a message in Go
+ *
+ *      foo := &pb.Foo{...}
+ *      any, err := anypb.New(foo)
+ *      if err != nil {
+ *        ...
+ *      }
+ *      ...
+ *      foo := &pb.Foo{}
+ *      if err := any.UnmarshalTo(foo); err != nil {
+ *        ...
+ *      }
+ *
+ * The pack methods provided by protobuf library will by default use
+ * 'type.googleapis.com/full.type.name' as the type URL and the unpack
+ * methods only use the fully qualified type name after the last '/'
+ * in the type URL, for example "foo.bar.com/x/y.z" will yield type
+ * name "y.z".
+ *
+ * JSON
+ * ====
+ * The JSON representation of an `Any` value uses the regular
+ * representation of the deserialized, embedded message, with an
+ * additional field `@type` which contains the type URL. Example:
+ *
+ *     package google.profile;
+ *     message Person {
+ *       string first_name = 1;
+ *       string last_name = 2;
+ *     }
+ *
+ *     {
+ *       "@type": "type.googleapis.com/google.profile.Person",
+ *       "firstName": <string>,
+ *       "lastName": <string>
+ *     }
+ *
+ * If the embedded message type is well-known and has a custom JSON
+ * representation, that representation will be embedded adding a field
+ * `value` which holds the custom JSON in addition to the `@type`
+ * field. Example (for message [google.protobuf.Duration][]):
+ *
+ *     {
+ *       "@type": "type.googleapis.com/google.protobuf.Duration",
+ *       "value": "1.212s"
+ *     }
+ *
+ *
+ * @generated from protobuf message google.protobuf.Any
+ */
+interface Any {
+    /**
+     * A URL/resource name that uniquely identifies the type of the serialized
+     * protocol buffer message. This string must contain at least
+     * one "/" character. The last segment of the URL's path must represent
+     * the fully qualified name of the type (as in
+     * `path/google.protobuf.Duration`). The name should be in a canonical form
+     * (e.g., leading "." is not accepted).
+     *
+     * In practice, teams usually precompile into the binary all types that they
+     * expect it to use in the context of Any. However, for URLs which use the
+     * scheme `http`, `https`, or no scheme, one can optionally set up a type
+     * server that maps type URLs to message definitions as follows:
+     *
+     * * If no scheme is provided, `https` is assumed.
+     * * An HTTP GET on the URL must yield a [google.protobuf.Type][]
+     *   value in binary format, or produce an error.
+     * * Applications are allowed to cache lookup results based on the
+     *   URL, or have them precompiled into a binary to avoid any
+     *   lookup. Therefore, binary compatibility needs to be preserved
+     *   on changes to types. (Use versioned type names to manage
+     *   breaking changes.)
+     *
+     * Note: this functionality is not currently available in the official
+     * protobuf release, and it is not used for type URLs beginning with
+     * type.googleapis.com. As of May 2023, there are no widely used type server
+     * implementations and no plans to implement one.
+     *
+     * Schemes other than `http`, `https` (or the empty scheme) might be
+     * used with implementation specific semantics.
+     *
+     *
+     * @generated from protobuf field: string type_url = 1
+     */
+    typeUrl: string;
+    /**
+     * Must be a valid serialized protocol buffer of the above specified type.
+     *
+     * @generated from protobuf field: bytes value = 2
+     */
+    value: Uint8Array;
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.Any
+ */
+declare const Any: Any$Type;
+
+/**
+ * @generated from protobuf enum protorpc.RpcErrorType
+ */
+declare enum RpcErrorType {
+    /**
+     * @generated from protobuf enum value: SERVER_TIMEOUT = 0;
+     */
+    SERVER_TIMEOUT = 0,
+    /**
+     * @generated from protobuf enum value: CLIENT_TIMEOUT = 1;
+     */
+    CLIENT_TIMEOUT = 1,
+    /**
+     * @generated from protobuf enum value: UNKNOWN_RPC_METHOD = 2;
+     */
+    UNKNOWN_RPC_METHOD = 2,
+    /**
+     * @generated from protobuf enum value: CLIENT_ERROR = 3;
+     */
+    CLIENT_ERROR = 3,
+    /**
+     * @generated from protobuf enum value: SERVER_ERROR = 4;
+     */
+    SERVER_ERROR = 4
+}
+declare class RpcMessage$Type extends MessageType<RpcMessage> {
+    constructor();
+}
+/**
+ * @generated from protobuf message protorpc.RpcMessage
+ */
+interface RpcMessage {
+    /**
+     * @generated from protobuf field: map<string, string> header = 1
+     */
+    header: {
+        [key: string]: string;
+    };
+    /**
+     * @generated from protobuf field: google.protobuf.Any body = 2
+     */
+    body?: Any;
+    /**
+     * @generated from protobuf field: string requestId = 3
+     */
+    requestId: string;
+    /**
+     * @generated from protobuf field: optional protorpc.RpcErrorType errorType = 4
+     */
+    errorType?: RpcErrorType;
+    /**
+     * @generated from protobuf field: optional string errorClassName = 5
+     */
+    errorClassName?: string;
+    /**
+     * @generated from protobuf field: optional string errorCode = 6
+     */
+    errorCode?: string;
+    /**
+     * @generated from protobuf field: optional string errorMessage = 7
+     */
+    errorMessage?: string;
+}
+/**
+ * @generated MessageType for protobuf message protorpc.RpcMessage
+ */
+declare const RpcMessage: RpcMessage$Type;
+
+declare class Timestamp$Type extends MessageType<Timestamp> {
+    constructor();
+    /**
+     * Creates a new `Timestamp` for the current time.
+     */
+    now(): Timestamp;
+    /**
+     * Converts a `Timestamp` to a JavaScript Date.
+     */
+    toDate(message: Timestamp): Date;
+    /**
+     * Converts a JavaScript Date to a `Timestamp`.
+     */
+    fromDate(date: Date): Timestamp;
+    /**
+     * In JSON format, the `Timestamp` type is encoded as a string
+     * in the RFC 3339 format.
+     */
+    internalJsonWrite(message: Timestamp, options: JsonWriteOptions): JsonValue;
+    /**
+     * In JSON format, the `Timestamp` type is encoded as a string
+     * in the RFC 3339 format.
+     */
+    internalJsonRead(json: JsonValue, options: JsonReadOptions, target?: Timestamp): Timestamp;
+    create(value?: PartialMessage<Timestamp>): Timestamp;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Timestamp): Timestamp;
+    internalBinaryWrite(message: Timestamp, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * A Timestamp represents a point in time independent of any time zone or local
+ * calendar, encoded as a count of seconds and fractions of seconds at
+ * nanosecond resolution. The count is relative to an epoch at UTC midnight on
+ * January 1, 1970, in the proleptic Gregorian calendar which extends the
+ * Gregorian calendar backwards to year one.
+ *
+ * All minutes are 60 seconds long. Leap seconds are "smeared" so that no leap
+ * second table is needed for interpretation, using a [24-hour linear
+ * smear](https://developers.google.com/time/smear).
+ *
+ * The range is from 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. By
+ * restricting to that range, we ensure that we can convert to and from [RFC
+ * 3339](https://www.ietf.org/rfc/rfc3339.txt) date strings.
+ *
+ * # Examples
+ *
+ * Example 1: Compute Timestamp from POSIX `time()`.
+ *
+ *     Timestamp timestamp;
+ *     timestamp.set_seconds(time(NULL));
+ *     timestamp.set_nanos(0);
+ *
+ * Example 2: Compute Timestamp from POSIX `gettimeofday()`.
+ *
+ *     struct timeval tv;
+ *     gettimeofday(&tv, NULL);
+ *
+ *     Timestamp timestamp;
+ *     timestamp.set_seconds(tv.tv_sec);
+ *     timestamp.set_nanos(tv.tv_usec * 1000);
+ *
+ * Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
+ *
+ *     FILETIME ft;
+ *     GetSystemTimeAsFileTime(&ft);
+ *     UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
+ *
+ *     // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
+ *     // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
+ *     Timestamp timestamp;
+ *     timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
+ *     timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
+ *
+ * Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
+ *
+ *     long millis = System.currentTimeMillis();
+ *
+ *     Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
+ *         .setNanos((int) ((millis % 1000) * 1000000)).build();
+ *
+ * Example 5: Compute Timestamp from Java `Instant.now()`.
+ *
+ *     Instant now = Instant.now();
+ *
+ *     Timestamp timestamp =
+ *         Timestamp.newBuilder().setSeconds(now.getEpochSecond())
+ *             .setNanos(now.getNano()).build();
+ *
+ * Example 6: Compute Timestamp from current time in Python.
+ *
+ *     timestamp = Timestamp()
+ *     timestamp.GetCurrentTime()
+ *
+ * # JSON Mapping
+ *
+ * In JSON format, the Timestamp type is encoded as a string in the
+ * [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
+ * format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
+ * where {year} is always expressed using four digits while {month}, {day},
+ * {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
+ * seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
+ * are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
+ * is required. A proto3 JSON serializer should always use UTC (as indicated by
+ * "Z") when printing the Timestamp type and a proto3 JSON parser should be
+ * able to accept both UTC and other timezones (as indicated by an offset).
+ *
+ * For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
+ * 01:30 UTC on January 15, 2017.
+ *
+ * In JavaScript, one can convert a Date object to this format using the
+ * standard
+ * [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString)
+ * method. In Python, a standard `datetime.datetime` object can be converted
+ * to this format using
+ * [`strftime`](https://docs.python.org/2/library/time.html#time.strftime) with
+ * the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one can use
+ * the Joda Time's [`ISODateTimeFormat.dateTime()`](
+ * http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime()
+ * ) to obtain a formatter capable of generating timestamps in this format.
+ *
+ *
+ * @generated from protobuf message google.protobuf.Timestamp
+ */
+interface Timestamp {
+    /**
+     * Represents seconds of UTC time since Unix epoch 1970-01-01T00:00:00Z. Must
+     * be between -315576000000 and 315576000000 inclusive (which corresponds to
+     * 0001-01-01T00:00:00Z to 9999-12-31T23:59:59Z).
+     *
+     * @generated from protobuf field: int64 seconds = 1
+     */
+    seconds: number;
+    /**
+     * Non-negative fractions of a second at nanosecond resolution. This field is
+     * the nanosecond portion of the duration, not an alternative to seconds.
+     * Negative second values with fractions must still have non-negative nanos
+     * values that count forward in time. Must be between 0 and 999,999,999
+     * inclusive.
+     *
+     * @generated from protobuf field: int32 nanos = 2
+     */
+    nanos: number;
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.Timestamp
+ */
+declare const Timestamp: Timestamp$Type;
+
+/**
+ * @generated from protobuf enum dht.RecursiveOperation
+ */
+declare enum RecursiveOperation {
+    /**
+     * @generated from protobuf enum value: FIND_CLOSEST_NODES = 0;
+     */
+    FIND_CLOSEST_NODES = 0,
+    /**
+     * @generated from protobuf enum value: FETCH_DATA = 1;
+     */
+    FETCH_DATA = 1,
+    /**
+     * @generated from protobuf enum value: DELETE_DATA = 2;
+     */
+    DELETE_DATA = 2
+}
+/**
+ * @generated from protobuf enum dht.NodeType
+ */
+declare enum NodeType {
+    /**
+     * @generated from protobuf enum value: NODEJS = 0;
+     */
+    NODEJS = 0,
+    /**
+     * @generated from protobuf enum value: BROWSER = 1;
+     */
+    BROWSER = 1
+}
+/**
+ * @generated from protobuf enum dht.HandshakeError
+ */
+declare enum HandshakeError {
+    /**
+     * @generated from protobuf enum value: DUPLICATE_CONNECTION = 0;
+     */
+    DUPLICATE_CONNECTION = 0,
+    /**
+     * @generated from protobuf enum value: INVALID_TARGET_PEER_DESCRIPTOR = 1;
+     */
+    INVALID_TARGET_PEER_DESCRIPTOR = 1,
+    /**
+     * @generated from protobuf enum value: UNSUPPORTED_PROTOCOL_VERSION = 2;
+     */
+    UNSUPPORTED_PROTOCOL_VERSION = 2
+}
+declare class DataEntry$Type extends MessageType<DataEntry> {
+    constructor();
+}
+/**
+ * @generated from protobuf message dht.DataEntry
+ */
+interface DataEntry {
+    /**
+     * @generated from protobuf field: bytes key = 1
+     */
+    key: Uint8Array;
+    /**
+     * @generated from protobuf field: google.protobuf.Any data = 2
+     */
+    data?: Any;
+    /**
+     * @generated from protobuf field: bytes creator = 3
+     */
+    creator: Uint8Array;
+    /**
+     * @generated from protobuf field: google.protobuf.Timestamp createdAt = 4
+     */
+    createdAt?: Timestamp;
+    /**
+     * @generated from protobuf field: google.protobuf.Timestamp storedAt = 5
+     */
+    storedAt?: Timestamp;
+    /**
+     * @generated from protobuf field: uint32 ttl = 6
+     */
+    ttl: number;
+    /**
+     * @generated from protobuf field: bool stale = 7
+     */
+    stale: boolean;
+    /**
+     * @generated from protobuf field: bool deleted = 8
+     */
+    deleted: boolean;
+}
+/**
+ * @generated MessageType for protobuf message dht.DataEntry
+ */
+declare const DataEntry: DataEntry$Type;
+declare class RecursiveOperationRequest$Type extends MessageType<RecursiveOperationRequest> {
+    constructor();
+}
+/**
+ * @generated from protobuf message dht.RecursiveOperationRequest
+ */
+interface RecursiveOperationRequest {
+    /**
+     * @generated from protobuf field: string sessionId = 1
+     */
+    sessionId: string;
+    /**
+     * @generated from protobuf field: dht.RecursiveOperation operation = 2
+     */
+    operation: RecursiveOperation;
+}
+/**
+ * @generated MessageType for protobuf message dht.RecursiveOperationRequest
+ */
+declare const RecursiveOperationRequest: RecursiveOperationRequest$Type;
+declare class PeerDescriptor$Type extends MessageType<PeerDescriptor> {
+    constructor();
+}
+/**
+ * @generated from protobuf message dht.PeerDescriptor
+ */
+interface PeerDescriptor {
+    /**
+     * @generated from protobuf field: bytes nodeId = 1
+     */
+    nodeId: Uint8Array;
+    /**
+     * @generated from protobuf field: dht.NodeType type = 2
+     */
+    type: NodeType;
+    /**
+     * @generated from protobuf field: dht.ConnectivityMethod udp = 3
+     */
+    udp?: ConnectivityMethod;
+    /**
+     * @generated from protobuf field: dht.ConnectivityMethod tcp = 4
+     */
+    tcp?: ConnectivityMethod;
+    /**
+     * @generated from protobuf field: dht.ConnectivityMethod websocket = 5
+     */
+    websocket?: ConnectivityMethod;
+    /**
+     * @generated from protobuf field: optional uint32 region = 6
+     */
+    region?: number;
+    /**
+     * @generated from protobuf field: optional uint32 ipAddress = 7
+     */
+    ipAddress?: number;
+    /**
+     * @generated from protobuf field: optional bytes publicKey = 8
+     */
+    publicKey?: Uint8Array;
+    /**
+     * signature of fields 2-8
+     *
+     * @generated from protobuf field: optional bytes signature = 9
+     */
+    signature?: Uint8Array;
+}
+/**
+ * @generated MessageType for protobuf message dht.PeerDescriptor
+ */
+declare const PeerDescriptor: PeerDescriptor$Type;
+declare class ConnectivityMethod$Type extends MessageType<ConnectivityMethod> {
+    constructor();
+}
+/**
+ * @generated from protobuf message dht.ConnectivityMethod
+ */
+interface ConnectivityMethod {
+    /**
+     * @generated from protobuf field: uint32 port = 1
+     */
+    port: number;
+    /**
+     * @generated from protobuf field: string host = 2
+     */
+    host: string;
+    /**
+     * @generated from protobuf field: bool tls = 3
+     */
+    tls: boolean;
+}
+/**
+ * @generated MessageType for protobuf message dht.ConnectivityMethod
+ */
+declare const ConnectivityMethod: ConnectivityMethod$Type;
+declare class ConnectivityRequest$Type extends MessageType<ConnectivityRequest> {
+    constructor();
+}
+/**
+ * @generated from protobuf message dht.ConnectivityRequest
+ */
+interface ConnectivityRequest {
+    /**
+     * @generated from protobuf field: uint32 port = 1
+     */
+    port: number;
+    /**
+     * @generated from protobuf field: bool tls = 2
+     */
+    tls: boolean;
+    /**
+     * @generated from protobuf field: optional string host = 3
+     */
+    host?: string;
+    /**
+     * @generated from protobuf field: bool allowSelfSignedCertificate = 4
+     */
+    allowSelfSignedCertificate: boolean;
+}
+/**
+ * @generated MessageType for protobuf message dht.ConnectivityRequest
+ */
+declare const ConnectivityRequest: ConnectivityRequest$Type;
+declare class ConnectivityResponse$Type extends MessageType<ConnectivityResponse> {
+    constructor();
+}
+/**
+ * @generated from protobuf message dht.ConnectivityResponse
+ */
+interface ConnectivityResponse {
+    /**
+     * @generated from protobuf field: string host = 1
+     */
+    host: string;
+    /**
+     * @generated from protobuf field: string natType = 2
+     */
+    natType: string;
+    /**
+     * @generated from protobuf field: dht.ConnectivityMethod websocket = 3
+     */
+    websocket?: ConnectivityMethod;
+    /**
+     * @generated from protobuf field: uint32 ipAddress = 4
+     */
+    ipAddress: number;
+    /**
+     * @generated from protobuf field: string protocolVersion = 5
+     */
+    protocolVersion: string;
+    /**
+     * @generated from protobuf field: optional double latitude = 6
+     */
+    latitude?: number;
+    /**
+     * @generated from protobuf field: optional double longitude = 7
+     */
+    longitude?: number;
+}
+/**
+ * @generated MessageType for protobuf message dht.ConnectivityResponse
+ */
+declare const ConnectivityResponse: ConnectivityResponse$Type;
+declare class HandshakeRequest$Type extends MessageType<HandshakeRequest> {
+    constructor();
+}
+/**
+ * @generated from protobuf message dht.HandshakeRequest
+ */
+interface HandshakeRequest {
+    /**
+     * @generated from protobuf field: dht.PeerDescriptor sourcePeerDescriptor = 1
+     */
+    sourcePeerDescriptor?: PeerDescriptor;
+    /**
+     * @generated from protobuf field: optional dht.PeerDescriptor targetPeerDescriptor = 2
+     */
+    targetPeerDescriptor?: PeerDescriptor;
+    /**
+     * @generated from protobuf field: string protocolVersion = 3
+     */
+    protocolVersion: string;
+    /**
+     * @generated from protobuf field: string applicationVersion = 4
+     */
+    applicationVersion: string;
+}
+/**
+ * @generated MessageType for protobuf message dht.HandshakeRequest
+ */
+declare const HandshakeRequest: HandshakeRequest$Type;
+declare class HandshakeResponse$Type extends MessageType<HandshakeResponse> {
+    constructor();
+}
+/**
+ * @generated from protobuf message dht.HandshakeResponse
+ */
+interface HandshakeResponse {
+    /**
+     * @generated from protobuf field: dht.PeerDescriptor sourcePeerDescriptor = 1
+     */
+    sourcePeerDescriptor?: PeerDescriptor;
+    /**
+     * @generated from protobuf field: optional dht.HandshakeError error = 2
+     */
+    error?: HandshakeError;
+    /**
+     * @generated from protobuf field: string protocolVersion = 3
+     */
+    protocolVersion: string;
+    /**
+     * @generated from protobuf field: string applicationVersion = 4
+     */
+    applicationVersion: string;
+}
+/**
+ * @generated MessageType for protobuf message dht.HandshakeResponse
+ */
+declare const HandshakeResponse: HandshakeResponse$Type;
+declare class Message$Type extends MessageType<Message> {
+    constructor();
+}
+/**
+ * @generated from protobuf message dht.Message
+ */
+interface Message {
+    /**
+     * @generated from protobuf field: string messageId = 1
+     */
+    messageId: string;
+    /**
+     * @generated from protobuf field: dht.PeerDescriptor sourceDescriptor = 2
+     */
+    sourceDescriptor?: PeerDescriptor;
+    /**
+     * @generated from protobuf field: dht.PeerDescriptor targetDescriptor = 3
+     */
+    targetDescriptor?: PeerDescriptor;
+    /**
+     * @generated from protobuf field: string serviceId = 4
+     */
+    serviceId: string;
+    /**
+     * @generated from protobuf oneof: body
+     */
+    body: {
+        oneofKind: "rpcMessage";
+        /**
+         * @generated from protobuf field: protorpc.RpcMessage rpcMessage = 5
+         */
+        rpcMessage: RpcMessage;
+    } | {
+        oneofKind: "connectivityRequest";
+        /**
+         * @generated from protobuf field: dht.ConnectivityRequest connectivityRequest = 6
+         */
+        connectivityRequest: ConnectivityRequest;
+    } | {
+        oneofKind: "connectivityResponse";
+        /**
+         * @generated from protobuf field: dht.ConnectivityResponse connectivityResponse = 7
+         */
+        connectivityResponse: ConnectivityResponse;
+    } | {
+        oneofKind: "handshakeRequest";
+        /**
+         * @generated from protobuf field: dht.HandshakeRequest handshakeRequest = 8
+         */
+        handshakeRequest: HandshakeRequest;
+    } | {
+        oneofKind: "handshakeResponse";
+        /**
+         * @generated from protobuf field: dht.HandshakeResponse handshakeResponse = 9
+         */
+        handshakeResponse: HandshakeResponse;
+    } | {
+        oneofKind: "recursiveOperationRequest";
+        /**
+         * @generated from protobuf field: dht.RecursiveOperationRequest recursiveOperationRequest = 10
+         */
+        recursiveOperationRequest: RecursiveOperationRequest;
+    } | {
+        oneofKind: undefined;
+    };
+}
+/**
+ * @generated MessageType for protobuf message dht.Message
+ */
+declare const Message: Message$Type;
+
+interface TransportEvents {
+    connected: (peerDescriptor: PeerDescriptor) => void;
+    disconnected: (peerDescriptor: PeerDescriptor, gracefulLeave: boolean) => void;
+    message: (message: Message) => void;
+}
+interface SendOptions {
+    connect: boolean;
+    sendIfStopped: boolean;
+    bufferWhileConnecting: boolean;
+}
+interface ITransport {
+    on<T extends keyof TransportEvents>(eventName: T, listener: (message: Message) => void): void;
+    on<T extends keyof TransportEvents>(eventName: T, listener: (peerDescriptor: PeerDescriptor) => void): void;
+    on<T extends keyof TransportEvents>(eventName: T, listener: (peerDescriptor: PeerDescriptor, gracefulLeave: boolean) => void): void;
+    once<T extends keyof TransportEvents>(eventName: T, listener: (message: Message) => void): void;
+    once<T extends keyof TransportEvents>(eventName: T, listener: (peerDescriptor: PeerDescriptor) => void): void;
+    once<T extends keyof TransportEvents>(eventName: T, listener: (peerDescriptor: PeerDescriptor, gracefulLeave: boolean) => void): void;
+    off<T extends keyof TransportEvents>(eventName: T, listener: (message: Message) => void): void;
+    off<T extends keyof TransportEvents>(eventName: T, listener: (peerDescriptor: PeerDescriptor) => void): void;
+    off<T extends keyof TransportEvents>(eventName: T, listener: (peerDescriptor: PeerDescriptor, gracefulLeave: boolean) => void): void;
+    send(msg: Message, opts?: SendOptions): Promise<void>;
+    getLocalPeerDescriptor(): PeerDescriptor;
+    stop(): void | Promise<void>;
+    getDiagnosticInfo(): Record<string, unknown>;
+}
+
+type DhtAddress = BrandedString<'DhtAddress'>;
+type DhtAddressRaw = Uint8Array;
+declare const toDhtAddress: (raw: DhtAddressRaw) => DhtAddress;
+declare const toDhtAddressRaw: (address: DhtAddress) => DhtAddressRaw;
+declare const toNodeId: (peerDescriptor: PeerDescriptor) => DhtAddress;
+declare const areEqualPeerDescriptors: (peerDescriptor1: PeerDescriptor, peerDescriptor2: PeerDescriptor) => boolean;
+declare const randomDhtAddress: () => DhtAddress;
+
+type LockID = string;
+
+interface ConnectionEvents {
+    data: (bytes: Uint8Array) => void;
+    connected: () => void;
+    disconnected: (gracefulLeave: boolean, code?: number, reason?: string) => void;
+    error: (name: string) => void;
+}
+declare enum ConnectionType {
+    WEBSOCKET_SERVER = "websocket-server",
+    WEBSOCKET_CLIENT = "websocket-client",
+    WEBRTC = "webrtc",
+    SIMULATOR_SERVER = "simulator-server",
+    SIMULATOR_CLIENT = "simulator-client"
+}
+type ConnectionID = BrandedString<'ConnectionID'>;
+interface IConnection {
+    on(event: 'data', listener: (bytes: Uint8Array) => void): this;
+    on(event: 'error', listener: (name: string) => void): this;
+    on(event: 'connected', listener: () => void): this;
+    on(event: 'disconnected', listener: (gracefulLeave: boolean, code?: number, reason?: string) => void): this;
+    once(event: 'data', listener: (bytes: Uint8Array) => void): this;
+    once(event: 'error', listener: (name: string) => void): this;
+    once(event: 'connected', listener: () => void): this;
+    once(event: 'disconnected', listener: (gracefulLeave: boolean, code?: number, reason?: string) => void): this;
+    off(event: 'data', listener: (bytes: Uint8Array) => void): void;
+    off(event: 'error', listener: (name: string) => void): void;
+    off(event: 'connected', listener: () => void): void;
+    off(event: 'disconnected', listener: (gracefulLeave: boolean, code?: number, reason?: string) => void): void;
+    send(data: Uint8Array): void;
+    close(gracefulLeave: boolean): Promise<void>;
+    destroy(): void;
+}
+
+declare class Connection extends EventEmitter<ConnectionEvents> {
+    connectionId: ConnectionID;
+    connectionType: ConnectionType;
+    private peerDescriptor?;
+    constructor(connectionType: ConnectionType);
+    setPeerDescriptor(peerDescriptor: PeerDescriptor): void;
+    getPeerDescriptor(): PeerDescriptor | undefined;
+}
+
+declare class SimulatorConnection extends Connection implements IConnection {
+    private stopped;
+    localPeerDescriptor: PeerDescriptor;
+    private targetPeerDescriptor;
+    private simulator;
+    constructor(localPeerDescriptor: PeerDescriptor, targetPeerDescriptor: PeerDescriptor, connectionType: ConnectionType, simulator: Simulator);
+    send(data: Uint8Array): void;
+    close(gracefulLeave: boolean): Promise<void>;
+    connect(): void;
+    handleIncomingData(data: Uint8Array): void;
+    handleIncomingDisconnection(): void;
+    destroy(): void;
+    private doDisconnect;
+}
+
+interface PendingConnectionEvents {
+    connected: (peerDescriptor: PeerDescriptor, connection: IConnection) => void;
+    disconnected: (gracefulLeave: boolean) => void;
+}
+declare class PendingConnection extends EventEmitter<PendingConnectionEvents> {
+    private readonly connectingAbortController;
+    private remotePeerDescriptor;
+    private replacedAsDuplicate;
+    private stopped;
+    constructor(remotePeerDescriptor: PeerDescriptor, timeout?: number);
+    replaceAsDuplicate(): void;
+    onHandshakeCompleted(connection: IConnection): void;
+    close(graceful: boolean): void;
+    destroy(): void;
+    getPeerDescriptor(): PeerDescriptor;
+}
+
+declare class SimulatorConnector {
+    private connectingConnections;
+    private stopped;
+    private localPeerDescriptor;
+    private simulator;
+    private onNewConnection;
+    constructor(localPeerDescriptor: PeerDescriptor, simulator: Simulator, onNewConnection: (connection: PendingConnection) => boolean);
+    connect(targetPeerDescriptor: PeerDescriptor): PendingConnection;
+    getPeerDescriptor(): PeerDescriptor;
+    handleIncomingConnection(sourceConnection: SimulatorConnection): void;
+    stop(): Promise<void>;
+}
+
+declare enum LatencyType {
+    NONE = "NONE",
+    RANDOM = "RANDOM",
+    REAL = "REAL",
+    FIXED = "FIXED"
+}
+declare class Simulator {
+    private stopped;
+    private connectors;
+    private latencyTable?;
+    private associations;
+    private latencyType;
+    private fixedLatency?;
+    private loopCounter;
+    private MAX_LOOPS;
+    private operationQueue;
+    private simulatorTimeout?;
+    constructor(latencyType?: LatencyType, fixedLatency?: number);
+    private generateExecutionTime;
+    private getLatency;
+    accept(sourceConnection: SimulatorConnection, targetConnection: SimulatorConnection): void;
+    addConnector(connector: SimulatorConnector): void;
+    private executeConnectOperation;
+    private executeCloseOperation;
+    private executeSendOperation;
+    private executeQueuedOperations;
+    private scheduleNextTimeout;
+    private scheduleOperation;
+    connect(sourceConnection: SimulatorConnection, targetDescriptor: PeerDescriptor, connectedCallback: (error?: string) => void): void;
+    close(sourceConnection: SimulatorConnection): void;
+    send(sourceConnection: SimulatorConnection, data: Uint8Array): void;
+    stop(): void;
+}
+
+interface IceServer {
+    url: string;
+    port: number;
+    username?: string;
+    password?: string;
+    tcp?: boolean;
+}
+
+interface DhtRpcOptions extends ProtoRpcOptions {
+    targetDescriptor?: PeerDescriptor;
+    sourceDescriptor?: PeerDescriptor;
+    clientId?: number;
+    connect?: boolean;
+    sendIfStopped?: boolean;
+    bufferWhileConnecting?: boolean;
+}
+
+declare class DhtCallContext extends ProtoCallContext implements DhtRpcOptions {
+    targetDescriptor?: PeerDescriptor;
+    sourceDescriptor?: PeerDescriptor;
+    clientId?: number;
+    connect?: boolean;
+    sendIfStopped?: boolean;
+    bufferWhileConnecting?: boolean;
+    incomingSourceDescriptor?: PeerDescriptor;
+}
+
+type ServiceID = string;
+
+declare class RoutingRpcCommunicator extends RpcCommunicator<DhtCallContext> {
+    private ownServiceId;
+    constructor(ownServiceId: ServiceID, sendFn: (msg: Message, opts: SendOptions) => Promise<void>, options?: RpcCommunicatorOptions);
+    handleMessageFromPeer(message: Message): void;
+}
+
+declare class ListeningRpcCommunicator extends RoutingRpcCommunicator {
+    private readonly transport;
+    private readonly messageListener;
+    private readonly disconnectedListener;
+    constructor(ownServiceId: ServiceID, transport: ITransport, options?: RpcCommunicatorOptions);
+    destroy(): void;
+}
+
+interface WebsocketServerConnectorOptions {
+    onNewConnection: (connection: PendingConnection) => boolean;
+    rpcCommunicator: ListeningRpcCommunicator;
+    hasConnection: (nodeId: DhtAddress) => boolean;
+    portRange?: PortRange;
+    maxMessageSize?: number;
+    host?: string;
+    entrypoints?: PeerDescriptor[];
+    tlsCertificate?: TlsCertificate;
+    autoCertifierTransport: ITransport;
+    autoCertifierUrl: string;
+    autoCertifierConfigFile: string;
+    serverEnableTls: boolean;
+    geoIpDatabaseFolder?: string;
+}
+
+interface ConnectorFacade {
+    createConnection: (peerDescriptor: PeerDescriptor) => PendingConnection;
+    getLocalPeerDescriptor: () => PeerDescriptor | undefined;
+    start: (onNewConnection: (connection: PendingConnection) => boolean, hasConnection: (nodeId: DhtAddress) => boolean, autoCertifierTransport: ITransport) => Promise<void>;
+    stop: () => Promise<void>;
+}
+interface DefaultConnectorFacadeOptions {
+    transport: ITransport;
+    websocketHost?: string;
+    websocketPortRange?: PortRange;
+    entryPoints?: PeerDescriptor[];
+    iceServers?: IceServer[];
+    webrtcAllowPrivateAddresses?: boolean;
+    webrtcDatachannelBufferThresholdLow?: number;
+    webrtcDatachannelBufferThresholdHigh?: number;
+    externalIp?: string;
+    webrtcPortRange?: PortRange;
+    maxMessageSize?: number;
+    tlsCertificate?: TlsCertificate;
+    websocketServerEnableTls?: boolean;
+    autoCertifierUrl?: string;
+    autoCertifierConfigFile?: string;
+    geoIpDatabaseFolder?: string;
+    createLocalPeerDescriptor: (connectivityResponse: ConnectivityResponse) => Promise<PeerDescriptor>;
+}
+declare class DefaultConnectorFacade implements ConnectorFacade {
+    private readonly options;
+    private localPeerDescriptor?;
+    private websocketConnectorRpcCommunicator?;
+    private websocketClientConnector?;
+    private websocketServerConnector?;
+    private webrtcConnector?;
+    constructor(options: DefaultConnectorFacadeOptions);
+    start(onNewConnection: (connection: PendingConnection) => boolean, hasConnection: (nodeId: DhtAddress) => boolean, autoCertifierTransport: ITransport): Promise<void>;
+    private setLocalPeerDescriptor;
+    restartWebsocketServerConnector(options: WebsocketServerConnectorOptions): Promise<void>;
+    createConnection(peerDescriptor: PeerDescriptor): PendingConnection;
+    getLocalPeerDescriptor(): PeerDescriptor | undefined;
+    stop(): Promise<void>;
+}
+
+interface ConnectionsView {
+    getConnections: () => PeerDescriptor[];
+    getConnectionCount: () => number;
+    hasConnection: (nodeId: DhtAddress) => boolean;
+}
+
+interface ConnectionManagerOptions {
+    maxConnections?: number;
+    metricsContext: MetricsContext;
+    allowIncomingPrivateConnections: boolean;
+    createConnectorFacade: () => ConnectorFacade;
+}
+interface ConnectionLocker {
+    lockConnection(targetDescriptor: PeerDescriptor, lockId: LockID): void;
+    unlockConnection(targetDescriptor: PeerDescriptor, lockId: LockID): void;
+    weakLockConnection(nodeId: DhtAddress, lockId: LockID): void;
+    weakUnlockConnection(nodeId: DhtAddress, lockId: LockID): void;
+    getLocalLockedConnectionCount(): number;
+    getRemoteLockedConnectionCount(): number;
+    getWeakLockedConnectionCount(): number;
+}
+interface PortRange {
+    min: number;
+    max: number;
+}
+interface TlsCertificate {
+    privateKeyFileName: string;
+    certFileName: string;
+}
+declare class ConnectionManager extends EventEmitter<TransportEvents> implements ITransport, ConnectionsView, ConnectionLocker {
+    private options;
+    private readonly metricsContext;
+    private readonly duplicateMessageDetector;
+    private readonly metrics;
+    private locks;
+    private endpoints;
+    private readonly connectorFacade;
+    private rpcCommunicator?;
+    private disconnectorIntervalRef?;
+    private state;
+    private privateClientMode;
+    constructor(options: ConnectionManagerOptions);
+    private garbageCollectConnections;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getLocalLockedConnectionCount(): number;
+    getRemoteLockedConnectionCount(): number;
+    getWeakLockedConnectionCount(): number;
+    send(message: Message, opts?: SendOptions): Promise<void>;
+    private isConnectionToSelf;
+    private isOwnWebsocketServer;
+    getLocalPeerDescriptor(): PeerDescriptor;
+    hasConnection(nodeId: DhtAddress): boolean;
+    getConnectionCount(): number;
+    hasLocalLockedConnection(nodeId: DhtAddress): boolean;
+    hasRemoteLockedConnection(nodeId: DhtAddress): boolean;
+    private handleMessage;
+    private onData;
+    private onConnected;
+    private onDisconnected;
+    private onNewConnection;
+    private acceptNewConnection;
+    private closeConnection;
+    lockConnection(targetDescriptor: PeerDescriptor, lockId: LockID): void;
+    unlockConnection(targetDescriptor: PeerDescriptor, lockId: LockID): void;
+    weakLockConnection(nodeId: DhtAddress, lockId: LockID): void;
+    weakUnlockConnection(nodeId: DhtAddress, lockId: LockID): void;
+    enablePrivateClientMode(): Promise<void>;
+    disablePrivateClientMode(): Promise<void>;
+    private getConnectedEndpoints;
+    isPrivateClientMode(): boolean;
+    private setPrivateForConnection;
+    private gracefullyDisconnectAsync;
+    private doGracefullyDisconnectAsync;
+    getConnections(): PeerDescriptor[];
+    private onConnectionCountChange;
+    getDiagnosticInfo(): Record<string, unknown>;
+}
+
+type RingIdRaw = Uint8Array & {
+    __ringIdRaw: never;
+};
+
+interface RingContacts {
+    left: PeerDescriptor[];
+    right: PeerDescriptor[];
+}
+
+interface DhtNodeEvents extends TransportEvents {
+    nearbyContactAdded: (peerDescriptor: PeerDescriptor) => void;
+    nearbyContactRemoved: (peerDescriptor: PeerDescriptor) => void;
+    randomContactAdded: (peerDescriptor: PeerDescriptor) => void;
+    randomContactRemoved: (peerDescriptor: PeerDescriptor) => void;
+    ringContactAdded: (peerDescriptor: PeerDescriptor) => void;
+    ringContactRemoved: (peerDescriptor: PeerDescriptor) => void;
+    manualRejoinRequired: () => void;
+}
+interface DhtNodeOptions {
+    serviceId?: ServiceID;
+    joinParallelism?: number;
+    maxContactCount?: number;
+    numberOfNodesPerKBucket?: number;
+    joinNoProgressLimit?: number;
+    peerDiscoveryQueryBatchSize?: number;
+    dhtJoinTimeout?: number;
+    metricsContext?: MetricsContext;
+    storeHighestTtl?: number;
+    storeMaxTtl?: number;
+    networkConnectivityTimeout?: number;
+    storageRedundancyFactor?: number;
+    periodicallyPingNeighbors?: boolean;
+    periodicallyPingRingContacts?: boolean;
+    neighborPingLimit?: number;
+    transport?: ITransport;
+    connectionsView?: ConnectionsView;
+    connectionLocker?: ConnectionLocker;
+    peerDescriptor?: PeerDescriptor;
+    entryPoints?: PeerDescriptor[];
+    websocketHost?: string;
+    websocketPortRange?: PortRange;
+    websocketServerEnableTls?: boolean;
+    nodeId?: DhtAddress;
+    region?: number;
+    rpcRequestTimeout?: number;
+    iceServers?: IceServer[];
+    webrtcAllowPrivateAddresses?: boolean;
+    webrtcDatachannelBufferThresholdLow?: number;
+    webrtcDatachannelBufferThresholdHigh?: number;
+    webrtcPortRange?: PortRange;
+    maxMessageSize?: number;
+    maxConnections?: number;
+    tlsCertificate?: TlsCertificate;
+    externalIp?: string;
+    autoCertifierUrl?: string;
+    autoCertifierConfigFile?: string;
+    geoIpDatabaseFolder?: string;
+    allowIncomingPrivateConnections?: boolean;
+}
+declare class DhtNode extends EventEmitter<DhtNodeEvents> implements ITransport {
+    private readonly options;
+    private rpcCommunicator?;
+    private transport?;
+    private localPeerDescriptor?;
+    private router?;
+    private storeManager?;
+    private localDataStore;
+    private recursiveOperationManager?;
+    private peerDiscovery?;
+    private peerManager?;
+    private connectionsView?;
+    connectionLocker?: ConnectionLocker;
+    private started;
+    private abortController;
+    constructor(conf: DhtNodeOptions);
+    private validateOptions;
+    start(): Promise<void>;
+    private initPeerManager;
+    private bindRpcLocalMethods;
+    private handleMessageFromTransport;
+    private handleMessageFromRouter;
+    private generatePeerDescriptorCallBack;
+    getClosestContacts(limit?: number): PeerDescriptor[];
+    getRandomContacts(limit?: number): PeerDescriptor[];
+    getRingContacts(): RingContacts;
+    getClosestRingContactsTo(ringIdRaw: RingIdRaw, limit?: number): RingContacts;
+    getNodeId(): DhtAddress;
+    getNeighborCount(): number;
+    removeContact(nodeId: DhtAddress): void;
+    send(msg: Message): Promise<void>;
+    private getConnectedEntryPoints;
+    joinDht(entryPointDescriptors: PeerDescriptor[], doAdditionalDistantPeerDiscovery?: boolean, retry?: boolean): Promise<void>;
+    joinRing(): Promise<void>;
+    storeDataToDht(key: DhtAddress, data: Any, creator?: DhtAddress): Promise<PeerDescriptor[]>;
+    storeDataToDhtViaPeer(key: DhtAddress, data: Any, peer: PeerDescriptor): Promise<PeerDescriptor[]>;
+    fetchDataFromDht(key: DhtAddress): Promise<DataEntry[]>;
+    fetchDataFromDhtViaPeer(key: DhtAddress, peer: PeerDescriptor): Promise<DataEntry[]>;
+    private executeRecursiveOperation;
+    deleteDataFromDht(key: DhtAddress, waitForCompletion: boolean): Promise<void>;
+    findClosestNodesFromDht(key: DhtAddress): Promise<PeerDescriptor[]>;
+    private findClosestNodesViaPeer;
+    getTransport(): ITransport;
+    getLocalPeerDescriptor(): PeerDescriptor;
+    getNeighbors(): PeerDescriptor[];
+    getConnectionsView(): ConnectionsView;
+    getLocalLockedConnectionCount(): number;
+    getRemoteLockedConnectionCount(): number;
+    getWeakLockedConnectionCount(): number;
+    waitForNetworkConnectivity(): Promise<void>;
+    hasJoined(): boolean;
+    getDiagnosticInfo(): Record<string, unknown>;
+    stop(): Promise<void>;
+    private createDhtNodeRpcRemote;
+}
+
+declare class SimulatorTransport extends ConnectionManager {
+    constructor(localPeerDescriptor: PeerDescriptor, simulator: Simulator);
+}
+
+declare function getRegionDelayMatrix(): number[][];
+declare function getRandomRegion(): number;
+
+declare const EXISTING_CONNECTION_TIMEOUT = 5000;
+declare abstract class RpcRemote<T extends ServiceInfo & ClassType> {
+    private readonly localPeerDescriptor;
+    private readonly remotePeerDescriptor;
+    private readonly client;
+    private readonly timeout?;
+    constructor(localPeerDescriptor: PeerDescriptor, remotePeerDescriptor: PeerDescriptor, rpcCommunicator: RpcCommunicator<DhtCallContext>, clientClass: {
+        new (clientTransport: ClientTransport): T;
+    }, timeout?: number);
+    getPeerDescriptor(): PeerDescriptor;
+    getLocalPeerDescriptor(): PeerDescriptor;
+    getClient(): ProtoRpcClient<T>;
+    formDhtRpcOptions(opts?: Omit<DhtRpcOptions, 'sourceDescriptor' | 'targetDescriptor'>): DhtRpcOptions;
+}
+
+interface Socket {
+    binaryType: string;
+    readyState: number;
+    close(code?: number, reason?: string): void;
+    send(data: string | Buffer | ArrayBuffer | ArrayBufferView): void;
+}
+declare abstract class AbstractWebsocketClientConnection extends EventEmitter<ConnectionEvents> implements IConnection {
+    readonly connectionId: ConnectionID;
+    protected abstract socket?: Socket;
+    connectionType: ConnectionType;
+    protected destroyed: boolean;
+    constructor();
+    abstract connect(address: string, allowSelfSignedCertificate: boolean): void;
+    protected abstract stopListening(): void;
+    send(data: Uint8Array): void;
+    close(gracefulLeave: boolean): Promise<void>;
+    destroy(): void;
+    protected onOpen(): void;
+    protected onMessage(message: Uint8Array): void;
+    protected onClose(code: number, reason: string): void;
+    protected onError(error: Error): void;
+    protected doDisconnect(code?: number, reason?: string): void;
+}
+
+declare class WebsocketClientConnection extends AbstractWebsocketClientConnection {
+    protected socket?: w3cwebsocket;
+    connect(address: string, selfSigned?: boolean): void;
+    protected stopListening(): void;
+}
+
+interface ManagedConnectionEvents {
+    managedData: (bytes: Uint8Array, remotePeerDescriptor: PeerDescriptor) => void;
+    disconnected: (gracefulLeave: boolean) => void;
+}
+declare class ManagedConnection extends EventEmitter<ManagedConnectionEvents> {
+    private connection;
+    connectionId: ConnectionID;
+    private remotePeerDescriptor;
+    private lastUsedTimestamp;
+    private replacedAsDuplicate;
+    private stopped;
+    private openedAt;
+    private bytesSent;
+    private bytesReceived;
+    private messagesSent;
+    private messagesReceived;
+    constructor(peerDescriptor: PeerDescriptor, connection: IConnection);
+    private onDisconnected;
+    replaceAsDuplicate(): void;
+    send(data: Uint8Array): void;
+    close(gracefulLeave: boolean): Promise<void>;
+    getNodeId(): DhtAddress;
+    getLastUsedTimestamp(): number;
+    getPeerDescriptor(): PeerDescriptor | undefined;
+    getDiagnosticInfo(): Record<string, unknown>;
+}
+
+interface HandshakerEvents {
+    handshakeRequest: (source: PeerDescriptor, protocolVersion: string, target?: PeerDescriptor) => void;
+    handshakeCompleted: (remote: PeerDescriptor) => void;
+    handshakeFailed: (error?: HandshakeError) => void;
+}
+declare const createOutgoingHandshaker: (localPeerDescriptor: PeerDescriptor, pendingConnection: PendingConnection, connection: IConnection, targetPeerDescriptor?: PeerDescriptor) => Handshaker;
+declare class Handshaker extends EventEmitter<HandshakerEvents> {
+    static readonly HANDSHAKER_SERVICE_ID = "system/handshaker";
+    private localPeerDescriptor;
+    private connection;
+    private readonly onDataListener;
+    constructor(localPeerDescriptor: PeerDescriptor, connection: IConnection);
+    private onData;
+    sendHandshakeRequest(remotePeerDescriptor?: PeerDescriptor): void;
+    sendHandshakeResponse(error?: HandshakeError): void;
+    stop(): void;
+}
+
+export { ConnectionManager, ConnectionType, DataEntry, DefaultConnectorFacade, DhtCallContext, DhtNode, EXISTING_CONNECTION_TIMEOUT, LatencyType, ListeningRpcCommunicator, ManagedConnection, Message, NodeType, PeerDescriptor, PendingConnection, RoutingRpcCommunicator, RpcRemote, Simulator, SimulatorTransport, WebsocketClientConnection, areEqualPeerDescriptors, createOutgoingHandshaker, getRandomRegion, getRegionDelayMatrix, randomDhtAddress, toDhtAddress, toDhtAddressRaw, toNodeId };
+export type { ConnectionLocker, ConnectionsView, DhtAddress, DhtAddressRaw, DhtNodeEvents, DhtNodeOptions, DhtRpcOptions, IConnection, ITransport, IceServer, LockID, PortRange, RingContacts, ServiceID, TlsCertificate, TransportEvents };