@streamr/trackerless-network 103.1.2 → 103.2.0-experiment.0

package/dist/exports.d.ts

@@ -0,0 +1,1391 @@
+import * as _protobuf_ts_runtime from '@protobuf-ts/runtime';
+import { MessageType, PartialMessage, IBinaryReader, BinaryReadOptions, IBinaryWriter, BinaryWriteOptions, IMessageType, JsonWriteOptions, JsonValue, JsonReadOptions } from '@protobuf-ts/runtime';
+import * as _protobuf_ts_runtime_rpc from '@protobuf-ts/runtime-rpc';
+import { ServiceInfo, RpcOptions, UnaryCall, RpcTransport, ServerCallContext } from '@protobuf-ts/runtime-rpc';
+import { PeerDescriptor as PeerDescriptor$1, DhtAddress, RingContacts, RpcRemote, ListeningRpcCommunicator, ConnectionLocker, LockID, ITransport, DataEntry, ConnectionsView, DhtNodeOptions } from '@streamr/dht';
+import { ClassType, ClientTransport, ProtoRpcClient } from '@streamr/proto-rpc';
+import { StreamPartID, UserID, ChangeFieldType, MetricsContext } from '@streamr/utils';
+import { EventEmitter } from 'eventemitter3';
+import { MarkRequired } from 'ts-essentials';
+
+type ExternalRpcClient = ServiceInfo & ClassType;
+type ExternalRpcClientClass<T extends ExternalRpcClient> = {
+    new (clientTransport: ClientTransport): T;
+};
+
+declare class Empty$Type extends MessageType<Empty> {
+    constructor();
+    create(value?: PartialMessage<Empty>): Empty;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: Empty): Empty;
+    internalBinaryWrite(message: Empty, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * A generic empty message that you can re-use to avoid defining duplicated
+ * empty messages in your APIs. A typical example is to use it as the request
+ * or the response type of an API method. For instance:
+ *
+ *     service Foo {
+ *       rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
+ *     }
+ *
+ *
+ * @generated from protobuf message google.protobuf.Empty
+ */
+interface Empty {
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.Empty
+ */
+declare const Empty: Empty$Type;
+
+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 dht.NodeType
+ */
+declare enum NodeType {
+    /**
+     * @generated from protobuf enum value: NODEJS = 0;
+     */
+    NODEJS = 0,
+    /**
+     * @generated from protobuf enum value: BROWSER = 1;
+     */
+    BROWSER = 1
+}
+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;
+
+/**
+ * @generated from protobuf enum ContentType
+ */
+declare enum ContentType {
+    /**
+     * @generated from protobuf enum value: JSON = 0;
+     */
+    JSON = 0,
+    /**
+     * @generated from protobuf enum value: BINARY = 1;
+     */
+    BINARY = 1
+}
+/**
+ * @generated from protobuf enum EncryptionType
+ */
+declare enum EncryptionType {
+    /**
+     * @generated from protobuf enum value: NONE = 0;
+     */
+    NONE = 0,
+    /**
+     * @generated from protobuf enum value: AES = 1;
+     */
+    AES = 1
+}
+/**
+ * @generated from protobuf enum AsymmetricEncryptionType
+ */
+declare enum AsymmetricEncryptionType {
+    /**
+     * default
+     *
+     * @generated from protobuf enum value: RSA = 0;
+     */
+    RSA = 0,
+    /**
+     * @generated from protobuf enum value: ML_KEM = 1;
+     */
+    ML_KEM = 1
+}
+/**
+ * @generated from protobuf enum SignatureType
+ */
+declare enum SignatureType {
+    /**
+     * @generated from protobuf enum value: ECDSA_SECP256K1_LEGACY = 0;
+     */
+    ECDSA_SECP256K1_LEGACY = 0,
+    /**
+     * @generated from protobuf enum value: ECDSA_SECP256K1_EVM = 1;
+     */
+    ECDSA_SECP256K1_EVM = 1,
+    /**
+     * @generated from protobuf enum value: ERC_1271 = 2;
+     */
+    ERC_1271 = 2,
+    /**
+     * @generated from protobuf enum value: ML_DSA_87 = 3;
+     */
+    ML_DSA_87 = 3,
+    /**
+     * @generated from protobuf enum value: ECDSA_SECP256R1 = 4;
+     */
+    ECDSA_SECP256R1 = 4
+}
+/**
+ * @generated from protobuf enum ProxyDirection
+ */
+declare enum ProxyDirection {
+    /**
+     * @generated from protobuf enum value: PUBLISH = 0;
+     */
+    PUBLISH = 0,
+    /**
+     * @generated from protobuf enum value: SUBSCRIBE = 1;
+     */
+    SUBSCRIBE = 1
+}
+declare class MessageID$Type extends MessageType<MessageID> {
+    constructor();
+}
+/**
+ * @generated from protobuf message MessageID
+ */
+interface MessageID {
+    /**
+     * @generated from protobuf field: string streamId = 1
+     */
+    streamId: string;
+    /**
+     * @generated from protobuf field: int32 streamPartition = 2
+     */
+    streamPartition: number;
+    /**
+     * @generated from protobuf field: int64 timestamp = 3
+     */
+    timestamp: number;
+    /**
+     * @generated from protobuf field: int32 sequenceNumber = 4
+     */
+    sequenceNumber: number;
+    /**
+     * @generated from protobuf field: bytes publisherId = 5
+     */
+    publisherId: Uint8Array;
+    /**
+     * @generated from protobuf field: string messageChainId = 6
+     */
+    messageChainId: string;
+}
+/**
+ * @generated MessageType for protobuf message MessageID
+ */
+declare const MessageID: MessageID$Type;
+declare class MessageRef$Type extends MessageType<MessageRef> {
+    constructor();
+}
+/**
+ * @generated from protobuf message MessageRef
+ */
+interface MessageRef {
+    /**
+     * @generated from protobuf field: int64 timestamp = 1
+     */
+    timestamp: number;
+    /**
+     * @generated from protobuf field: int32 sequenceNumber = 2
+     */
+    sequenceNumber: number;
+}
+/**
+ * @generated MessageType for protobuf message MessageRef
+ */
+declare const MessageRef: MessageRef$Type;
+declare class StreamMessage$Type extends MessageType<StreamMessage> {
+    constructor();
+}
+/**
+ * @generated from protobuf message StreamMessage
+ */
+interface StreamMessage {
+    /**
+     * this is a required field but in generated NetworkRpc.ts it is incorrectly annotated as optional (NET-1082)
+     *
+     * @generated from protobuf field: MessageID messageId = 1
+     */
+    messageId?: MessageID;
+    /**
+     * @generated from protobuf field: optional MessageRef previousMessageRef = 2
+     */
+    previousMessageRef?: MessageRef;
+    /**
+     * @generated from protobuf field: bytes signature = 3
+     */
+    signature: Uint8Array;
+    /**
+     * @generated from protobuf field: SignatureType signatureType = 4
+     */
+    signatureType: SignatureType;
+    /**
+     * @generated from protobuf oneof: body
+     */
+    body: {
+        oneofKind: "contentMessage";
+        /**
+         * @generated from protobuf field: ContentMessage contentMessage = 5
+         */
+        contentMessage: ContentMessage;
+    } | {
+        oneofKind: "groupKeyRequest";
+        /**
+         * @generated from protobuf field: GroupKeyRequest groupKeyRequest = 6
+         */
+        groupKeyRequest: GroupKeyRequest;
+    } | {
+        oneofKind: "groupKeyResponse";
+        /**
+         * @generated from protobuf field: GroupKeyResponse groupKeyResponse = 7
+         */
+        groupKeyResponse: GroupKeyResponse;
+    } | {
+        oneofKind: undefined;
+    };
+}
+/**
+ * @generated MessageType for protobuf message StreamMessage
+ */
+declare const StreamMessage: StreamMessage$Type;
+declare class ContentMessage$Type extends MessageType<ContentMessage> {
+    constructor();
+}
+/**
+ * @generated from protobuf message ContentMessage
+ */
+interface ContentMessage {
+    /**
+     * @generated from protobuf field: bytes content = 1
+     */
+    content: Uint8Array;
+    /**
+     * @generated from protobuf field: ContentType contentType = 2
+     */
+    contentType: ContentType;
+    /**
+     * @generated from protobuf field: EncryptionType encryptionType = 3
+     */
+    encryptionType: EncryptionType;
+    /**
+     * @generated from protobuf field: optional string groupKeyId = 4
+     */
+    groupKeyId?: string;
+    /**
+     * @generated from protobuf field: optional EncryptedGroupKey newGroupKey = 5
+     */
+    newGroupKey?: EncryptedGroupKey;
+}
+/**
+ * @generated MessageType for protobuf message ContentMessage
+ */
+declare const ContentMessage: ContentMessage$Type;
+declare class GroupKeyRequest$Type extends MessageType<GroupKeyRequest> {
+    constructor();
+}
+/**
+ * @generated from protobuf message GroupKeyRequest
+ */
+interface GroupKeyRequest {
+    /**
+     * @generated from protobuf field: string requestId = 1
+     */
+    requestId: string;
+    /**
+     * @generated from protobuf field: bytes recipientId = 2
+     */
+    recipientId: Uint8Array;
+    /**
+     * @generated from protobuf field: bytes publicKey = 3
+     */
+    publicKey: Uint8Array;
+    /**
+     * @generated from protobuf field: repeated string groupKeyIds = 4
+     */
+    groupKeyIds: string[];
+    /**
+     * @generated from protobuf field: AsymmetricEncryptionType encryptionType = 5
+     */
+    encryptionType: AsymmetricEncryptionType;
+}
+/**
+ * @generated MessageType for protobuf message GroupKeyRequest
+ */
+declare const GroupKeyRequest: GroupKeyRequest$Type;
+declare class GroupKeyResponse$Type extends MessageType<GroupKeyResponse> {
+    constructor();
+}
+/**
+ * @generated from protobuf message GroupKeyResponse
+ */
+interface GroupKeyResponse {
+    /**
+     * @generated from protobuf field: string requestId = 1
+     */
+    requestId: string;
+    /**
+     * @generated from protobuf field: bytes recipientId = 2
+     */
+    recipientId: Uint8Array;
+    /**
+     * @generated from protobuf field: repeated EncryptedGroupKey groupKeys = 3
+     */
+    groupKeys: EncryptedGroupKey[];
+    /**
+     * @generated from protobuf field: AsymmetricEncryptionType encryptionType = 4
+     */
+    encryptionType: AsymmetricEncryptionType;
+}
+/**
+ * @generated MessageType for protobuf message GroupKeyResponse
+ */
+declare const GroupKeyResponse: GroupKeyResponse$Type;
+declare class EncryptedGroupKey$Type extends MessageType<EncryptedGroupKey> {
+    constructor();
+}
+/**
+ * @generated from protobuf message EncryptedGroupKey
+ */
+interface EncryptedGroupKey {
+    /**
+     * @generated from protobuf field: string id = 1
+     */
+    id: string;
+    /**
+     * @generated from protobuf field: bytes data = 2
+     */
+    data: Uint8Array;
+}
+/**
+ * @generated MessageType for protobuf message EncryptedGroupKey
+ */
+declare const EncryptedGroupKey: EncryptedGroupKey$Type;
+declare class LeaveStreamPartNotice$Type extends MessageType<LeaveStreamPartNotice> {
+    constructor();
+}
+/**
+ * @generated from protobuf message LeaveStreamPartNotice
+ */
+interface LeaveStreamPartNotice {
+    /**
+     * @generated from protobuf field: string streamPartId = 1
+     */
+    streamPartId: string;
+    /**
+     * @generated from protobuf field: bool isEntryPoint = 2
+     */
+    isEntryPoint: boolean;
+}
+/**
+ * @generated MessageType for protobuf message LeaveStreamPartNotice
+ */
+declare const LeaveStreamPartNotice: LeaveStreamPartNotice$Type;
+declare class ProxyConnectionRequest$Type extends MessageType<ProxyConnectionRequest> {
+    constructor();
+}
+/**
+ * @generated from protobuf message ProxyConnectionRequest
+ */
+interface ProxyConnectionRequest {
+    /**
+     * @generated from protobuf field: optional ProxyDirection direction = 1
+     */
+    direction?: ProxyDirection;
+    /**
+     * @generated from protobuf field: bytes userId = 2
+     */
+    userId: Uint8Array;
+}
+/**
+ * @generated MessageType for protobuf message ProxyConnectionRequest
+ */
+declare const ProxyConnectionRequest: ProxyConnectionRequest$Type;
+declare class ProxyConnectionResponse$Type extends MessageType<ProxyConnectionResponse> {
+    constructor();
+}
+/**
+ * @generated from protobuf message ProxyConnectionResponse
+ */
+interface ProxyConnectionResponse {
+    /**
+     * @generated from protobuf field: bool accepted = 1
+     */
+    accepted: boolean;
+}
+/**
+ * @generated MessageType for protobuf message ProxyConnectionResponse
+ */
+declare const ProxyConnectionResponse: ProxyConnectionResponse$Type;
+declare class TemporaryConnectionRequest$Type extends MessageType<TemporaryConnectionRequest> {
+    constructor();
+}
+/**
+ * @generated from protobuf message TemporaryConnectionRequest
+ */
+interface TemporaryConnectionRequest {
+}
+/**
+ * @generated MessageType for protobuf message TemporaryConnectionRequest
+ */
+declare const TemporaryConnectionRequest: TemporaryConnectionRequest$Type;
+declare class TemporaryConnectionResponse$Type extends MessageType<TemporaryConnectionResponse> {
+    constructor();
+}
+/**
+ * @generated from protobuf message TemporaryConnectionResponse
+ */
+interface TemporaryConnectionResponse {
+    /**
+     * @generated from protobuf field: bool accepted = 1
+     */
+    accepted: boolean;
+}
+/**
+ * @generated MessageType for protobuf message TemporaryConnectionResponse
+ */
+declare const TemporaryConnectionResponse: TemporaryConnectionResponse$Type;
+declare class CloseTemporaryConnection$Type extends MessageType<CloseTemporaryConnection> {
+    constructor();
+}
+/**
+ * @generated from protobuf message CloseTemporaryConnection
+ */
+interface CloseTemporaryConnection {
+}
+/**
+ * @generated MessageType for protobuf message CloseTemporaryConnection
+ */
+declare const CloseTemporaryConnection: CloseTemporaryConnection$Type;
+declare class StreamPartitionInfo$Type extends MessageType<StreamPartitionInfo$1> {
+    constructor();
+}
+/**
+ * @generated from protobuf message StreamPartitionInfo
+ */
+interface StreamPartitionInfo$1 {
+    /**
+     * @generated from protobuf field: string id = 1
+     */
+    id: string;
+    /**
+     * @generated from protobuf field: repeated dht.PeerDescriptor controlLayerNeighbors = 2
+     */
+    controlLayerNeighbors: PeerDescriptor[];
+    /**
+     * @generated from protobuf field: repeated dht.PeerDescriptor deprecatedContentDeliveryLayerNeighbors = 3
+     */
+    deprecatedContentDeliveryLayerNeighbors: PeerDescriptor[];
+    /**
+     * @generated from protobuf field: repeated ContentDeliveryLayerNeighborInfo contentDeliveryLayerNeighbors = 4
+     */
+    contentDeliveryLayerNeighbors: ContentDeliveryLayerNeighborInfo$1[];
+}
+/**
+ * @generated MessageType for protobuf message StreamPartitionInfo
+ */
+declare const StreamPartitionInfo$1: StreamPartitionInfo$Type;
+declare class ContentDeliveryLayerNeighborInfo$Type extends MessageType<ContentDeliveryLayerNeighborInfo$1> {
+    constructor();
+}
+/**
+ * @generated from protobuf message ContentDeliveryLayerNeighborInfo
+ */
+interface ContentDeliveryLayerNeighborInfo$1 {
+    /**
+     * @generated from protobuf field: dht.PeerDescriptor peerDescriptor = 1
+     */
+    peerDescriptor?: PeerDescriptor;
+    /**
+     * @generated from protobuf field: optional int32 rtt = 2
+     */
+    rtt?: number;
+}
+/**
+ * @generated MessageType for protobuf message ContentDeliveryLayerNeighborInfo
+ */
+declare const ContentDeliveryLayerNeighborInfo$1: ContentDeliveryLayerNeighborInfo$Type;
+declare class ControlLayerInfo$Type extends MessageType<ControlLayerInfo> {
+    constructor();
+}
+/**
+ * @generated from protobuf message ControlLayerInfo
+ */
+interface ControlLayerInfo {
+    /**
+     * @generated from protobuf field: repeated dht.PeerDescriptor neighbors = 1
+     */
+    neighbors: PeerDescriptor[];
+    /**
+     * @generated from protobuf field: repeated dht.PeerDescriptor connections = 2
+     */
+    connections: PeerDescriptor[];
+}
+/**
+ * @generated MessageType for protobuf message ControlLayerInfo
+ */
+declare const ControlLayerInfo: ControlLayerInfo$Type;
+declare class NodeInfoResponse$Type extends MessageType<NodeInfoResponse> {
+    constructor();
+}
+/**
+ * @generated from protobuf message NodeInfoResponse
+ */
+interface NodeInfoResponse {
+    /**
+     * @generated from protobuf field: dht.PeerDescriptor peerDescriptor = 1
+     */
+    peerDescriptor?: PeerDescriptor;
+    /**
+     * @generated from protobuf field: repeated StreamPartitionInfo streamPartitions = 2
+     */
+    streamPartitions: StreamPartitionInfo$1[];
+    /**
+     * @generated from protobuf field: ControlLayerInfo controlLayer = 3
+     */
+    controlLayer?: ControlLayerInfo;
+    /**
+     * @generated from protobuf field: string applicationVersion = 4
+     */
+    applicationVersion: string;
+}
+/**
+ * @generated MessageType for protobuf message NodeInfoResponse
+ */
+declare const NodeInfoResponse: NodeInfoResponse$Type;
+
+interface DiscoveryLayerNodeEvents {
+    manualRejoinRequired: () => void;
+    nearbyContactAdded: (peerDescriptor: PeerDescriptor$1) => void;
+    nearbyContactRemoved: (peerDescriptor: PeerDescriptor$1) => void;
+    randomContactAdded: (peerDescriptor: PeerDescriptor$1) => void;
+    randomContactRemoved: (peerDescriptor: PeerDescriptor$1) => void;
+    ringContactAdded: (peerDescriptor: PeerDescriptor$1) => void;
+    ringContactRemoved: (peerDescriptor: PeerDescriptor$1) => void;
+}
+interface DiscoveryLayerNode {
+    on<T extends keyof DiscoveryLayerNodeEvents>(eventName: T, listener: (peerDescriptor: PeerDescriptor$1) => void): void;
+    on<T extends keyof DiscoveryLayerNodeEvents>(eventName: T, listener: () => void): void;
+    off<T extends keyof DiscoveryLayerNodeEvents>(eventName: T, listener: (peerDescriptor: PeerDescriptor$1) => void): void;
+    off<T extends keyof DiscoveryLayerNodeEvents>(eventName: T, listener: () => void): void;
+    once<T extends keyof DiscoveryLayerNodeEvents>(eventName: T, listener: (peerDescriptor: PeerDescriptor$1) => void): void;
+    once<T extends keyof DiscoveryLayerNodeEvents>(eventName: T, listener: () => void): void;
+    removeContact: (nodeId: DhtAddress) => void;
+    getClosestContacts: (maxCount?: number) => PeerDescriptor$1[];
+    getRandomContacts: (maxCount?: number) => PeerDescriptor$1[];
+    getRingContacts: () => RingContacts;
+    getNeighbors: () => PeerDescriptor$1[];
+    getNeighborCount(): number;
+    joinDht: (entryPoints: PeerDescriptor$1[], doRandomJoin?: boolean, retry?: boolean) => Promise<void>;
+    joinRing: () => Promise<void>;
+    start: () => Promise<void>;
+    stop: () => Promise<void>;
+}
+
+/**
+ * @generated from protobuf service ContentDeliveryRpc
+ */
+interface IContentDeliveryRpcClient {
+    /**
+     * @generated from protobuf rpc: sendStreamMessage
+     */
+    sendStreamMessage(input: StreamMessage, options?: RpcOptions): UnaryCall<StreamMessage, Empty>;
+    /**
+     * @generated from protobuf rpc: leaveStreamPartNotice
+     */
+    leaveStreamPartNotice(input: LeaveStreamPartNotice, options?: RpcOptions): UnaryCall<LeaveStreamPartNotice, Empty>;
+}
+/**
+ * @generated from protobuf service ContentDeliveryRpc
+ */
+declare class ContentDeliveryRpcClient implements IContentDeliveryRpcClient, ServiceInfo {
+    private readonly _transport;
+    typeName: string;
+    methods: _protobuf_ts_runtime_rpc.MethodInfo<any, any>[];
+    options: {
+        [extensionName: string]: _protobuf_ts_runtime.JsonValue;
+    };
+    constructor(_transport: RpcTransport);
+    /**
+     * @generated from protobuf rpc: sendStreamMessage
+     */
+    sendStreamMessage(input: StreamMessage, options?: RpcOptions): UnaryCall<StreamMessage, Empty>;
+    /**
+     * @generated from protobuf rpc: leaveStreamPartNotice
+     */
+    leaveStreamPartNotice(input: LeaveStreamPartNotice, options?: RpcOptions): UnaryCall<LeaveStreamPartNotice, Empty>;
+}
+
+declare class ContentDeliveryRpcRemote extends RpcRemote<ContentDeliveryRpcClient> {
+    private rtt?;
+    sendStreamMessage(msg: StreamMessage, bufferWhileConnecting?: boolean): Promise<void>;
+    leaveStreamPartNotice(streamPartId: StreamPartID, isLocalNodeEntryPoint: boolean): void;
+    setRtt(rtt: number): void;
+    getRtt(): number | undefined;
+}
+
+interface Events$5 {
+    nodeAdded: (id: DhtAddress, remote: ContentDeliveryRpcRemote) => void;
+    nodeRemoved: (id: DhtAddress, remote: ContentDeliveryRpcRemote) => void;
+}
+declare class NodeList extends EventEmitter<Events$5> {
+    private readonly nodes;
+    private readonly limit;
+    private ownId;
+    constructor(ownId: DhtAddress, limit: number);
+    add(remote: ContentDeliveryRpcRemote): void;
+    remove(nodeId: DhtAddress): void;
+    has(nodeId: DhtAddress): boolean;
+    replaceAll(neighbors: ContentDeliveryRpcRemote[]): void;
+    getIds(): DhtAddress[];
+    get(id: DhtAddress): ContentDeliveryRpcRemote | undefined;
+    size(exclude?: DhtAddress[]): number;
+    getRandom(exclude: DhtAddress[]): ContentDeliveryRpcRemote | undefined;
+    getFirst(exclude: DhtAddress[], wsOnly?: boolean): ContentDeliveryRpcRemote | undefined;
+    getFirstAndLast(exclude: DhtAddress[]): ContentDeliveryRpcRemote[];
+    getLast(exclude: DhtAddress[]): ContentDeliveryRpcRemote | undefined;
+    getAll(): ContentDeliveryRpcRemote[];
+    stop(): void;
+}
+
+interface InspectorOptions {
+    localPeerDescriptor: PeerDescriptor$1;
+    streamPartId: StreamPartID;
+    rpcCommunicator: ListeningRpcCommunicator;
+    connectionLocker: ConnectionLocker;
+    inspectionTimeout?: number;
+    openInspectConnection?: (peerDescriptor: PeerDescriptor$1, lockId: LockID) => Promise<void>;
+    closeInspectConnection?: (peerDescriptor: PeerDescriptor$1, lockId: LockID) => Promise<void>;
+}
+declare class Inspector {
+    private readonly sessions;
+    private readonly streamPartId;
+    private readonly localPeerDescriptor;
+    private readonly rpcCommunicator;
+    private readonly connectionLocker;
+    private readonly inspectionTimeout;
+    private readonly openInspectConnection;
+    private readonly closeInspectConnection;
+    constructor(options: InspectorOptions);
+    defaultOpenInspectConnection(peerDescriptor: PeerDescriptor$1, lockId: LockID): Promise<void>;
+    defaultCloseInspectConnection(peerDescriptor: PeerDescriptor$1, lockId: LockID): Promise<void>;
+    inspect(peerDescriptor: PeerDescriptor$1): Promise<boolean>;
+    markMessage(sender: DhtAddress, messageId: MessageID): void;
+    isInspected(nodeId: DhtAddress): boolean;
+    stop(): void;
+}
+
+interface HandshakerOptions {
+    localPeerDescriptor: PeerDescriptor$1;
+    streamPartId: StreamPartID;
+    neighbors: NodeList;
+    leftNodeView: NodeList;
+    rightNodeView: NodeList;
+    nearbyNodeView: NodeList;
+    randomNodeView: NodeList;
+    rpcCommunicator: ListeningRpcCommunicator;
+    maxNeighborCount: number;
+    ongoingHandshakes: Set<DhtAddress>;
+    rpcRequestTimeout?: number;
+}
+declare class Handshaker {
+    private options;
+    private readonly rpcLocal;
+    constructor(options: HandshakerOptions);
+    attemptHandshakesOnContacts(excludedIds: DhtAddress[]): Promise<DhtAddress[]>;
+    private selectParallelTargetsAndHandshake;
+    private selectParallelTargets;
+    private doParallelHandshakes;
+    private selectNewTargetAndHandshake;
+    private handshakeWithTarget;
+    private handshakeWithInterleaving;
+    private createRpcRemote;
+    private createContentDeliveryRpcRemote;
+    getOngoingHandshakes(): Set<DhtAddress>;
+}
+
+interface FindNeighborsSessionOptions {
+    neighbors: NodeList;
+    nearbyNodeView: NodeList;
+    leftNodeView: NodeList;
+    rightNodeView: NodeList;
+    randomNodeView: NodeList;
+    doFindNeighbors: (excludedNodes: DhtAddress[]) => Promise<DhtAddress[]>;
+    minCount: number;
+}
+declare class NeighborFinder {
+    private readonly abortController;
+    private readonly options;
+    private running;
+    constructor(options: FindNeighborsSessionOptions);
+    private findNeighbors;
+    isRunning(): boolean;
+    start(excluded?: DhtAddress[]): void;
+    stop(): void;
+}
+
+interface NeighborUpdateManagerOptions {
+    localPeerDescriptor: PeerDescriptor$1;
+    neighbors: NodeList;
+    nearbyNodeView: NodeList;
+    neighborFinder: NeighborFinder;
+    streamPartId: StreamPartID;
+    rpcCommunicator: ListeningRpcCommunicator;
+    neighborUpdateInterval: number;
+    neighborTargetCount: number;
+    ongoingHandshakes: Set<DhtAddress>;
+}
+declare class NeighborUpdateManager {
+    private readonly abortController;
+    private readonly options;
+    private readonly rpcLocal;
+    constructor(options: NeighborUpdateManagerOptions);
+    start(): Promise<void>;
+    stop(): void;
+    private updateNeighborInfo;
+    private createRemote;
+}
+
+type SendToNeighborFn = (neighborId: DhtAddress, msg: StreamMessage) => Promise<void>;
+interface ConstructorOptions {
+    sendToNeighbor: SendToNeighborFn;
+    minPropagationTargets: number;
+    maxMessages: number;
+    ttl: number;
+}
+/**
+ * Message propagation logic of a node. Given a message, this class will actively attempt to propagate it to
+ * `minPropagationTargets` neighbors until success or TTL expiration.
+ *
+ * Setting `minPropagationTargets = 0` effectively disables any propagation reattempts. A message will then
+ * only be propagated exactly once, to neighbors that are present at that moment, in a fire-and-forget manner.
+ */
+declare class Propagation {
+    private readonly sendToNeighbor;
+    private readonly minPropagationTargets;
+    private readonly activeTaskStore;
+    constructor({ sendToNeighbor, minPropagationTargets, maxMessages, ttl }: ConstructorOptions);
+    /**
+     * Node should invoke this when it learns about a new message
+     */
+    feedUnseenMessage(message: StreamMessage, targets: DhtAddress[], source: DhtAddress | null): void;
+    /**
+     * Node should invoke this when it learns about a new node stream assignment
+     */
+    onNeighborJoined(neighborId: DhtAddress): void;
+    private sendAndAwaitThenMark;
+}
+
+/**
+ * @generated from protobuf service ProxyConnectionRpc
+ */
+interface IProxyConnectionRpc<T = ServerCallContext> {
+    /**
+     * @generated from protobuf rpc: requestConnection
+     */
+    requestConnection(request: ProxyConnectionRequest, context: T): Promise<ProxyConnectionResponse>;
+}
+/**
+ * @generated from protobuf service TemporaryConnectionRpc
+ */
+interface ITemporaryConnectionRpc<T = ServerCallContext> {
+    /**
+     * @generated from protobuf rpc: openConnection
+     */
+    openConnection(request: TemporaryConnectionRequest, context: T): Promise<TemporaryConnectionResponse>;
+    /**
+     * @generated from protobuf rpc: closeConnection
+     */
+    closeConnection(request: CloseTemporaryConnection, context: T): Promise<Empty>;
+}
+
+interface ProxyConnection {
+    userId: UserID;
+    remote: ContentDeliveryRpcRemote;
+    direction?: ProxyDirection;
+}
+interface ProxyConnectionRpcLocalOptions {
+    localPeerDescriptor: PeerDescriptor$1;
+    streamPartId: StreamPartID;
+    rpcCommunicator: ListeningRpcCommunicator;
+}
+interface Events$4 {
+    newConnection: (nodeId: DhtAddress) => void;
+}
+declare class ProxyConnectionRpcLocal extends EventEmitter<Events$4> implements IProxyConnectionRpc {
+    private readonly options;
+    private readonly connections;
+    constructor(options: ProxyConnectionRpcLocalOptions);
+    getConnection(nodeId: DhtAddress): ProxyConnection | undefined;
+    hasConnection(nodeId: DhtAddress): boolean;
+    removeConnection(nodeId: DhtAddress): void;
+    stop(): void;
+    getPropagationTargets(msg: StreamMessage): DhtAddress[];
+    private getNodeIdsForUserId;
+    private getSubscribers;
+    requestConnection(request: ProxyConnectionRequest, context: ServerCallContext): Promise<ProxyConnectionResponse>;
+}
+
+interface TemporaryConnectionRpcLocalOptions {
+    rpcCommunicator: ListeningRpcCommunicator;
+    localPeerDescriptor: PeerDescriptor;
+    streamPartId: StreamPartID;
+    connectionLocker: ConnectionLocker;
+}
+declare class TemporaryConnectionRpcLocal implements ITemporaryConnectionRpc {
+    private readonly options;
+    private readonly temporaryNodes;
+    private readonly lockId;
+    constructor(options: TemporaryConnectionRpcLocalOptions);
+    getNodes(): NodeList;
+    hasNode(node: DhtAddress): boolean;
+    removeNode(nodeId: DhtAddress): void;
+    openConnection(_request: TemporaryConnectionRequest, context: ServerCallContext): Promise<TemporaryConnectionResponse>;
+    closeConnection(_request: CloseTemporaryConnection, context: ServerCallContext): Promise<Empty>;
+}
+
+type ContentDeliveryLayerNeighborInfo = MarkRequired<ContentDeliveryLayerNeighborInfo$1, 'peerDescriptor'>;
+type StreamPartitionInfo = ChangeFieldType<Required<StreamPartitionInfo$1>, 'contentDeliveryLayerNeighbors', ContentDeliveryLayerNeighborInfo[]>;
+type NodeInfo = ChangeFieldType<Required<NodeInfoResponse>, 'streamPartitions', StreamPartitionInfo[]>;
+
+interface Options {
+    neighbors: NodeList;
+    localPeerDescriptor: PeerDescriptor$1;
+    rpcCommunicator: ListeningRpcCommunicator;
+    maxPausedNeighbors?: number;
+}
+interface Events$3 {
+    message: (msg: StreamMessage) => void;
+}
+declare class PlumtreeManager extends EventEmitter<Events$3> {
+    private readonly neighbors;
+    private readonly localPeerDescriptor;
+    private readonly localPausedNeighbors;
+    private readonly remotePausedNeighbors;
+    private readonly rpcLocal;
+    private readonly latestMessages;
+    private readonly rpcCommunicator;
+    private readonly metadataTimestampsAheadOfRealData;
+    private readonly maxPausedNeighbors;
+    constructor(options: Options);
+    pauseNeighbor(node: PeerDescriptor$1, msgChainId: string): Promise<void>;
+    resumeNeighbor(node: PeerDescriptor$1, msgChainId: string, fromTimestamp: number): Promise<void>;
+    private onNeighborRemoved;
+    getLatestMessageTimestamp(msgChainId: string): number;
+    private sendBuffer;
+    private onMetadata;
+    private createRemote;
+    broadcast(msg: StreamMessage, previousNode: DhtAddress): void;
+    isNeighborPaused(node: PeerDescriptor$1, msgChainId: string): boolean;
+    stop(): void;
+}
+
+interface Events$2 {
+    message: (message: StreamMessage) => void;
+    neighborConnected: (nodeId: DhtAddress) => void;
+    entryPointLeaveDetected: () => void;
+}
+interface StrictContentDeliveryLayerNodeOptions {
+    streamPartId: StreamPartID;
+    discoveryLayerNode: DiscoveryLayerNode;
+    transport: ITransport;
+    connectionLocker: ConnectionLocker;
+    localPeerDescriptor: PeerDescriptor$1;
+    nodeViewSize: number;
+    nearbyNodeView: NodeList;
+    randomNodeView: NodeList;
+    leftNodeView: NodeList;
+    rightNodeView: NodeList;
+    neighbors: NodeList;
+    handshaker: Handshaker;
+    neighborFinder: NeighborFinder;
+    neighborUpdateManager: NeighborUpdateManager;
+    propagation: Propagation;
+    rpcCommunicator: ListeningRpcCommunicator;
+    neighborTargetCount: number;
+    inspector: Inspector;
+    temporaryConnectionRpcLocal: TemporaryConnectionRpcLocal;
+    isLocalNodeEntryPoint: () => boolean;
+    proxyConnectionRpcLocal?: ProxyConnectionRpcLocal;
+    rpcRequestTimeout?: number;
+    plumtreeManager?: PlumtreeManager;
+}
+declare class ContentDeliveryLayerNode extends EventEmitter<Events$2> {
+    private started;
+    private readonly duplicateDetectors;
+    private options;
+    private readonly contentDeliveryRpcLocal;
+    private abortController;
+    private messagesPropagated;
+    constructor(options: StrictContentDeliveryLayerNodeOptions);
+    start(): Promise<void>;
+    private registerDefaultServerMethods;
+    private onRingContactsUpdated;
+    private onNearbyContactAdded;
+    private onNearbyContactRemoved;
+    private updateNearbyNodeView;
+    private onRandomContactAdded;
+    private onRandomContactRemoved;
+    private onNodeDisconnected;
+    hasProxyConnection(nodeId: DhtAddress): boolean;
+    stop(): void;
+    broadcast(msg: StreamMessage, previousNode?: DhtAddress): void;
+    inspect(peerDescriptor: PeerDescriptor$1): Promise<boolean>;
+    private getPropagationTargets;
+    getOwnNodeId(): DhtAddress;
+    getOutgoingHandshakeCount(): number;
+    getNeighbors(): PeerDescriptor$1[];
+    getInfos(): ContentDeliveryLayerNeighborInfo[];
+    getNearbyNodeView(): NodeList;
+    getDiagnosticInfo(): Record<string, unknown>;
+    private isStopped;
+}
+
+interface ControlLayerNode extends ITransport {
+    joinDht(entryPointDescriptors: PeerDescriptor$1[]): Promise<void>;
+    hasJoined(): boolean;
+    getLocalPeerDescriptor(): PeerDescriptor$1;
+    fetchDataFromDht(key: DhtAddress): Promise<DataEntry[]>;
+    storeDataToDht(key: DhtAddress, data: Any): Promise<PeerDescriptor$1[]>;
+    deleteDataFromDht(key: DhtAddress, waitForCompletion: boolean): Promise<void>;
+    waitForNetworkConnectivity(): Promise<void>;
+    getTransport(): ITransport;
+    getNeighbors(): PeerDescriptor$1[];
+    getConnectionsView(): ConnectionsView;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+}
+
+interface StreamPartNetworkSplitAvoidanceOptions {
+    discoveryLayerNode: DiscoveryLayerNode;
+    discoverEntryPoints: (excludedNodes?: Set<DhtAddress>) => Promise<PeerDescriptor$1[]>;
+    exponentialRunOfBaseDelay?: number;
+}
+declare class StreamPartNetworkSplitAvoidance {
+    private readonly abortController;
+    private readonly options;
+    private readonly excludedNodes;
+    private running;
+    constructor(options: StreamPartNetworkSplitAvoidanceOptions);
+    avoidNetworkSplit(): Promise<void>;
+    isRunning(): boolean;
+    destroy(): void;
+}
+
+interface ProxyClientOptions {
+    transport: ITransport;
+    localPeerDescriptor: PeerDescriptor$1;
+    streamPartId: StreamPartID;
+    connectionLocker: ConnectionLocker;
+    maxPropagationBufferSize: number;
+    minPropagationTargets: number;
+    propagationBufferTtl: number;
+}
+interface Events$1 {
+    message: (message: StreamMessage) => void;
+}
+declare class ProxyClient extends EventEmitter<Events$1> {
+    private readonly rpcCommunicator;
+    private readonly contentDeliveryRpcLocal;
+    private readonly options;
+    private readonly duplicateDetectors;
+    private definition?;
+    private readonly connections;
+    private readonly propagation;
+    private readonly neighbors;
+    private readonly abortController;
+    constructor(options: ProxyClientOptions);
+    private registerDefaultServerMethods;
+    setProxies(nodes: PeerDescriptor$1[], userId: UserID, direction?: ProxyDirection, connectionCount?: number): Promise<void>;
+    private updateConnections;
+    private getInvalidConnections;
+    private openRandomConnections;
+    private attemptConnection;
+    private closeRandomConnections;
+    private closeConnection;
+    private removeConnection;
+    broadcast(msg: StreamMessage, previousNode?: DhtAddress): void;
+    hasConnection(nodeId: DhtAddress, direction?: ProxyDirection): boolean;
+    getDirection(): ProxyDirection | undefined;
+    private onNodeDisconnected;
+    start(): Promise<void>;
+    getDiagnosticInfo(): Record<string, unknown>;
+    stop(): void;
+}
+
+type StreamPartDelivery = {
+    broadcast: (msg: StreamMessage) => void;
+    stop: () => Promise<void>;
+} & ({
+    proxied: false;
+    discoveryLayerNode: DiscoveryLayerNode;
+    node: ContentDeliveryLayerNode;
+    networkSplitAvoidance: StreamPartNetworkSplitAvoidance;
+    getDiagnosticInfo: () => Record<string, unknown>;
+} | {
+    proxied: true;
+    client: ProxyClient;
+    getDiagnosticInfo: () => Record<string, unknown>;
+});
+interface Events {
+    newMessage: (msg: StreamMessage) => void;
+}
+interface ContentDeliveryManagerOptions {
+    metricsContext?: MetricsContext;
+    streamPartitionNeighborTargetCount?: number;
+    streamPartitionMinPropagationTargets?: number;
+    streamPartitionMaxPropagationBufferSize?: number;
+    acceptProxyConnections?: boolean;
+    rpcRequestTimeout?: number;
+    neighborUpdateInterval?: number;
+    bufferWhileConnecting?: boolean;
+}
+type PlumtreeOptions = {
+    enabled: true;
+    maxPausedNeighbors?: number;
+} | {
+    enabled: false;
+};
+interface StreamPartDeliveryOptions {
+    plumtreeOptimization?: PlumtreeOptions;
+}
+declare const streamPartIdToDataKey: (streamPartId: StreamPartID) => DhtAddress;
+declare class ContentDeliveryManager extends EventEmitter<Events> {
+    private transport?;
+    private connectionLocker?;
+    private controlLayerNode?;
+    private readonly metricsContext;
+    private readonly metrics;
+    private readonly options;
+    private readonly streamParts;
+    private readonly knownStreamPartEntryPoints;
+    private started;
+    private destroyed;
+    constructor(options: ContentDeliveryManagerOptions);
+    start(startedAndJoinedControlLayerNode: ControlLayerNode, transport: ITransport, connectionLocker: ConnectionLocker): Promise<void>;
+    destroy(): Promise<void>;
+    broadcast(msg: StreamMessage, streamPartDeliveryOptions?: StreamPartDeliveryOptions): void;
+    leaveStreamPart(streamPartId: StreamPartID): Promise<void>;
+    joinStreamPart(streamPartId: StreamPartID, streamPartDeliveryOptions?: StreamPartDeliveryOptions): void;
+    private startLayersAndJoinDht;
+    private createDiscoveryLayerNode;
+    private createContentDeliveryLayerNode;
+    setProxies(streamPartId: StreamPartID, nodes: PeerDescriptor$1[], userId: UserID, direction?: ProxyDirection, connectionCount?: number): Promise<void>;
+    private createProxyClient;
+    inspect(peerDescriptor: PeerDescriptor$1, streamPartId: StreamPartID): Promise<boolean>;
+    getNodeInfo(): StreamPartitionInfo[];
+    setStreamPartEntryPoints(streamPartId: StreamPartID, entryPoints: PeerDescriptor$1[]): void;
+    isProxiedStreamPart(streamPartId: StreamPartID, direction?: ProxyDirection): boolean;
+    getStreamPartDelivery(streamPartId: StreamPartID): StreamPartDelivery | undefined;
+    hasStreamPart(streamPartId: StreamPartID): boolean;
+    getPeerDescriptor(): PeerDescriptor$1;
+    getNodeId(): DhtAddress;
+    getNeighbors(streamPartId: StreamPartID): DhtAddress[];
+    getStreamParts(): StreamPartID[];
+    getDiagnosticInfo(): Record<string, unknown>;
+}
+
+interface NetworkOptions {
+    layer0?: DhtNodeOptions;
+    networkNode?: ContentDeliveryManagerOptions;
+    metricsContext?: MetricsContext;
+}
+declare class NetworkStack {
+    private controlLayerNode?;
+    private contentDeliveryManager?;
+    private stopped;
+    private readonly metricsContext;
+    private readonly options;
+    private nodeInfoRpcLocal?;
+    private nodeInfoClient?;
+    constructor(options: NetworkOptions);
+    joinStreamPart(streamPartId: StreamPartID, neighborRequirement?: {
+        minCount: number;
+        timeout: number;
+    }, streamPartDeliveryOptions?: StreamPartDeliveryOptions): Promise<void>;
+    broadcast(msg: StreamMessage, streamPartDeliveryOptions?: StreamPartDeliveryOptions): Promise<void>;
+    start(doJoin?: boolean): Promise<void>;
+    private ensureConnectedToControlLayer;
+    getContentDeliveryManager(): ContentDeliveryManager;
+    getControlLayerNode(): ControlLayerNode;
+    getMetricsContext(): MetricsContext;
+    fetchNodeInfo(node: PeerDescriptor$1): Promise<NodeInfo>;
+    createNodeInfo(): NodeInfo;
+    getOptions(): NetworkOptions;
+    private getConnectionManager;
+    stop(): Promise<void>;
+}
+
+declare const createNetworkNode: (opts: NetworkOptions) => NetworkNode;
+/**
+ * Convenience wrapper for building client-facing functionality. Used by client.
+ */
+declare class NetworkNode {
+    readonly stack: NetworkStack;
+    private stopped;
+    private externalNetworkRpc?;
+    start(doJoin?: boolean): Promise<void>;
+    inspect(node: PeerDescriptor$1, streamPartId: StreamPartID): Promise<boolean>;
+    broadcast(msg: StreamMessage, streamPartDeliveryOptions?: StreamPartDeliveryOptions): Promise<void>;
+    join(streamPartId: StreamPartID, neighborRequirement?: {
+        minCount: number;
+        timeout: number;
+    }, streamPartDeliveryOptions?: StreamPartDeliveryOptions): Promise<void>;
+    setProxies(streamPartId: StreamPartID, nodes: PeerDescriptor$1[], userId: UserID, direction?: ProxyDirection, connectionCount?: number): Promise<void>;
+    isProxiedStreamPart(streamPartId: StreamPartID): boolean;
+    addMessageListener(listener: (msg: StreamMessage) => void): void;
+    setStreamPartEntryPoints(streamPartId: StreamPartID, contactPeerDescriptors: PeerDescriptor$1[]): void;
+    removeMessageListener(listener: (msg: StreamMessage) => void): void;
+    leave(streamPartId: StreamPartID): Promise<void>;
+    getNeighbors(streamPartId: StreamPartID): readonly DhtAddress[];
+    hasStreamPart(streamPartId: StreamPartID): boolean;
+    stop(): Promise<void>;
+    getPeerDescriptor(): PeerDescriptor$1;
+    getMetricsContext(): MetricsContext;
+    getNodeId(): DhtAddress;
+    getOptions(): NetworkOptions;
+    getStreamParts(): StreamPartID[];
+    fetchNodeInfo(node: PeerDescriptor$1): Promise<NodeInfo>;
+    getDiagnosticInfo(): Record<string, unknown>;
+    registerExternalNetworkRpcMethod<RequestClass extends IMessageType<RequestType>, ResponseClass extends IMessageType<ResponseType>, RequestType extends object, ResponseType extends object>(request: RequestClass, response: ResponseClass, name: string, fn: (req: RequestType, context: ServerCallContext) => Promise<ResponseType>): void;
+    createExternalRpcClient<T extends ExternalRpcClient>(clientClass: ExternalRpcClientClass<T>): ProtoRpcClient<T>;
+}
+
+export { AsymmetricEncryptionType, ContentType, ControlLayerInfo, EncryptedGroupKey, EncryptionType, GroupKeyRequest, GroupKeyResponse, MessageID, MessageRef, NetworkNode, NetworkStack, ProxyDirection, SignatureType, StreamMessage, createNetworkNode, streamPartIdToDataKey };
+export type { ContentDeliveryLayerNeighborInfo, ContentDeliveryManagerOptions, ExternalRpcClient, ExternalRpcClientClass, NetworkOptions, NodeInfo, StreamPartDeliveryOptions, StreamPartitionInfo };