@gitpod/supervisor-api-grpc 0.1.5-se-workspace-id.35 → 0.1.5-se-init.1

package/lib/port_grpc_pb.d.ts

@@ -0,0 +1,108 @@
+// package: supervisor
+// file: port.proto
+
+/* tslint:disable */
+/* eslint-disable */
+
+import * as grpc from "@grpc/grpc-js";
+import * as port_pb from "./port_pb";
+
+interface IPortServiceService extends grpc.ServiceDefinition<grpc.UntypedServiceImplementation> {
+    tunnel: IPortServiceService_ITunnel;
+    closeTunnel: IPortServiceService_ICloseTunnel;
+    establishTunnel: IPortServiceService_IEstablishTunnel;
+    autoTunnel: IPortServiceService_IAutoTunnel;
+    retryAutoExpose: IPortServiceService_IRetryAutoExpose;
+}
+
+interface IPortServiceService_ITunnel extends grpc.MethodDefinition<port_pb.TunnelPortRequest, port_pb.TunnelPortResponse> {
+    path: "/supervisor.PortService/Tunnel";
+    requestStream: false;
+    responseStream: false;
+    requestSerialize: grpc.serialize<port_pb.TunnelPortRequest>;
+    requestDeserialize: grpc.deserialize<port_pb.TunnelPortRequest>;
+    responseSerialize: grpc.serialize<port_pb.TunnelPortResponse>;
+    responseDeserialize: grpc.deserialize<port_pb.TunnelPortResponse>;
+}
+interface IPortServiceService_ICloseTunnel extends grpc.MethodDefinition<port_pb.CloseTunnelRequest, port_pb.CloseTunnelResponse> {
+    path: "/supervisor.PortService/CloseTunnel";
+    requestStream: false;
+    responseStream: false;
+    requestSerialize: grpc.serialize<port_pb.CloseTunnelRequest>;
+    requestDeserialize: grpc.deserialize<port_pb.CloseTunnelRequest>;
+    responseSerialize: grpc.serialize<port_pb.CloseTunnelResponse>;
+    responseDeserialize: grpc.deserialize<port_pb.CloseTunnelResponse>;
+}
+interface IPortServiceService_IEstablishTunnel extends grpc.MethodDefinition<port_pb.EstablishTunnelRequest, port_pb.EstablishTunnelResponse> {
+    path: "/supervisor.PortService/EstablishTunnel";
+    requestStream: true;
+    responseStream: true;
+    requestSerialize: grpc.serialize<port_pb.EstablishTunnelRequest>;
+    requestDeserialize: grpc.deserialize<port_pb.EstablishTunnelRequest>;
+    responseSerialize: grpc.serialize<port_pb.EstablishTunnelResponse>;
+    responseDeserialize: grpc.deserialize<port_pb.EstablishTunnelResponse>;
+}
+interface IPortServiceService_IAutoTunnel extends grpc.MethodDefinition<port_pb.AutoTunnelRequest, port_pb.AutoTunnelResponse> {
+    path: "/supervisor.PortService/AutoTunnel";
+    requestStream: false;
+    responseStream: false;
+    requestSerialize: grpc.serialize<port_pb.AutoTunnelRequest>;
+    requestDeserialize: grpc.deserialize<port_pb.AutoTunnelRequest>;
+    responseSerialize: grpc.serialize<port_pb.AutoTunnelResponse>;
+    responseDeserialize: grpc.deserialize<port_pb.AutoTunnelResponse>;
+}
+interface IPortServiceService_IRetryAutoExpose extends grpc.MethodDefinition<port_pb.RetryAutoExposeRequest, port_pb.RetryAutoExposeResponse> {
+    path: "/supervisor.PortService/RetryAutoExpose";
+    requestStream: false;
+    responseStream: false;
+    requestSerialize: grpc.serialize<port_pb.RetryAutoExposeRequest>;
+    requestDeserialize: grpc.deserialize<port_pb.RetryAutoExposeRequest>;
+    responseSerialize: grpc.serialize<port_pb.RetryAutoExposeResponse>;
+    responseDeserialize: grpc.deserialize<port_pb.RetryAutoExposeResponse>;
+}
+
+export const PortServiceService: IPortServiceService;
+
+export interface IPortServiceServer extends grpc.UntypedServiceImplementation {
+    tunnel: grpc.handleUnaryCall<port_pb.TunnelPortRequest, port_pb.TunnelPortResponse>;
+    closeTunnel: grpc.handleUnaryCall<port_pb.CloseTunnelRequest, port_pb.CloseTunnelResponse>;
+    establishTunnel: grpc.handleBidiStreamingCall<port_pb.EstablishTunnelRequest, port_pb.EstablishTunnelResponse>;
+    autoTunnel: grpc.handleUnaryCall<port_pb.AutoTunnelRequest, port_pb.AutoTunnelResponse>;
+    retryAutoExpose: grpc.handleUnaryCall<port_pb.RetryAutoExposeRequest, port_pb.RetryAutoExposeResponse>;
+}
+
+export interface IPortServiceClient {
+    tunnel(request: port_pb.TunnelPortRequest, callback: (error: grpc.ServiceError | null, response: port_pb.TunnelPortResponse) => void): grpc.ClientUnaryCall;
+    tunnel(request: port_pb.TunnelPortRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: port_pb.TunnelPortResponse) => void): grpc.ClientUnaryCall;
+    tunnel(request: port_pb.TunnelPortRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: port_pb.TunnelPortResponse) => void): grpc.ClientUnaryCall;
+    closeTunnel(request: port_pb.CloseTunnelRequest, callback: (error: grpc.ServiceError | null, response: port_pb.CloseTunnelResponse) => void): grpc.ClientUnaryCall;
+    closeTunnel(request: port_pb.CloseTunnelRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: port_pb.CloseTunnelResponse) => void): grpc.ClientUnaryCall;
+    closeTunnel(request: port_pb.CloseTunnelRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: port_pb.CloseTunnelResponse) => void): grpc.ClientUnaryCall;
+    establishTunnel(): grpc.ClientDuplexStream<port_pb.EstablishTunnelRequest, port_pb.EstablishTunnelResponse>;
+    establishTunnel(options: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<port_pb.EstablishTunnelRequest, port_pb.EstablishTunnelResponse>;
+    establishTunnel(metadata: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<port_pb.EstablishTunnelRequest, port_pb.EstablishTunnelResponse>;
+    autoTunnel(request: port_pb.AutoTunnelRequest, callback: (error: grpc.ServiceError | null, response: port_pb.AutoTunnelResponse) => void): grpc.ClientUnaryCall;
+    autoTunnel(request: port_pb.AutoTunnelRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: port_pb.AutoTunnelResponse) => void): grpc.ClientUnaryCall;
+    autoTunnel(request: port_pb.AutoTunnelRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: port_pb.AutoTunnelResponse) => void): grpc.ClientUnaryCall;
+    retryAutoExpose(request: port_pb.RetryAutoExposeRequest, callback: (error: grpc.ServiceError | null, response: port_pb.RetryAutoExposeResponse) => void): grpc.ClientUnaryCall;
+    retryAutoExpose(request: port_pb.RetryAutoExposeRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: port_pb.RetryAutoExposeResponse) => void): grpc.ClientUnaryCall;
+    retryAutoExpose(request: port_pb.RetryAutoExposeRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: port_pb.RetryAutoExposeResponse) => void): grpc.ClientUnaryCall;
+}
+
+export class PortServiceClient extends grpc.Client implements IPortServiceClient {
+    constructor(address: string, credentials: grpc.ChannelCredentials, options?: Partial<grpc.ClientOptions>);
+    public tunnel(request: port_pb.TunnelPortRequest, callback: (error: grpc.ServiceError | null, response: port_pb.TunnelPortResponse) => void): grpc.ClientUnaryCall;
+    public tunnel(request: port_pb.TunnelPortRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: port_pb.TunnelPortResponse) => void): grpc.ClientUnaryCall;
+    public tunnel(request: port_pb.TunnelPortRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: port_pb.TunnelPortResponse) => void): grpc.ClientUnaryCall;
+    public closeTunnel(request: port_pb.CloseTunnelRequest, callback: (error: grpc.ServiceError | null, response: port_pb.CloseTunnelResponse) => void): grpc.ClientUnaryCall;
+    public closeTunnel(request: port_pb.CloseTunnelRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: port_pb.CloseTunnelResponse) => void): grpc.ClientUnaryCall;
+    public closeTunnel(request: port_pb.CloseTunnelRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: port_pb.CloseTunnelResponse) => void): grpc.ClientUnaryCall;
+    public establishTunnel(options?: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<port_pb.EstablishTunnelRequest, port_pb.EstablishTunnelResponse>;
+    public establishTunnel(metadata?: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<port_pb.EstablishTunnelRequest, port_pb.EstablishTunnelResponse>;
+    public autoTunnel(request: port_pb.AutoTunnelRequest, callback: (error: grpc.ServiceError | null, response: port_pb.AutoTunnelResponse) => void): grpc.ClientUnaryCall;
+    public autoTunnel(request: port_pb.AutoTunnelRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: port_pb.AutoTunnelResponse) => void): grpc.ClientUnaryCall;
+    public autoTunnel(request: port_pb.AutoTunnelRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: port_pb.AutoTunnelResponse) => void): grpc.ClientUnaryCall;
+    public retryAutoExpose(request: port_pb.RetryAutoExposeRequest, callback: (error: grpc.ServiceError | null, response: port_pb.RetryAutoExposeResponse) => void): grpc.ClientUnaryCall;
+    public retryAutoExpose(request: port_pb.RetryAutoExposeRequest, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: port_pb.RetryAutoExposeResponse) => void): grpc.ClientUnaryCall;
+    public retryAutoExpose(request: port_pb.RetryAutoExposeRequest, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: port_pb.RetryAutoExposeResponse) => void): grpc.ClientUnaryCall;
+}

