@streamr/trackerless-network 0.0.1-tatum.0

package/src/proto/packages/proto-rpc/protos/ProtoRpc.ts

@@ -0,0 +1,108 @@
+// @generated by protobuf-ts 2.8.2 with parameter server_generic,generate_dependencies,long_type_number
+// @generated from protobuf file "packages/proto-rpc/protos/ProtoRpc.proto" (package "protorpc", syntax proto3)
+// tslint:disable
+import { MessageType } from "@protobuf-ts/runtime";
+import { Empty } from "../../../google/protobuf/empty";
+import { Any } from "../../../google/protobuf/any";
+/**
+ * @generated from protobuf message protorpc.RpcMessage
+ */
+export 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;
+}
+// Dummy message to force the generation of the typescript class "google.prototype.Empty"
+// We need this generated class in RpcCommunicator
+
+/**
+ * @generated from protobuf message protorpc.Mnfo2uhnf92hvqi2nviouq2hv9puhq
+ */
+export interface Mnfo2uhnf92hvqi2nviouq2hv9puhq {
+    /**
+     * @generated from protobuf field: google.protobuf.Empty empty = 1;
+     */
+    empty?: Empty;
+}
+/**
+ * @generated from protobuf enum protorpc.RpcErrorType
+ */
+export 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
+}
+// @generated message type with reflection information, may provide speed optimized methods
+class RpcMessage$Type extends MessageType<RpcMessage> {
+    constructor() {
+        super("protorpc.RpcMessage", [
+            { no: 1, name: "header", kind: "map", K: 9 /*ScalarType.STRING*/, V: { kind: "scalar", T: 9 /*ScalarType.STRING*/ } },
+            { no: 2, name: "body", kind: "message", T: () => Any },
+            { no: 3, name: "requestId", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 4, name: "errorType", kind: "enum", opt: true, T: () => ["protorpc.RpcErrorType", RpcErrorType] },
+            { no: 5, name: "errorClassName", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
+            { no: 6, name: "errorCode", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
+            { no: 7, name: "errorMessage", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message protorpc.RpcMessage
+ */
+export const RpcMessage = new RpcMessage$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Mnfo2uhnf92hvqi2nviouq2hv9puhq$Type extends MessageType<Mnfo2uhnf92hvqi2nviouq2hv9puhq> {
+    constructor() {
+        super("protorpc.Mnfo2uhnf92hvqi2nviouq2hv9puhq", [
+            { no: 1, name: "empty", kind: "message", T: () => Empty }
+        ]);
+    }
+}
+/**
+ * @generated MessageType for protobuf message protorpc.Mnfo2uhnf92hvqi2nviouq2hv9puhq
+ */
+export const Mnfo2uhnf92hvqi2nviouq2hv9puhq = new Mnfo2uhnf92hvqi2nviouq2hv9puhq$Type();

package/src/proto/packages/trackerless-network/protos/NetworkRpc.client.ts

@@ -0,0 +1,176 @@
+// @generated by protobuf-ts 2.8.2 with parameter server_generic,generate_dependencies,long_type_number
+// @generated from protobuf file "packages/trackerless-network/protos/NetworkRpc.proto" (syntax proto3)
+// tslint:disable
+import { TemporaryConnectionRpc } from "./NetworkRpc";
+import type { TemporaryConnectionResponse } from "./NetworkRpc";
+import type { TemporaryConnectionRequest } from "./NetworkRpc";
+import { NeighborUpdateRpc } from "./NetworkRpc";
+import type { NeighborUpdate } from "./NetworkRpc";
+import { HandshakeRpc } from "./NetworkRpc";
+import type { InterleaveNotice } from "./NetworkRpc";
+import type { StreamHandshakeResponse } from "./NetworkRpc";
+import type { StreamHandshakeRequest } from "./NetworkRpc";
+import { ProxyConnectionRpc } from "./NetworkRpc";
+import type { ProxyConnectionResponse } from "./NetworkRpc";
+import type { ProxyConnectionRequest } from "./NetworkRpc";
+import type { RpcTransport } from "@protobuf-ts/runtime-rpc";
+import type { ServiceInfo } from "@protobuf-ts/runtime-rpc";
+import { NetworkRpc } from "./NetworkRpc";
+import type { LeaveStreamNotice } from "./NetworkRpc";
+import { stackIntercept } from "@protobuf-ts/runtime-rpc";
+import type { Empty } from "../../../google/protobuf/empty";
+import type { StreamMessage } from "./NetworkRpc";
+import type { UnaryCall } from "@protobuf-ts/runtime-rpc";
+import type { RpcOptions } from "@protobuf-ts/runtime-rpc";
+/**
+ * @generated from protobuf service NetworkRpc
+ */
+export interface INetworkRpcClient {
+    /**
+     * @generated from protobuf rpc: sendData(StreamMessage) returns (google.protobuf.Empty);
+     */
+    sendData(input: StreamMessage, options?: RpcOptions): UnaryCall<StreamMessage, Empty>;
+    /**
+     * @generated from protobuf rpc: leaveStreamNotice(LeaveStreamNotice) returns (google.protobuf.Empty);
+     */
+    leaveStreamNotice(input: LeaveStreamNotice, options?: RpcOptions): UnaryCall<LeaveStreamNotice, Empty>;
+}
+/**
+ * @generated from protobuf service NetworkRpc
+ */
+export class NetworkRpcClient implements INetworkRpcClient, ServiceInfo {
+    typeName = NetworkRpc.typeName;
+    methods = NetworkRpc.methods;
+    options = NetworkRpc.options;
+    constructor(private readonly _transport: RpcTransport) {
+    }
+    /**
+     * @generated from protobuf rpc: sendData(StreamMessage) returns (google.protobuf.Empty);
+     */
+    sendData(input: StreamMessage, options?: RpcOptions): UnaryCall<StreamMessage, Empty> {
+        const method = this.methods[0], opt = this._transport.mergeOptions(options);
+        return stackIntercept<StreamMessage, Empty>("unary", this._transport, method, opt, input);
+    }
+    /**
+     * @generated from protobuf rpc: leaveStreamNotice(LeaveStreamNotice) returns (google.protobuf.Empty);
+     */
+    leaveStreamNotice(input: LeaveStreamNotice, options?: RpcOptions): UnaryCall<LeaveStreamNotice, Empty> {
+        const method = this.methods[1], opt = this._transport.mergeOptions(options);
+        return stackIntercept<LeaveStreamNotice, Empty>("unary", this._transport, method, opt, input);
+    }
+}
+/**
+ * @generated from protobuf service ProxyConnectionRpc
+ */
+export interface IProxyConnectionRpcClient {
+    /**
+     * @generated from protobuf rpc: requestConnection(ProxyConnectionRequest) returns (ProxyConnectionResponse);
+     */
+    requestConnection(input: ProxyConnectionRequest, options?: RpcOptions): UnaryCall<ProxyConnectionRequest, ProxyConnectionResponse>;
+}
+/**
+ * @generated from protobuf service ProxyConnectionRpc
+ */
+export class ProxyConnectionRpcClient implements IProxyConnectionRpcClient, ServiceInfo {
+    typeName = ProxyConnectionRpc.typeName;
+    methods = ProxyConnectionRpc.methods;
+    options = ProxyConnectionRpc.options;
+    constructor(private readonly _transport: RpcTransport) {
+    }
+    /**
+     * @generated from protobuf rpc: requestConnection(ProxyConnectionRequest) returns (ProxyConnectionResponse);
+     */
+    requestConnection(input: ProxyConnectionRequest, options?: RpcOptions): UnaryCall<ProxyConnectionRequest, ProxyConnectionResponse> {
+        const method = this.methods[0], opt = this._transport.mergeOptions(options);
+        return stackIntercept<ProxyConnectionRequest, ProxyConnectionResponse>("unary", this._transport, method, opt, input);
+    }
+}
+/**
+ * @generated from protobuf service HandshakeRpc
+ */
+export interface IHandshakeRpcClient {
+    /**
+     * @generated from protobuf rpc: handshake(StreamHandshakeRequest) returns (StreamHandshakeResponse);
+     */
+    handshake(input: StreamHandshakeRequest, options?: RpcOptions): UnaryCall<StreamHandshakeRequest, StreamHandshakeResponse>;
+    /**
+     * @generated from protobuf rpc: interleaveNotice(InterleaveNotice) returns (google.protobuf.Empty);
+     */
+    interleaveNotice(input: InterleaveNotice, options?: RpcOptions): UnaryCall<InterleaveNotice, Empty>;
+}
+/**
+ * @generated from protobuf service HandshakeRpc
+ */
+export class HandshakeRpcClient implements IHandshakeRpcClient, ServiceInfo {
+    typeName = HandshakeRpc.typeName;
+    methods = HandshakeRpc.methods;
+    options = HandshakeRpc.options;
+    constructor(private readonly _transport: RpcTransport) {
+    }
+    /**
+     * @generated from protobuf rpc: handshake(StreamHandshakeRequest) returns (StreamHandshakeResponse);
+     */
+    handshake(input: StreamHandshakeRequest, options?: RpcOptions): UnaryCall<StreamHandshakeRequest, StreamHandshakeResponse> {
+        const method = this.methods[0], opt = this._transport.mergeOptions(options);
+        return stackIntercept<StreamHandshakeRequest, StreamHandshakeResponse>("unary", this._transport, method, opt, input);
+    }
+    /**
+     * @generated from protobuf rpc: interleaveNotice(InterleaveNotice) returns (google.protobuf.Empty);
+     */
+    interleaveNotice(input: InterleaveNotice, options?: RpcOptions): UnaryCall<InterleaveNotice, Empty> {
+        const method = this.methods[1], opt = this._transport.mergeOptions(options);
+        return stackIntercept<InterleaveNotice, Empty>("unary", this._transport, method, opt, input);
+    }
+}
+/**
+ * @generated from protobuf service NeighborUpdateRpc
+ */
+export interface INeighborUpdateRpcClient {
+    /**
+     * @generated from protobuf rpc: neighborUpdate(NeighborUpdate) returns (NeighborUpdate);
+     */
+    neighborUpdate(input: NeighborUpdate, options?: RpcOptions): UnaryCall<NeighborUpdate, NeighborUpdate>;
+}
+/**
+ * @generated from protobuf service NeighborUpdateRpc
+ */
+export class NeighborUpdateRpcClient implements INeighborUpdateRpcClient, ServiceInfo {
+    typeName = NeighborUpdateRpc.typeName;
+    methods = NeighborUpdateRpc.methods;
+    options = NeighborUpdateRpc.options;
+    constructor(private readonly _transport: RpcTransport) {
+    }
+    /**
+     * @generated from protobuf rpc: neighborUpdate(NeighborUpdate) returns (NeighborUpdate);
+     */
+    neighborUpdate(input: NeighborUpdate, options?: RpcOptions): UnaryCall<NeighborUpdate, NeighborUpdate> {
+        const method = this.methods[0], opt = this._transport.mergeOptions(options);
+        return stackIntercept<NeighborUpdate, NeighborUpdate>("unary", this._transport, method, opt, input);
+    }
+}
+/**
+ * @generated from protobuf service TemporaryConnectionRpc
+ */
+export interface ITemporaryConnectionRpcClient {
+    /**
+     * @generated from protobuf rpc: openConnection(TemporaryConnectionRequest) returns (TemporaryConnectionResponse);
+     */
+    openConnection(input: TemporaryConnectionRequest, options?: RpcOptions): UnaryCall<TemporaryConnectionRequest, TemporaryConnectionResponse>;
+}
+/**
+ * @generated from protobuf service TemporaryConnectionRpc
+ */
+export class TemporaryConnectionRpcClient implements ITemporaryConnectionRpcClient, ServiceInfo {
+    typeName = TemporaryConnectionRpc.typeName;
+    methods = TemporaryConnectionRpc.methods;
+    options = TemporaryConnectionRpc.options;
+    constructor(private readonly _transport: RpcTransport) {
+    }
+    /**
+     * @generated from protobuf rpc: openConnection(TemporaryConnectionRequest) returns (TemporaryConnectionResponse);
+     */
+    openConnection(input: TemporaryConnectionRequest, options?: RpcOptions): UnaryCall<TemporaryConnectionRequest, TemporaryConnectionResponse> {
+        const method = this.methods[0], opt = this._transport.mergeOptions(options);
+        return stackIntercept<TemporaryConnectionRequest, TemporaryConnectionResponse>("unary", this._transport, method, opt, input);
+    }
+}

package/src/proto/packages/trackerless-network/protos/NetworkRpc.server.ts

@@ -0,0 +1,68 @@
+// @generated by protobuf-ts 2.8.2 with parameter server_generic,generate_dependencies,long_type_number
+// @generated from protobuf file "packages/trackerless-network/protos/NetworkRpc.proto" (syntax proto3)
+// tslint:disable
+import { TemporaryConnectionResponse } from "./NetworkRpc";
+import { TemporaryConnectionRequest } from "./NetworkRpc";
+import { NeighborUpdate } from "./NetworkRpc";
+import { InterleaveNotice } from "./NetworkRpc";
+import { StreamHandshakeResponse } from "./NetworkRpc";
+import { StreamHandshakeRequest } from "./NetworkRpc";
+import { ProxyConnectionResponse } from "./NetworkRpc";
+import { ProxyConnectionRequest } from "./NetworkRpc";
+import { LeaveStreamNotice } from "./NetworkRpc";
+import { Empty } from "../../../google/protobuf/empty";
+import { StreamMessage } from "./NetworkRpc";
+import { ServerCallContext } from "@protobuf-ts/runtime-rpc";
+/**
+ * @generated from protobuf service NetworkRpc
+ */
+export interface INetworkRpc<T = ServerCallContext> {
+    /**
+     * @generated from protobuf rpc: sendData(StreamMessage) returns (google.protobuf.Empty);
+     */
+    sendData(request: StreamMessage, context: T): Promise<Empty>;
+    /**
+     * @generated from protobuf rpc: leaveStreamNotice(LeaveStreamNotice) returns (google.protobuf.Empty);
+     */
+    leaveStreamNotice(request: LeaveStreamNotice, context: T): Promise<Empty>;
+}
+/**
+ * @generated from protobuf service ProxyConnectionRpc
+ */
+export interface IProxyConnectionRpc<T = ServerCallContext> {
+    /**
+     * @generated from protobuf rpc: requestConnection(ProxyConnectionRequest) returns (ProxyConnectionResponse);
+     */
+    requestConnection(request: ProxyConnectionRequest, context: T): Promise<ProxyConnectionResponse>;
+}
+/**
+ * @generated from protobuf service HandshakeRpc
+ */
+export interface IHandshakeRpc<T = ServerCallContext> {
+    /**
+     * @generated from protobuf rpc: handshake(StreamHandshakeRequest) returns (StreamHandshakeResponse);
+     */
+    handshake(request: StreamHandshakeRequest, context: T): Promise<StreamHandshakeResponse>;
+    /**
+     * @generated from protobuf rpc: interleaveNotice(InterleaveNotice) returns (google.protobuf.Empty);
+     */
+    interleaveNotice(request: InterleaveNotice, context: T): Promise<Empty>;
+}
+/**
+ * @generated from protobuf service NeighborUpdateRpc
+ */
+export interface INeighborUpdateRpc<T = ServerCallContext> {
+    /**
+     * @generated from protobuf rpc: neighborUpdate(NeighborUpdate) returns (NeighborUpdate);
+     */
+    neighborUpdate(request: NeighborUpdate, context: T): Promise<NeighborUpdate>;
+}
+/**
+ * @generated from protobuf service TemporaryConnectionRpc
+ */
+export interface ITemporaryConnectionRpc<T = ServerCallContext> {
+    /**
+     * @generated from protobuf rpc: openConnection(TemporaryConnectionRequest) returns (TemporaryConnectionResponse);
+     */
+    openConnection(request: TemporaryConnectionRequest, context: T): Promise<TemporaryConnectionResponse>;
+}