@dronedeploy/rocos-js-sdk 0.0.1 → 3.0.0-alpha.6

package/grpc/serviette.v1_pb.grpc-client.d.ts

@@ -0,0 +1,215 @@
+import type { MeshInfo } from "./serviette.v1_pb";
+import type { MeshNodeResponse } from "./serviette.v1_pb";
+import type { MeshNodeRequest } from "./serviette.v1_pb";
+import type { RequestCancellations } from "./serviette.v1_pb";
+import type { RequestCancellation } from "./serviette.v1_pb";
+import type { ServiceRequests } from "./serviette.v1_pb";
+import type { ServiceRequest } from "./serviette.v1_pb";
+import type { WebSendResponseMessage } from "./serviette.v1_pb";
+import type { WebReceiverRegistration } from "./serviette.v1_pb";
+import type { ReceiverRecords } from "./serviette.v1_pb";
+import type { Empty } from "./google/protobuf/empty_pb";
+import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
+import type { BinaryReadOptions } from "@protobuf-ts/runtime";
+import type { RequestChannelMessage } from "./serviette.v1_pb";
+import type { ResponseChannelMessage } from "./serviette.v1_pb";
+import * as grpc from "@grpc/grpc-js";
+/**
+ * @generated from protobuf service serviette.v1.ServiceReceiver
+ */
+export interface IServiceReceiverClient {
+    /**
+     * @generated from protobuf rpc: RegisterReceiver(stream serviette.v1.ResponseChannelMessage) returns (stream serviette.v1.RequestChannelMessage);
+     */
+    registerReceiver(metadata: grpc.Metadata, options?: grpc.CallOptions): grpc.ClientDuplexStream<ResponseChannelMessage, RequestChannelMessage>;
+    registerReceiver(options?: grpc.CallOptions): grpc.ClientDuplexStream<ResponseChannelMessage, RequestChannelMessage>;
+}
+/**
+ * @generated from protobuf service serviette.v1.ServiceReceiver
+ */
+export declare class ServiceReceiverClient extends grpc.Client implements IServiceReceiverClient {
+    private readonly _binaryOptions;
+    constructor(address: string, credentials: grpc.ChannelCredentials, options?: grpc.ClientOptions, binaryOptions?: Partial<BinaryReadOptions & BinaryWriteOptions>);
+    /**
+     * @generated from protobuf rpc: RegisterReceiver(stream serviette.v1.ResponseChannelMessage) returns (stream serviette.v1.RequestChannelMessage);
+     */
+    registerReceiver(metadata?: grpc.Metadata | grpc.CallOptions, options?: grpc.CallOptions): grpc.ClientDuplexStream<ResponseChannelMessage, RequestChannelMessage>;
+}
+/**
+ * @generated from protobuf service serviette.v1.ServiceCaller
+ */
+export interface IServiceCallerClient {
+    /**
+     * @generated from protobuf rpc: CallServices(stream serviette.v1.RequestChannelMessage) returns (stream serviette.v1.ResponseChannelMessage);
+     */
+    callServices(metadata: grpc.Metadata, options?: grpc.CallOptions): grpc.ClientDuplexStream<RequestChannelMessage, ResponseChannelMessage>;
+    callServices(options?: grpc.CallOptions): grpc.ClientDuplexStream<RequestChannelMessage, ResponseChannelMessage>;
+    /**
+     * @generated from protobuf rpc: ListKnownReceivers(google.protobuf.Empty) returns (serviette.v1.ReceiverRecords);
+     */
+    listKnownReceivers(input: Empty, metadata: grpc.Metadata, options: grpc.CallOptions, callback: (err: grpc.ServiceError | null, value?: ReceiverRecords) => void): grpc.ClientUnaryCall;
+    listKnownReceivers(input: Empty, metadata: grpc.Metadata, callback: (err: grpc.ServiceError | null, value?: ReceiverRecords) => void): grpc.ClientUnaryCall;
+    listKnownReceivers(input: Empty, options: grpc.CallOptions, callback: (err: grpc.ServiceError | null, value?: ReceiverRecords) => void): grpc.ClientUnaryCall;
+    listKnownReceivers(input: Empty, callback: (err: grpc.ServiceError | null, value?: ReceiverRecords) => void): grpc.ClientUnaryCall;
+}
+/**
+ * @generated from protobuf service serviette.v1.ServiceCaller
+ */
+export declare class ServiceCallerClient extends grpc.Client implements IServiceCallerClient {
+    private readonly _binaryOptions;
+    constructor(address: string, credentials: grpc.ChannelCredentials, options?: grpc.ClientOptions, binaryOptions?: Partial<BinaryReadOptions & BinaryWriteOptions>);
+    /**
+     * @generated from protobuf rpc: CallServices(stream serviette.v1.RequestChannelMessage) returns (stream serviette.v1.ResponseChannelMessage);
+     */
+    callServices(metadata?: grpc.Metadata | grpc.CallOptions, options?: grpc.CallOptions): grpc.ClientDuplexStream<RequestChannelMessage, ResponseChannelMessage>;
+    /**
+     * @generated from protobuf rpc: ListKnownReceivers(google.protobuf.Empty) returns (serviette.v1.ReceiverRecords);
+     */
+    listKnownReceivers(input: Empty, metadata: grpc.Metadata | grpc.CallOptions | ((err: grpc.ServiceError | null, value?: ReceiverRecords) => void), options?: grpc.CallOptions | ((err: grpc.ServiceError | null, value?: ReceiverRecords) => void), callback?: ((err: grpc.ServiceError | null, value?: ReceiverRecords) => void)): grpc.ClientUnaryCall;
+}
+/**
+ * @generated from protobuf service serviette.v1.WebServiceReceiver
+ */
+export interface IWebServiceReceiverClient {
+    /**
+     * @generated from protobuf rpc: RegisterReceiver(serviette.v1.WebReceiverRegistration) returns (stream serviette.v1.RequestChannelMessage);
+     */
+    registerReceiver(input: WebReceiverRegistration, metadata?: grpc.Metadata, options?: grpc.CallOptions): grpc.ClientReadableStream<RequestChannelMessage>;
+    registerReceiver(input: WebReceiverRegistration, options?: grpc.CallOptions): grpc.ClientReadableStream<RequestChannelMessage>;
+    /**
+     * @generated from protobuf rpc: SendResponse(serviette.v1.ResponseChannelMessage) returns (serviette.v1.WebSendResponseMessage);
+     */
+    sendResponse(input: ResponseChannelMessage, metadata: grpc.Metadata, options: grpc.CallOptions, callback: (err: grpc.ServiceError | null, value?: WebSendResponseMessage) => void): grpc.ClientUnaryCall;
+    sendResponse(input: ResponseChannelMessage, metadata: grpc.Metadata, callback: (err: grpc.ServiceError | null, value?: WebSendResponseMessage) => void): grpc.ClientUnaryCall;
+    sendResponse(input: ResponseChannelMessage, options: grpc.CallOptions, callback: (err: grpc.ServiceError | null, value?: WebSendResponseMessage) => void): grpc.ClientUnaryCall;
+    sendResponse(input: ResponseChannelMessage, callback: (err: grpc.ServiceError | null, value?: WebSendResponseMessage) => void): grpc.ClientUnaryCall;
+}
+/**
+ * @generated from protobuf service serviette.v1.WebServiceReceiver
+ */
+export declare class WebServiceReceiverClient extends grpc.Client implements IWebServiceReceiverClient {
+    private readonly _binaryOptions;
+    constructor(address: string, credentials: grpc.ChannelCredentials, options?: grpc.ClientOptions, binaryOptions?: Partial<BinaryReadOptions & BinaryWriteOptions>);
+    /**
+     * @generated from protobuf rpc: RegisterReceiver(serviette.v1.WebReceiverRegistration) returns (stream serviette.v1.RequestChannelMessage);
+     */
+    registerReceiver(input: WebReceiverRegistration, metadata?: grpc.Metadata | grpc.CallOptions, options?: grpc.CallOptions): grpc.ClientReadableStream<RequestChannelMessage>;
+    /**
+     * @generated from protobuf rpc: SendResponse(serviette.v1.ResponseChannelMessage) returns (serviette.v1.WebSendResponseMessage);
+     */
+    sendResponse(input: ResponseChannelMessage, metadata: grpc.Metadata | grpc.CallOptions | ((err: grpc.ServiceError | null, value?: WebSendResponseMessage) => void), options?: grpc.CallOptions | ((err: grpc.ServiceError | null, value?: WebSendResponseMessage) => void), callback?: ((err: grpc.ServiceError | null, value?: WebSendResponseMessage) => void)): grpc.ClientUnaryCall;
+}
+/**
+ * @generated from protobuf service serviette.v1.WebServiceCaller
+ */
+export interface IWebServiceCallerClient {
+    /**
+     * @generated from protobuf rpc: CallService(serviette.v1.ServiceRequest) returns (stream serviette.v1.ResponseChannelMessage);
+     */
+    callService(input: ServiceRequest, metadata?: grpc.Metadata, options?: grpc.CallOptions): grpc.ClientReadableStream<ResponseChannelMessage>;
+    callService(input: ServiceRequest, options?: grpc.CallOptions): grpc.ClientReadableStream<ResponseChannelMessage>;
+    /**
+     * @generated from protobuf rpc: CallServices(serviette.v1.ServiceRequests) returns (stream serviette.v1.ResponseChannelMessage);
+     */
+    callServices(input: ServiceRequests, metadata?: grpc.Metadata, options?: grpc.CallOptions): grpc.ClientReadableStream<ResponseChannelMessage>;
+    callServices(input: ServiceRequests, options?: grpc.CallOptions): grpc.ClientReadableStream<ResponseChannelMessage>;
+    /**
+     * @generated from protobuf rpc: CancelService(serviette.v1.RequestCancellation) returns (stream serviette.v1.ResponseChannelMessage);
+     */
+    cancelService(input: RequestCancellation, metadata?: grpc.Metadata, options?: grpc.CallOptions): grpc.ClientReadableStream<ResponseChannelMessage>;
+    cancelService(input: RequestCancellation, options?: grpc.CallOptions): grpc.ClientReadableStream<ResponseChannelMessage>;
+    /**
+     * @generated from protobuf rpc: CancelServices(serviette.v1.RequestCancellations) returns (stream serviette.v1.ResponseChannelMessage);
+     */
+    cancelServices(input: RequestCancellations, metadata?: grpc.Metadata, options?: grpc.CallOptions): grpc.ClientReadableStream<ResponseChannelMessage>;
+    cancelServices(input: RequestCancellations, options?: grpc.CallOptions): grpc.ClientReadableStream<ResponseChannelMessage>;
+    /**
+     * @generated from protobuf rpc: ListKnownReceivers(google.protobuf.Empty) returns (serviette.v1.ReceiverRecords);
+     */
+    listKnownReceivers(input: Empty, metadata: grpc.Metadata, options: grpc.CallOptions, callback: (err: grpc.ServiceError | null, value?: ReceiverRecords) => void): grpc.ClientUnaryCall;
+    listKnownReceivers(input: Empty, metadata: grpc.Metadata, callback: (err: grpc.ServiceError | null, value?: ReceiverRecords) => void): grpc.ClientUnaryCall;
+    listKnownReceivers(input: Empty, options: grpc.CallOptions, callback: (err: grpc.ServiceError | null, value?: ReceiverRecords) => void): grpc.ClientUnaryCall;
+    listKnownReceivers(input: Empty, callback: (err: grpc.ServiceError | null, value?: ReceiverRecords) => void): grpc.ClientUnaryCall;
+}
+/**
+ * @generated from protobuf service serviette.v1.WebServiceCaller
+ */
+export declare class WebServiceCallerClient extends grpc.Client implements IWebServiceCallerClient {
+    private readonly _binaryOptions;
+    constructor(address: string, credentials: grpc.ChannelCredentials, options?: grpc.ClientOptions, binaryOptions?: Partial<BinaryReadOptions & BinaryWriteOptions>);
+    /**
+     * @generated from protobuf rpc: CallService(serviette.v1.ServiceRequest) returns (stream serviette.v1.ResponseChannelMessage);
+     */
+    callService(input: ServiceRequest, metadata?: grpc.Metadata | grpc.CallOptions, options?: grpc.CallOptions): grpc.ClientReadableStream<ResponseChannelMessage>;
+    /**
+     * @generated from protobuf rpc: CallServices(serviette.v1.ServiceRequests) returns (stream serviette.v1.ResponseChannelMessage);
+     */
+    callServices(input: ServiceRequests, metadata?: grpc.Metadata | grpc.CallOptions, options?: grpc.CallOptions): grpc.ClientReadableStream<ResponseChannelMessage>;
+    /**
+     * @generated from protobuf rpc: CancelService(serviette.v1.RequestCancellation) returns (stream serviette.v1.ResponseChannelMessage);
+     */
+    cancelService(input: RequestCancellation, metadata?: grpc.Metadata | grpc.CallOptions, options?: grpc.CallOptions): grpc.ClientReadableStream<ResponseChannelMessage>;
+    /**
+     * @generated from protobuf rpc: CancelServices(serviette.v1.RequestCancellations) returns (stream serviette.v1.ResponseChannelMessage);
+     */
+    cancelServices(input: RequestCancellations, metadata?: grpc.Metadata | grpc.CallOptions, options?: grpc.CallOptions): grpc.ClientReadableStream<ResponseChannelMessage>;
+    /**
+     * @generated from protobuf rpc: ListKnownReceivers(google.protobuf.Empty) returns (serviette.v1.ReceiverRecords);
+     */
+    listKnownReceivers(input: Empty, metadata: grpc.Metadata | grpc.CallOptions | ((err: grpc.ServiceError | null, value?: ReceiverRecords) => void), options?: grpc.CallOptions | ((err: grpc.ServiceError | null, value?: ReceiverRecords) => void), callback?: ((err: grpc.ServiceError | null, value?: ReceiverRecords) => void)): grpc.ClientUnaryCall;
+}
+/**
+ * @generated from protobuf service serviette.v1.MeshAdmin
+ */
+export interface IMeshAdminClient {
+    /**
+     * @generated from protobuf rpc: ListKnownReceivers(google.protobuf.Empty) returns (serviette.v1.ReceiverRecords);
+     */
+    listKnownReceivers(input: Empty, metadata: grpc.Metadata, options: grpc.CallOptions, callback: (err: grpc.ServiceError | null, value?: ReceiverRecords) => void): grpc.ClientUnaryCall;
+    listKnownReceivers(input: Empty, metadata: grpc.Metadata, callback: (err: grpc.ServiceError | null, value?: ReceiverRecords) => void): grpc.ClientUnaryCall;
+    listKnownReceivers(input: Empty, options: grpc.CallOptions, callback: (err: grpc.ServiceError | null, value?: ReceiverRecords) => void): grpc.ClientUnaryCall;
+    listKnownReceivers(input: Empty, callback: (err: grpc.ServiceError | null, value?: ReceiverRecords) => void): grpc.ClientUnaryCall;
+    /**
+     * @generated from protobuf rpc: AddGatewayNode(serviette.v1.MeshNodeRequest) returns (serviette.v1.MeshNodeResponse);
+     */
+    addGatewayNode(input: MeshNodeRequest, metadata: grpc.Metadata, options: grpc.CallOptions, callback: (err: grpc.ServiceError | null, value?: MeshNodeResponse) => void): grpc.ClientUnaryCall;
+    addGatewayNode(input: MeshNodeRequest, metadata: grpc.Metadata, callback: (err: grpc.ServiceError | null, value?: MeshNodeResponse) => void): grpc.ClientUnaryCall;
+    addGatewayNode(input: MeshNodeRequest, options: grpc.CallOptions, callback: (err: grpc.ServiceError | null, value?: MeshNodeResponse) => void): grpc.ClientUnaryCall;
+    addGatewayNode(input: MeshNodeRequest, callback: (err: grpc.ServiceError | null, value?: MeshNodeResponse) => void): grpc.ClientUnaryCall;
+}
+/**
+ * @generated from protobuf service serviette.v1.MeshAdmin
+ */
+export declare class MeshAdminClient extends grpc.Client implements IMeshAdminClient {
+    private readonly _binaryOptions;
+    constructor(address: string, credentials: grpc.ChannelCredentials, options?: grpc.ClientOptions, binaryOptions?: Partial<BinaryReadOptions & BinaryWriteOptions>);
+    /**
+     * @generated from protobuf rpc: ListKnownReceivers(google.protobuf.Empty) returns (serviette.v1.ReceiverRecords);
+     */
+    listKnownReceivers(input: Empty, metadata: grpc.Metadata | grpc.CallOptions | ((err: grpc.ServiceError | null, value?: ReceiverRecords) => void), options?: grpc.CallOptions | ((err: grpc.ServiceError | null, value?: ReceiverRecords) => void), callback?: ((err: grpc.ServiceError | null, value?: ReceiverRecords) => void)): grpc.ClientUnaryCall;
+    /**
+     * @generated from protobuf rpc: AddGatewayNode(serviette.v1.MeshNodeRequest) returns (serviette.v1.MeshNodeResponse);
+     */
+    addGatewayNode(input: MeshNodeRequest, metadata: grpc.Metadata | grpc.CallOptions | ((err: grpc.ServiceError | null, value?: MeshNodeResponse) => void), options?: grpc.CallOptions | ((err: grpc.ServiceError | null, value?: MeshNodeResponse) => void), callback?: ((err: grpc.ServiceError | null, value?: MeshNodeResponse) => void)): grpc.ClientUnaryCall;
+}
+/**
+ * @generated from protobuf service serviette.v1.Mesh
+ */
+export interface IMeshClient {
+    /**
+     * @generated from protobuf rpc: JoinMesh(stream serviette.v1.MeshInfo) returns (stream serviette.v1.MeshInfo);
+     */
+    joinMesh(metadata: grpc.Metadata, options?: grpc.CallOptions): grpc.ClientDuplexStream<MeshInfo, MeshInfo>;
+    joinMesh(options?: grpc.CallOptions): grpc.ClientDuplexStream<MeshInfo, MeshInfo>;
+}
+/**
+ * @generated from protobuf service serviette.v1.Mesh
+ */
+export declare class MeshClient extends grpc.Client implements IMeshClient {
+    private readonly _binaryOptions;
+    constructor(address: string, credentials: grpc.ChannelCredentials, options?: grpc.ClientOptions, binaryOptions?: Partial<BinaryReadOptions & BinaryWriteOptions>);
+    /**
+     * @generated from protobuf rpc: JoinMesh(stream serviette.v1.MeshInfo) returns (stream serviette.v1.MeshInfo);
+     */
+    joinMesh(metadata?: grpc.Metadata | grpc.CallOptions, options?: grpc.CallOptions): grpc.ClientDuplexStream<MeshInfo, MeshInfo>;
+}