package/lib/port_grpc_pb.js

@@ -0,0 +1,187 @@
+// GENERATED CODE -- DO NOT EDIT!
+
+// Original file comments:
+// Copyright (c) 2021 Gitpod GmbH. All rights reserved.
+// Licensed under the GNU Affero General Public License (AGPL).
+// See License-AGPL.txt in the project root for license information.
+//
+'use strict';
+var grpc = require('@grpc/grpc-js');
+var port_pb = require('./port_pb.js');
+
+function serialize_supervisor_AutoTunnelRequest(arg) {
+  if (!(arg instanceof port_pb.AutoTunnelRequest)) {
+    throw new Error('Expected argument of type supervisor.AutoTunnelRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_supervisor_AutoTunnelRequest(buffer_arg) {
+  return port_pb.AutoTunnelRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_supervisor_AutoTunnelResponse(arg) {
+  if (!(arg instanceof port_pb.AutoTunnelResponse)) {
+    throw new Error('Expected argument of type supervisor.AutoTunnelResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_supervisor_AutoTunnelResponse(buffer_arg) {
+  return port_pb.AutoTunnelResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_supervisor_CloseTunnelRequest(arg) {
+  if (!(arg instanceof port_pb.CloseTunnelRequest)) {
+    throw new Error('Expected argument of type supervisor.CloseTunnelRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_supervisor_CloseTunnelRequest(buffer_arg) {
+  return port_pb.CloseTunnelRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_supervisor_CloseTunnelResponse(arg) {
+  if (!(arg instanceof port_pb.CloseTunnelResponse)) {
+    throw new Error('Expected argument of type supervisor.CloseTunnelResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_supervisor_CloseTunnelResponse(buffer_arg) {
+  return port_pb.CloseTunnelResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_supervisor_EstablishTunnelRequest(arg) {
+  if (!(arg instanceof port_pb.EstablishTunnelRequest)) {
+    throw new Error('Expected argument of type supervisor.EstablishTunnelRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_supervisor_EstablishTunnelRequest(buffer_arg) {
+  return port_pb.EstablishTunnelRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_supervisor_EstablishTunnelResponse(arg) {
+  if (!(arg instanceof port_pb.EstablishTunnelResponse)) {
+    throw new Error('Expected argument of type supervisor.EstablishTunnelResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_supervisor_EstablishTunnelResponse(buffer_arg) {
+  return port_pb.EstablishTunnelResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_supervisor_RetryAutoExposeRequest(arg) {
+  if (!(arg instanceof port_pb.RetryAutoExposeRequest)) {
+    throw new Error('Expected argument of type supervisor.RetryAutoExposeRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_supervisor_RetryAutoExposeRequest(buffer_arg) {
+  return port_pb.RetryAutoExposeRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_supervisor_RetryAutoExposeResponse(arg) {
+  if (!(arg instanceof port_pb.RetryAutoExposeResponse)) {
+    throw new Error('Expected argument of type supervisor.RetryAutoExposeResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_supervisor_RetryAutoExposeResponse(buffer_arg) {
+  return port_pb.RetryAutoExposeResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_supervisor_TunnelPortRequest(arg) {
+  if (!(arg instanceof port_pb.TunnelPortRequest)) {
+    throw new Error('Expected argument of type supervisor.TunnelPortRequest');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_supervisor_TunnelPortRequest(buffer_arg) {
+  return port_pb.TunnelPortRequest.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+function serialize_supervisor_TunnelPortResponse(arg) {
+  if (!(arg instanceof port_pb.TunnelPortResponse)) {
+    throw new Error('Expected argument of type supervisor.TunnelPortResponse');
+  }
+  return Buffer.from(arg.serializeBinary());
+}
+
+function deserialize_supervisor_TunnelPortResponse(buffer_arg) {
+  return port_pb.TunnelPortResponse.deserializeBinary(new Uint8Array(buffer_arg));
+}
+
+
+var PortServiceService = exports.PortServiceService = {
+  // Tunnel notifies clients to install listeners on remote machines.
+// After that such clients should call EstablishTunnel to forward incoming connections.
+tunnel: {
+    path: '/supervisor.PortService/Tunnel',
+    requestStream: false,
+    responseStream: false,
+    requestType: port_pb.TunnelPortRequest,
+    responseType: port_pb.TunnelPortResponse,
+    requestSerialize: serialize_supervisor_TunnelPortRequest,
+    requestDeserialize: deserialize_supervisor_TunnelPortRequest,
+    responseSerialize: serialize_supervisor_TunnelPortResponse,
+    responseDeserialize: deserialize_supervisor_TunnelPortResponse,
+  },
+  // CloseTunnel notifies clients to remove listeners on remote machines.
+closeTunnel: {
+    path: '/supervisor.PortService/CloseTunnel',
+    requestStream: false,
+    responseStream: false,
+    requestType: port_pb.CloseTunnelRequest,
+    responseType: port_pb.CloseTunnelResponse,
+    requestSerialize: serialize_supervisor_CloseTunnelRequest,
+    requestDeserialize: deserialize_supervisor_CloseTunnelRequest,
+    responseSerialize: serialize_supervisor_CloseTunnelResponse,
+    responseDeserialize: deserialize_supervisor_CloseTunnelResponse,
+  },
+  // EstablishTunnel actually establishes the tunnel for an incoming connection on a remote machine.
+establishTunnel: {
+    path: '/supervisor.PortService/EstablishTunnel',
+    requestStream: true,
+    responseStream: true,
+    requestType: port_pb.EstablishTunnelRequest,
+    responseType: port_pb.EstablishTunnelResponse,
+    requestSerialize: serialize_supervisor_EstablishTunnelRequest,
+    requestDeserialize: deserialize_supervisor_EstablishTunnelRequest,
+    responseSerialize: serialize_supervisor_EstablishTunnelResponse,
+    responseDeserialize: deserialize_supervisor_EstablishTunnelResponse,
+  },
+  // AutoTunnel controls enablement of auto tunneling
+autoTunnel: {
+    path: '/supervisor.PortService/AutoTunnel',
+    requestStream: false,
+    responseStream: false,
+    requestType: port_pb.AutoTunnelRequest,
+    responseType: port_pb.AutoTunnelResponse,
+    requestSerialize: serialize_supervisor_AutoTunnelRequest,
+    requestDeserialize: deserialize_supervisor_AutoTunnelRequest,
+    responseSerialize: serialize_supervisor_AutoTunnelResponse,
+    responseDeserialize: deserialize_supervisor_AutoTunnelResponse,
+  },
+  // RetryAutoExpose retries auto exposing the give port
+retryAutoExpose: {
+    path: '/supervisor.PortService/RetryAutoExpose',
+    requestStream: false,
+    responseStream: false,
+    requestType: port_pb.RetryAutoExposeRequest,
+    responseType: port_pb.RetryAutoExposeResponse,
+    requestSerialize: serialize_supervisor_RetryAutoExposeRequest,
+    requestDeserialize: deserialize_supervisor_RetryAutoExposeRequest,
+    responseSerialize: serialize_supervisor_RetryAutoExposeResponse,
+    responseDeserialize: deserialize_supervisor_RetryAutoExposeResponse,
+  },
+};
+
+exports.PortServiceClient = grpc.makeGenericClientConstructor(PortServiceService);

package/lib/port_pb.d.ts

@@ -0,0 +1,232 @@
+// package: supervisor
+// file: port.proto
+
+/* tslint:disable */
+/* eslint-disable */
+
+import * as jspb from "google-protobuf";
+
+export class TunnelPortRequest extends jspb.Message { 
+    getPort(): number;
+    setPort(value: number): TunnelPortRequest;
+    getTargetPort(): number;
+    setTargetPort(value: number): TunnelPortRequest;
+    getVisibility(): TunnelVisiblity;
+    setVisibility(value: TunnelVisiblity): TunnelPortRequest;
+    getClientId(): string;
+    setClientId(value: string): TunnelPortRequest;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): TunnelPortRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: TunnelPortRequest): TunnelPortRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: TunnelPortRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): TunnelPortRequest;
+    static deserializeBinaryFromReader(message: TunnelPortRequest, reader: jspb.BinaryReader): TunnelPortRequest;
+}
+
+export namespace TunnelPortRequest {
+    export type AsObject = {
+        port: number,
+        targetPort: number,
+        visibility: TunnelVisiblity,
+        clientId: string,
+    }
+}
+
+export class TunnelPortResponse extends jspb.Message { 
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): TunnelPortResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: TunnelPortResponse): TunnelPortResponse.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: TunnelPortResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): TunnelPortResponse;
+    static deserializeBinaryFromReader(message: TunnelPortResponse, reader: jspb.BinaryReader): TunnelPortResponse;
+}
+
+export namespace TunnelPortResponse {
+    export type AsObject = {
+    }
+}
+
+export class CloseTunnelRequest extends jspb.Message { 
+    getPort(): number;
+    setPort(value: number): CloseTunnelRequest;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): CloseTunnelRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: CloseTunnelRequest): CloseTunnelRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: CloseTunnelRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): CloseTunnelRequest;
+    static deserializeBinaryFromReader(message: CloseTunnelRequest, reader: jspb.BinaryReader): CloseTunnelRequest;
+}
+
+export namespace CloseTunnelRequest {
+    export type AsObject = {
+        port: number,
+    }
+}
+
+export class CloseTunnelResponse extends jspb.Message { 
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): CloseTunnelResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: CloseTunnelResponse): CloseTunnelResponse.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: CloseTunnelResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): CloseTunnelResponse;
+    static deserializeBinaryFromReader(message: CloseTunnelResponse, reader: jspb.BinaryReader): CloseTunnelResponse;
+}
+
+export namespace CloseTunnelResponse {
+    export type AsObject = {
+    }
+}
+
+export class EstablishTunnelRequest extends jspb.Message { 
+
+    hasDesc(): boolean;
+    clearDesc(): void;
+    getDesc(): TunnelPortRequest | undefined;
+    setDesc(value?: TunnelPortRequest): EstablishTunnelRequest;
+
+    hasData(): boolean;
+    clearData(): void;
+    getData(): Uint8Array | string;
+    getData_asU8(): Uint8Array;
+    getData_asB64(): string;
+    setData(value: Uint8Array | string): EstablishTunnelRequest;
+
+    getOutputCase(): EstablishTunnelRequest.OutputCase;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): EstablishTunnelRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: EstablishTunnelRequest): EstablishTunnelRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: EstablishTunnelRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): EstablishTunnelRequest;
+    static deserializeBinaryFromReader(message: EstablishTunnelRequest, reader: jspb.BinaryReader): EstablishTunnelRequest;
+}
+
+export namespace EstablishTunnelRequest {
+    export type AsObject = {
+        desc?: TunnelPortRequest.AsObject,
+        data: Uint8Array | string,
+    }
+
+    export enum OutputCase {
+        OUTPUT_NOT_SET = 0,
+        DESC = 1,
+        DATA = 2,
+    }
+
+}
+
+export class EstablishTunnelResponse extends jspb.Message { 
+    getData(): Uint8Array | string;
+    getData_asU8(): Uint8Array;
+    getData_asB64(): string;
+    setData(value: Uint8Array | string): EstablishTunnelResponse;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): EstablishTunnelResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: EstablishTunnelResponse): EstablishTunnelResponse.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: EstablishTunnelResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): EstablishTunnelResponse;
+    static deserializeBinaryFromReader(message: EstablishTunnelResponse, reader: jspb.BinaryReader): EstablishTunnelResponse;
+}
+
+export namespace EstablishTunnelResponse {
+    export type AsObject = {
+        data: Uint8Array | string,
+    }
+}
+
+export class AutoTunnelRequest extends jspb.Message { 
+    getEnabled(): boolean;
+    setEnabled(value: boolean): AutoTunnelRequest;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): AutoTunnelRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: AutoTunnelRequest): AutoTunnelRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: AutoTunnelRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): AutoTunnelRequest;
+    static deserializeBinaryFromReader(message: AutoTunnelRequest, reader: jspb.BinaryReader): AutoTunnelRequest;
+}
+
+export namespace AutoTunnelRequest {
+    export type AsObject = {
+        enabled: boolean,
+    }
+}
+
+export class AutoTunnelResponse extends jspb.Message { 
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): AutoTunnelResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: AutoTunnelResponse): AutoTunnelResponse.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: AutoTunnelResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): AutoTunnelResponse;
+    static deserializeBinaryFromReader(message: AutoTunnelResponse, reader: jspb.BinaryReader): AutoTunnelResponse;
+}
+
+export namespace AutoTunnelResponse {
+    export type AsObject = {
+    }
+}
+
+export class RetryAutoExposeRequest extends jspb.Message { 
+    getPort(): number;
+    setPort(value: number): RetryAutoExposeRequest;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): RetryAutoExposeRequest.AsObject;
+    static toObject(includeInstance: boolean, msg: RetryAutoExposeRequest): RetryAutoExposeRequest.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: RetryAutoExposeRequest, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): RetryAutoExposeRequest;
+    static deserializeBinaryFromReader(message: RetryAutoExposeRequest, reader: jspb.BinaryReader): RetryAutoExposeRequest;
+}
+
+export namespace RetryAutoExposeRequest {
+    export type AsObject = {
+        port: number,
+    }
+}
+
+export class RetryAutoExposeResponse extends jspb.Message { 
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): RetryAutoExposeResponse.AsObject;
+    static toObject(includeInstance: boolean, msg: RetryAutoExposeResponse): RetryAutoExposeResponse.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: RetryAutoExposeResponse, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): RetryAutoExposeResponse;
+    static deserializeBinaryFromReader(message: RetryAutoExposeResponse, reader: jspb.BinaryReader): RetryAutoExposeResponse;
+}
+
+export namespace RetryAutoExposeResponse {
+    export type AsObject = {
+    }
+}
+
+export enum TunnelVisiblity {
+    NONE = 0,
+    HOST = 1,
+    NETWORK = 2,
+}