package/grpc/serviette.v1_pb.grpc-client.js

@@ -0,0 +1,162 @@
+/* eslint-disable */
+// @generated by protobuf-ts 2.9.1 with parameter ts_nocheck,eslint_disable,add_pb_suffix,client_grpc1,optimize_code_size,long_type_string
+// @generated from protobuf file "serviette.v1.proto" (package "serviette.v1", syntax proto3)
+// tslint:disable
+// @ts-nocheck
+import { Mesh } from "./serviette.v1_pb";
+import { MeshAdmin } from "./serviette.v1_pb";
+import { WebServiceCaller } from "./serviette.v1_pb";
+import { WebServiceReceiver } from "./serviette.v1_pb";
+import { ServiceCaller } from "./serviette.v1_pb";
+import { ServiceReceiver } from "./serviette.v1_pb";
+import * as grpc from "@grpc/grpc-js";
+// Use this: /snap/bin/protoc -I components/ext/service/service-gateway/proto/ -I $(go env GOPATH)/pkg/mod/github.com/team-rocos/go-common@v1.0.17/proto/  components/ext/service/service-gateway/proto/serviette/serviette.v1.proto --go_out=plugins=grpc:components/ext/service/service-gateway/proto/
+// SERVICE DEFINITIONS.
+// The regular services make full use of bidirectional streaming.
+/**
+ * @generated from protobuf service serviette.v1.ServiceReceiver
+ */
+export class ServiceReceiverClient extends grpc.Client {
+    constructor(address, credentials, options = {}, binaryOptions = {}) {
+        super(address, credentials, options);
+        this._binaryOptions = binaryOptions;
+    }
+    /**
+     * @generated from protobuf rpc: RegisterReceiver(stream serviette.v1.ResponseChannelMessage) returns (stream serviette.v1.RequestChannelMessage);
+     */
+    registerReceiver(metadata, options) {
+        const method = ServiceReceiver.methods[0];
+        return this.makeBidiStreamRequest(`/${ServiceReceiver.typeName}/${method.name}`, (value) => Buffer.from(method.I.toBinary(value, this._binaryOptions)), (value) => method.O.fromBinary(value, this._binaryOptions), metadata, options);
+    }
+}
+/**
+ * @generated from protobuf service serviette.v1.ServiceCaller
+ */
+export class ServiceCallerClient extends grpc.Client {
+    constructor(address, credentials, options = {}, binaryOptions = {}) {
+        super(address, credentials, options);
+        this._binaryOptions = binaryOptions;
+    }
+    /**
+     * @generated from protobuf rpc: CallServices(stream serviette.v1.RequestChannelMessage) returns (stream serviette.v1.ResponseChannelMessage);
+     */
+    callServices(metadata, options) {
+        const method = ServiceCaller.methods[0];
+        return this.makeBidiStreamRequest(`/${ServiceCaller.typeName}/${method.name}`, (value) => Buffer.from(method.I.toBinary(value, this._binaryOptions)), (value) => method.O.fromBinary(value, this._binaryOptions), metadata, options);
+    }
+    /**
+     * @generated from protobuf rpc: ListKnownReceivers(google.protobuf.Empty) returns (serviette.v1.ReceiverRecords);
+     */
+    listKnownReceivers(input, metadata, options, callback) {
+        const method = ServiceCaller.methods[1];
+        return this.makeUnaryRequest(`/${ServiceCaller.typeName}/${method.name}`, (value) => Buffer.from(method.I.toBinary(value, this._binaryOptions)), (value) => method.O.fromBinary(value, this._binaryOptions), input, metadata, options, callback);
+    }
+}
+// The web services have some extra stuff to account for the lack of bidirectional streaming support.
+/**
+ * @generated from protobuf service serviette.v1.WebServiceReceiver
+ */
+export class WebServiceReceiverClient extends grpc.Client {
+    constructor(address, credentials, options = {}, binaryOptions = {}) {
+        super(address, credentials, options);
+        this._binaryOptions = binaryOptions;
+    }
+    /**
+     * @generated from protobuf rpc: RegisterReceiver(serviette.v1.WebReceiverRegistration) returns (stream serviette.v1.RequestChannelMessage);
+     */
+    registerReceiver(input, metadata, options) {
+        const method = WebServiceReceiver.methods[0];
+        return this.makeServerStreamRequest(`/${WebServiceReceiver.typeName}/${method.name}`, (value) => Buffer.from(method.I.toBinary(value, this._binaryOptions)), (value) => method.O.fromBinary(value, this._binaryOptions), input, metadata, options);
+    }
+    /**
+     * @generated from protobuf rpc: SendResponse(serviette.v1.ResponseChannelMessage) returns (serviette.v1.WebSendResponseMessage);
+     */
+    sendResponse(input, metadata, options, callback) {
+        const method = WebServiceReceiver.methods[1];
+        return this.makeUnaryRequest(`/${WebServiceReceiver.typeName}/${method.name}`, (value) => Buffer.from(method.I.toBinary(value, this._binaryOptions)), (value) => method.O.fromBinary(value, this._binaryOptions), input, metadata, options, callback);
+    }
+}
+/**
+ * @generated from protobuf service serviette.v1.WebServiceCaller
+ */
+export class WebServiceCallerClient extends grpc.Client {
+    constructor(address, credentials, options = {}, binaryOptions = {}) {
+        super(address, credentials, options);
+        this._binaryOptions = binaryOptions;
+    }
+    /**
+     * @generated from protobuf rpc: CallService(serviette.v1.ServiceRequest) returns (stream serviette.v1.ResponseChannelMessage);
+     */
+    callService(input, metadata, options) {
+        const method = WebServiceCaller.methods[0];
+        return this.makeServerStreamRequest(`/${WebServiceCaller.typeName}/${method.name}`, (value) => Buffer.from(method.I.toBinary(value, this._binaryOptions)), (value) => method.O.fromBinary(value, this._binaryOptions), input, metadata, options);
+    }
+    /**
+     * @generated from protobuf rpc: CallServices(serviette.v1.ServiceRequests) returns (stream serviette.v1.ResponseChannelMessage);
+     */
+    callServices(input, metadata, options) {
+        const method = WebServiceCaller.methods[1];
+        return this.makeServerStreamRequest(`/${WebServiceCaller.typeName}/${method.name}`, (value) => Buffer.from(method.I.toBinary(value, this._binaryOptions)), (value) => method.O.fromBinary(value, this._binaryOptions), input, metadata, options);
+    }
+    /**
+     * @generated from protobuf rpc: CancelService(serviette.v1.RequestCancellation) returns (stream serviette.v1.ResponseChannelMessage);
+     */
+    cancelService(input, metadata, options) {
+        const method = WebServiceCaller.methods[2];
+        return this.makeServerStreamRequest(`/${WebServiceCaller.typeName}/${method.name}`, (value) => Buffer.from(method.I.toBinary(value, this._binaryOptions)), (value) => method.O.fromBinary(value, this._binaryOptions), input, metadata, options);
+    }
+    /**
+     * @generated from protobuf rpc: CancelServices(serviette.v1.RequestCancellations) returns (stream serviette.v1.ResponseChannelMessage);
+     */
+    cancelServices(input, metadata, options) {
+        const method = WebServiceCaller.methods[3];
+        return this.makeServerStreamRequest(`/${WebServiceCaller.typeName}/${method.name}`, (value) => Buffer.from(method.I.toBinary(value, this._binaryOptions)), (value) => method.O.fromBinary(value, this._binaryOptions), input, metadata, options);
+    }
+    /**
+     * @generated from protobuf rpc: ListKnownReceivers(google.protobuf.Empty) returns (serviette.v1.ReceiverRecords);
+     */
+    listKnownReceivers(input, metadata, options, callback) {
+        const method = WebServiceCaller.methods[4];
+        return this.makeUnaryRequest(`/${WebServiceCaller.typeName}/${method.name}`, (value) => Buffer.from(method.I.toBinary(value, this._binaryOptions)), (value) => method.O.fromBinary(value, this._binaryOptions), input, metadata, options, callback);
+    }
+}
+// Mesh services.
+/**
+ * @generated from protobuf service serviette.v1.MeshAdmin
+ */
+export class MeshAdminClient extends grpc.Client {
+    constructor(address, credentials, options = {}, binaryOptions = {}) {
+        super(address, credentials, options);
+        this._binaryOptions = binaryOptions;
+    }
+    /**
+     * @generated from protobuf rpc: ListKnownReceivers(google.protobuf.Empty) returns (serviette.v1.ReceiverRecords);
+     */
+    listKnownReceivers(input, metadata, options, callback) {
+        const method = MeshAdmin.methods[0];
+        return this.makeUnaryRequest(`/${MeshAdmin.typeName}/${method.name}`, (value) => Buffer.from(method.I.toBinary(value, this._binaryOptions)), (value) => method.O.fromBinary(value, this._binaryOptions), input, metadata, options, callback);
+    }
+    /**
+     * @generated from protobuf rpc: AddGatewayNode(serviette.v1.MeshNodeRequest) returns (serviette.v1.MeshNodeResponse);
+     */
+    addGatewayNode(input, metadata, options, callback) {
+        const method = MeshAdmin.methods[1];
+        return this.makeUnaryRequest(`/${MeshAdmin.typeName}/${method.name}`, (value) => Buffer.from(method.I.toBinary(value, this._binaryOptions)), (value) => method.O.fromBinary(value, this._binaryOptions), input, metadata, options, callback);
+    }
+}
+/**
+ * @generated from protobuf service serviette.v1.Mesh
+ */
+export class MeshClient extends grpc.Client {
+    constructor(address, credentials, options = {}, binaryOptions = {}) {
+        super(address, credentials, options);
+        this._binaryOptions = binaryOptions;
+    }
+    /**
+     * @generated from protobuf rpc: JoinMesh(stream serviette.v1.MeshInfo) returns (stream serviette.v1.MeshInfo);
+     */
+    joinMesh(metadata, options) {
+        const method = Mesh.methods[0];
+        return this.makeBidiStreamRequest(`/${Mesh.typeName}/${method.name}`, (value) => Buffer.from(method.I.toBinary(value, this._binaryOptions)), (value) => method.O.fromBinary(value, this._binaryOptions), metadata, options);
+    }
+}