@dronedeploy/rocos-js-sdk 1.0.0-alpha-2 → 2.6.1

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

@@ -0,0 +1,884 @@
+// package: serviette.v1
+// file: serviette.v1.proto
+
+import * as jspb from "google-protobuf";
+import * as google_protobuf_empty_pb from "google-protobuf/google/protobuf/empty_pb";
+import * as google_protobuf_descriptor_pb from "google-protobuf/google/protobuf/descriptor_pb";
+import * as common_v1_pb from "./common.v1_pb";
+import * as uri_v1_pb from "./uri.v1_pb";
+
+export class Heartbeat extends jspb.Message {
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): Heartbeat.AsObject;
+  static toObject(includeInstance: boolean, msg: Heartbeat): Heartbeat.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: Heartbeat, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): Heartbeat;
+  static deserializeBinaryFromReader(message: Heartbeat, reader: jspb.BinaryReader): Heartbeat;
+}
+
+export namespace Heartbeat {
+  export type AsObject = {
+  }
+}
+
+export class ServiceCallUID extends jspb.Message {
+  getVersion(): UIDVersionMap[keyof UIDVersionMap];
+  setVersion(value: UIDVersionMap[keyof UIDVersionMap]): void;
+
+  hasHash(): boolean;
+  clearHash(): void;
+  getHash(): string;
+  setHash(value: string): void;
+
+  getContentCase(): ServiceCallUID.ContentCase;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ServiceCallUID.AsObject;
+  static toObject(includeInstance: boolean, msg: ServiceCallUID): ServiceCallUID.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: ServiceCallUID, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ServiceCallUID;
+  static deserializeBinaryFromReader(message: ServiceCallUID, reader: jspb.BinaryReader): ServiceCallUID;
+}
+
+export namespace ServiceCallUID {
+  export type AsObject = {
+    version: UIDVersionMap[keyof UIDVersionMap],
+    hash: string,
+  }
+
+  export enum ContentCase {
+    CONTENT_NOT_SET = 0,
+    HASH = 2,
+  }
+}
+
+export class RequestChannelMessage extends jspb.Message {
+  hasHeartbeat(): boolean;
+  clearHeartbeat(): void;
+  getHeartbeat(): Heartbeat | undefined;
+  setHeartbeat(value?: Heartbeat): void;
+
+  hasRequests(): boolean;
+  clearRequests(): void;
+  getRequests(): ServiceRequests | undefined;
+  setRequests(value?: ServiceRequests): void;
+
+  hasChunks(): boolean;
+  clearChunks(): void;
+  getChunks(): ServiceRequestChunks | undefined;
+  setChunks(value?: ServiceRequestChunks): void;
+
+  hasCancellations(): boolean;
+  clearCancellations(): void;
+  getCancellations(): RequestCancellations | undefined;
+  setCancellations(value?: RequestCancellations): void;
+
+  getContentCase(): RequestChannelMessage.ContentCase;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): RequestChannelMessage.AsObject;
+  static toObject(includeInstance: boolean, msg: RequestChannelMessage): RequestChannelMessage.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: RequestChannelMessage, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): RequestChannelMessage;
+  static deserializeBinaryFromReader(message: RequestChannelMessage, reader: jspb.BinaryReader): RequestChannelMessage;
+}
+
+export namespace RequestChannelMessage {
+  export type AsObject = {
+    heartbeat?: Heartbeat.AsObject,
+    requests?: ServiceRequests.AsObject,
+    chunks?: ServiceRequestChunks.AsObject,
+    cancellations?: RequestCancellations.AsObject,
+  }
+
+  export enum ContentCase {
+    CONTENT_NOT_SET = 0,
+    HEARTBEAT = 1,
+    REQUESTS = 2,
+    CHUNKS = 3,
+    CANCELLATIONS = 4,
+  }
+}
+
+export class ServiceRequests extends jspb.Message {
+  clearRequestsList(): void;
+  getRequestsList(): Array<ServiceRequest>;
+  setRequestsList(value: Array<ServiceRequest>): void;
+  addRequests(value?: ServiceRequest, index?: number): ServiceRequest;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ServiceRequests.AsObject;
+  static toObject(includeInstance: boolean, msg: ServiceRequests): ServiceRequests.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: ServiceRequests, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ServiceRequests;
+  static deserializeBinaryFromReader(message: ServiceRequests, reader: jspb.BinaryReader): ServiceRequests;
+}
+
+export namespace ServiceRequests {
+  export type AsObject = {
+    requestsList: Array<ServiceRequest.AsObject>,
+  }
+}
+
+export class ServiceRequestChunks extends jspb.Message {
+  clearChunksList(): void;
+  getChunksList(): Array<ServiceRequestChunk>;
+  setChunksList(value: Array<ServiceRequestChunk>): void;
+  addChunks(value?: ServiceRequestChunk, index?: number): ServiceRequestChunk;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ServiceRequestChunks.AsObject;
+  static toObject(includeInstance: boolean, msg: ServiceRequestChunks): ServiceRequestChunks.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: ServiceRequestChunks, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ServiceRequestChunks;
+  static deserializeBinaryFromReader(message: ServiceRequestChunks, reader: jspb.BinaryReader): ServiceRequestChunks;
+}
+
+export namespace ServiceRequestChunks {
+  export type AsObject = {
+    chunksList: Array<ServiceRequestChunk.AsObject>,
+  }
+}
+
+export class ServiceRequestChunk extends jspb.Message {
+  hasUid(): boolean;
+  clearUid(): void;
+  getUid(): ServiceCallUID | undefined;
+  setUid(value?: ServiceCallUID): void;
+
+  getChunkindex(): number;
+  setChunkindex(value: number): void;
+
+  getChunkcount(): number;
+  setChunkcount(value: number): void;
+
+  hasHeader(): boolean;
+  clearHeader(): void;
+  getHeader(): ServiceRequestHeader | undefined;
+  setHeader(value?: ServiceRequestHeader): void;
+
+  hasPayload(): boolean;
+  clearPayload(): void;
+  getPayload(): Uint8Array | string;
+  getPayload_asU8(): Uint8Array;
+  getPayload_asB64(): string;
+  setPayload(value: Uint8Array | string): void;
+
+  getContentCase(): ServiceRequestChunk.ContentCase;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ServiceRequestChunk.AsObject;
+  static toObject(includeInstance: boolean, msg: ServiceRequestChunk): ServiceRequestChunk.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: ServiceRequestChunk, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ServiceRequestChunk;
+  static deserializeBinaryFromReader(message: ServiceRequestChunk, reader: jspb.BinaryReader): ServiceRequestChunk;
+}
+
+export namespace ServiceRequestChunk {
+  export type AsObject = {
+    uid?: ServiceCallUID.AsObject,
+    chunkindex: number,
+    chunkcount: number,
+    header?: ServiceRequestHeader.AsObject,
+    payload: Uint8Array | string,
+  }
+
+  export enum ContentCase {
+    CONTENT_NOT_SET = 0,
+    HEADER = 10,
+    PAYLOAD = 11,
+  }
+}
+
+export class ServiceRequest extends jspb.Message {
+  hasUid(): boolean;
+  clearUid(): void;
+  getUid(): ServiceCallUID | undefined;
+  setUid(value?: ServiceCallUID): void;
+
+  hasHeader(): boolean;
+  clearHeader(): void;
+  getHeader(): ServiceRequestHeader | undefined;
+  setHeader(value?: ServiceRequestHeader): void;
+
+  getPayload(): Uint8Array | string;
+  getPayload_asU8(): Uint8Array;
+  getPayload_asB64(): string;
+  setPayload(value: Uint8Array | string): void;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ServiceRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: ServiceRequest): ServiceRequest.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: ServiceRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ServiceRequest;
+  static deserializeBinaryFromReader(message: ServiceRequest, reader: jspb.BinaryReader): ServiceRequest;
+}
+
+export namespace ServiceRequest {
+  export type AsObject = {
+    uid?: ServiceCallUID.AsObject,
+    header?: ServiceRequestHeader.AsObject,
+    payload: Uint8Array | string,
+  }
+}
+
+export class ServiceRequestHeader extends jspb.Message {
+  hasSource(): boolean;
+  clearSource(): void;
+  getSource(): uri_v1_pb.RocosURI | undefined;
+  setSource(value?: uri_v1_pb.RocosURI): void;
+
+  getCreated(): number;
+  setCreated(value: number): void;
+
+  getMetaMap(): jspb.Map<string, string>;
+  clearMetaMap(): void;
+  getResponselevel(): ServiceResponseLevelMap[keyof ServiceResponseLevelMap];
+  setResponselevel(value: ServiceResponseLevelMap[keyof ServiceResponseLevelMap]): void;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ServiceRequestHeader.AsObject;
+  static toObject(includeInstance: boolean, msg: ServiceRequestHeader): ServiceRequestHeader.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: ServiceRequestHeader, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ServiceRequestHeader;
+  static deserializeBinaryFromReader(message: ServiceRequestHeader, reader: jspb.BinaryReader): ServiceRequestHeader;
+}
+
+export namespace ServiceRequestHeader {
+  export type AsObject = {
+    source?: uri_v1_pb.RocosURI.AsObject,
+    created: number,
+    metaMap: Array<[string, string]>,
+    responselevel: ServiceResponseLevelMap[keyof ServiceResponseLevelMap],
+  }
+}
+
+export class RequestCancellations extends jspb.Message {
+  clearCancellationsList(): void;
+  getCancellationsList(): Array<RequestCancellation>;
+  setCancellationsList(value: Array<RequestCancellation>): void;
+  addCancellations(value?: RequestCancellation, index?: number): RequestCancellation;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): RequestCancellations.AsObject;
+  static toObject(includeInstance: boolean, msg: RequestCancellations): RequestCancellations.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: RequestCancellations, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): RequestCancellations;
+  static deserializeBinaryFromReader(message: RequestCancellations, reader: jspb.BinaryReader): RequestCancellations;
+}
+
+export namespace RequestCancellations {
+  export type AsObject = {
+    cancellationsList: Array<RequestCancellation.AsObject>,
+  }
+}
+
+export class RequestCancellation extends jspb.Message {
+  hasUid(): boolean;
+  clearUid(): void;
+  getUid(): ServiceCallUID | undefined;
+  setUid(value?: ServiceCallUID): void;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): RequestCancellation.AsObject;
+  static toObject(includeInstance: boolean, msg: RequestCancellation): RequestCancellation.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: RequestCancellation, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): RequestCancellation;
+  static deserializeBinaryFromReader(message: RequestCancellation, reader: jspb.BinaryReader): RequestCancellation;
+}
+
+export namespace RequestCancellation {
+  export type AsObject = {
+    uid?: ServiceCallUID.AsObject,
+  }
+}
+
+export class ResponseChannelMessage extends jspb.Message {
+  hasHeartbeat(): boolean;
+  clearHeartbeat(): void;
+  getHeartbeat(): Heartbeat | undefined;
+  setHeartbeat(value?: Heartbeat): void;
+
+  hasResponses(): boolean;
+  clearResponses(): void;
+  getResponses(): ServiceResponses | undefined;
+  setResponses(value?: ServiceResponses): void;
+
+  hasChunks(): boolean;
+  clearChunks(): void;
+  getChunks(): ServiceResponseChunks | undefined;
+  setChunks(value?: ServiceResponseChunks): void;
+
+  getContentCase(): ResponseChannelMessage.ContentCase;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ResponseChannelMessage.AsObject;
+  static toObject(includeInstance: boolean, msg: ResponseChannelMessage): ResponseChannelMessage.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: ResponseChannelMessage, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ResponseChannelMessage;
+  static deserializeBinaryFromReader(message: ResponseChannelMessage, reader: jspb.BinaryReader): ResponseChannelMessage;
+}
+
+export namespace ResponseChannelMessage {
+  export type AsObject = {
+    heartbeat?: Heartbeat.AsObject,
+    responses?: ServiceResponses.AsObject,
+    chunks?: ServiceResponseChunks.AsObject,
+  }
+
+  export enum ContentCase {
+    CONTENT_NOT_SET = 0,
+    HEARTBEAT = 1,
+    RESPONSES = 2,
+    CHUNKS = 3,
+  }
+}
+
+export class ServiceResponses extends jspb.Message {
+  clearResponsesList(): void;
+  getResponsesList(): Array<ServiceResponse>;
+  setResponsesList(value: Array<ServiceResponse>): void;
+  addResponses(value?: ServiceResponse, index?: number): ServiceResponse;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ServiceResponses.AsObject;
+  static toObject(includeInstance: boolean, msg: ServiceResponses): ServiceResponses.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: ServiceResponses, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ServiceResponses;
+  static deserializeBinaryFromReader(message: ServiceResponses, reader: jspb.BinaryReader): ServiceResponses;
+}
+
+export namespace ServiceResponses {
+  export type AsObject = {
+    responsesList: Array<ServiceResponse.AsObject>,
+  }
+}
+
+export class ServiceResponseChunks extends jspb.Message {
+  clearChunksList(): void;
+  getChunksList(): Array<ServiceResponseChunk>;
+  setChunksList(value: Array<ServiceResponseChunk>): void;
+  addChunks(value?: ServiceResponseChunk, index?: number): ServiceResponseChunk;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ServiceResponseChunks.AsObject;
+  static toObject(includeInstance: boolean, msg: ServiceResponseChunks): ServiceResponseChunks.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: ServiceResponseChunks, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ServiceResponseChunks;
+  static deserializeBinaryFromReader(message: ServiceResponseChunks, reader: jspb.BinaryReader): ServiceResponseChunks;
+}
+
+export namespace ServiceResponseChunks {
+  export type AsObject = {
+    chunksList: Array<ServiceResponseChunk.AsObject>,
+  }
+}
+
+export class ServiceResponseChunk extends jspb.Message {
+  hasUid(): boolean;
+  clearUid(): void;
+  getUid(): ServiceCallUID | undefined;
+  setUid(value?: ServiceCallUID): void;
+
+  getChunkindex(): number;
+  setChunkindex(value: number): void;
+
+  getChunkcount(): number;
+  setChunkcount(value: number): void;
+
+  hasHeader(): boolean;
+  clearHeader(): void;
+  getHeader(): ServiceReturnHeader | undefined;
+  setHeader(value?: ServiceReturnHeader): void;
+
+  hasPayload(): boolean;
+  clearPayload(): void;
+  getPayload(): Uint8Array | string;
+  getPayload_asU8(): Uint8Array;
+  getPayload_asB64(): string;
+  setPayload(value: Uint8Array | string): void;
+
+  hasAck(): boolean;
+  clearAck(): void;
+  getAck(): ServiceAck | undefined;
+  setAck(value?: ServiceAck): void;
+
+  hasResult(): boolean;
+  clearResult(): void;
+  getResult(): ServiceResult | undefined;
+  setResult(value?: ServiceResult): void;
+
+  getContentCase(): ServiceResponseChunk.ContentCase;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ServiceResponseChunk.AsObject;
+  static toObject(includeInstance: boolean, msg: ServiceResponseChunk): ServiceResponseChunk.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: ServiceResponseChunk, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ServiceResponseChunk;
+  static deserializeBinaryFromReader(message: ServiceResponseChunk, reader: jspb.BinaryReader): ServiceResponseChunk;
+}
+
+export namespace ServiceResponseChunk {
+  export type AsObject = {
+    uid?: ServiceCallUID.AsObject,
+    chunkindex: number,
+    chunkcount: number,
+    header?: ServiceReturnHeader.AsObject,
+    payload: Uint8Array | string,
+    ack?: ServiceAck.AsObject,
+    result?: ServiceResult.AsObject,
+  }
+
+  export enum ContentCase {
+    CONTENT_NOT_SET = 0,
+    HEADER = 10,
+    PAYLOAD = 11,
+    ACK = 12,
+    RESULT = 13,
+  }
+}
+
+export class ServiceResponse extends jspb.Message {
+  hasUid(): boolean;
+  clearUid(): void;
+  getUid(): ServiceCallUID | undefined;
+  setUid(value?: ServiceCallUID): void;
+
+  hasAck(): boolean;
+  clearAck(): void;
+  getAck(): ServiceAck | undefined;
+  setAck(value?: ServiceAck): void;
+
+  hasResult(): boolean;
+  clearResult(): void;
+  getResult(): ServiceResult | undefined;
+  setResult(value?: ServiceResult): void;
+
+  hasReturn(): boolean;
+  clearReturn(): void;
+  getReturn(): ServiceReturn | undefined;
+  setReturn(value?: ServiceReturn): void;
+
+  getContentCase(): ServiceResponse.ContentCase;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ServiceResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: ServiceResponse): ServiceResponse.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: ServiceResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ServiceResponse;
+  static deserializeBinaryFromReader(message: ServiceResponse, reader: jspb.BinaryReader): ServiceResponse;
+}
+
+export namespace ServiceResponse {
+  export type AsObject = {
+    uid?: ServiceCallUID.AsObject,
+    ack?: ServiceAck.AsObject,
+    result?: ServiceResult.AsObject,
+    pb_return?: ServiceReturn.AsObject,
+  }
+
+  export enum ContentCase {
+    CONTENT_NOT_SET = 0,
+    ACK = 10,
+    RESULT = 11,
+    RETURN = 12,
+  }
+}
+
+export class ServiceReturn extends jspb.Message {
+  hasHeader(): boolean;
+  clearHeader(): void;
+  getHeader(): ServiceReturnHeader | undefined;
+  setHeader(value?: ServiceReturnHeader): void;
+
+  getPayload(): Uint8Array | string;
+  getPayload_asU8(): Uint8Array;
+  getPayload_asB64(): string;
+  setPayload(value: Uint8Array | string): void;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ServiceReturn.AsObject;
+  static toObject(includeInstance: boolean, msg: ServiceReturn): ServiceReturn.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: ServiceReturn, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ServiceReturn;
+  static deserializeBinaryFromReader(message: ServiceReturn, reader: jspb.BinaryReader): ServiceReturn;
+}
+
+export namespace ServiceReturn {
+  export type AsObject = {
+    header?: ServiceReturnHeader.AsObject,
+    payload: Uint8Array | string,
+  }
+}
+
+export class ServiceReturnHeader extends jspb.Message {
+  getCreated(): number;
+  setCreated(value: number): void;
+
+  getMetaMap(): jspb.Map<string, string>;
+  clearMetaMap(): void;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ServiceReturnHeader.AsObject;
+  static toObject(includeInstance: boolean, msg: ServiceReturnHeader): ServiceReturnHeader.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: ServiceReturnHeader, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ServiceReturnHeader;
+  static deserializeBinaryFromReader(message: ServiceReturnHeader, reader: jspb.BinaryReader): ServiceReturnHeader;
+}
+
+export namespace ServiceReturnHeader {
+  export type AsObject = {
+    created: number,
+    metaMap: Array<[string, string]>,
+  }
+}
+
+export class ServiceAck extends jspb.Message {
+  getStage(): StageMap[keyof StageMap];
+  setStage(value: StageMap[keyof StageMap]): void;
+
+  getStatus(): AckStatusMap[keyof AckStatusMap];
+  setStatus(value: AckStatusMap[keyof AckStatusMap]): void;
+
+  getMessage(): string;
+  setMessage(value: string): void;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ServiceAck.AsObject;
+  static toObject(includeInstance: boolean, msg: ServiceAck): ServiceAck.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: ServiceAck, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ServiceAck;
+  static deserializeBinaryFromReader(message: ServiceAck, reader: jspb.BinaryReader): ServiceAck;
+}
+
+export namespace ServiceAck {
+  export type AsObject = {
+    stage: StageMap[keyof StageMap],
+    status: AckStatusMap[keyof AckStatusMap],
+    message: string,
+  }
+}
+
+export class ServiceResult extends jspb.Message {
+  getStatus(): ResultStatusMap[keyof ResultStatusMap];
+  setStatus(value: ResultStatusMap[keyof ResultStatusMap]): void;
+
+  getMessage(): string;
+  setMessage(value: string): void;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ServiceResult.AsObject;
+  static toObject(includeInstance: boolean, msg: ServiceResult): ServiceResult.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: ServiceResult, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ServiceResult;
+  static deserializeBinaryFromReader(message: ServiceResult, reader: jspb.BinaryReader): ServiceResult;
+}
+
+export namespace ServiceResult {
+  export type AsObject = {
+    status: ResultStatusMap[keyof ResultStatusMap],
+    message: string,
+  }
+}
+
+export class WebReceiverRegistration extends jspb.Message {
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): WebReceiverRegistration.AsObject;
+  static toObject(includeInstance: boolean, msg: WebReceiverRegistration): WebReceiverRegistration.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: WebReceiverRegistration, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): WebReceiverRegistration;
+  static deserializeBinaryFromReader(message: WebReceiverRegistration, reader: jspb.BinaryReader): WebReceiverRegistration;
+}
+
+export namespace WebReceiverRegistration {
+  export type AsObject = {
+  }
+}
+
+export class WebSendResponseMessage extends jspb.Message {
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): WebSendResponseMessage.AsObject;
+  static toObject(includeInstance: boolean, msg: WebSendResponseMessage): WebSendResponseMessage.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: WebSendResponseMessage, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): WebSendResponseMessage;
+  static deserializeBinaryFromReader(message: WebSendResponseMessage, reader: jspb.BinaryReader): WebSendResponseMessage;
+}
+
+export namespace WebSendResponseMessage {
+  export type AsObject = {
+  }
+}
+
+export class ReceiverRecords extends jspb.Message {
+  clearRecordsList(): void;
+  getRecordsList(): Array<ReceiverRecord>;
+  setRecordsList(value: Array<ReceiverRecord>): void;
+  addRecords(value?: ReceiverRecord, index?: number): ReceiverRecord;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ReceiverRecords.AsObject;
+  static toObject(includeInstance: boolean, msg: ReceiverRecords): ReceiverRecords.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: ReceiverRecords, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ReceiverRecords;
+  static deserializeBinaryFromReader(message: ReceiverRecords, reader: jspb.BinaryReader): ReceiverRecords;
+}
+
+export namespace ReceiverRecords {
+  export type AsObject = {
+    recordsList: Array<ReceiverRecord.AsObject>,
+  }
+}
+
+export class ReceiverRecord extends jspb.Message {
+  hasGateway(): boolean;
+  clearGateway(): void;
+  getGateway(): MeshNodeUID | undefined;
+  setGateway(value?: MeshNodeUID): void;
+
+  getProject(): string;
+  setProject(value: string): void;
+
+  getCallsign(): string;
+  setCallsign(value: string): void;
+
+  getSubsystem(): string;
+  setSubsystem(value: string): void;
+
+  getMetric(): number;
+  setMetric(value: number): void;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): ReceiverRecord.AsObject;
+  static toObject(includeInstance: boolean, msg: ReceiverRecord): ReceiverRecord.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: ReceiverRecord, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): ReceiverRecord;
+  static deserializeBinaryFromReader(message: ReceiverRecord, reader: jspb.BinaryReader): ReceiverRecord;
+}
+
+export namespace ReceiverRecord {
+  export type AsObject = {
+    gateway?: MeshNodeUID.AsObject,
+    project: string,
+    callsign: string,
+    subsystem: string,
+    metric: number,
+  }
+}
+
+export class MeshNodeUID extends jspb.Message {
+  getVersion(): MeshNodeUIDVersionMap[keyof MeshNodeUIDVersionMap];
+  setVersion(value: MeshNodeUIDVersionMap[keyof MeshNodeUIDVersionMap]): void;
+
+  hasName(): boolean;
+  clearName(): void;
+  getName(): string;
+  setName(value: string): void;
+
+  getUidCase(): MeshNodeUID.UidCase;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): MeshNodeUID.AsObject;
+  static toObject(includeInstance: boolean, msg: MeshNodeUID): MeshNodeUID.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: MeshNodeUID, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): MeshNodeUID;
+  static deserializeBinaryFromReader(message: MeshNodeUID, reader: jspb.BinaryReader): MeshNodeUID;
+}
+
+export namespace MeshNodeUID {
+  export type AsObject = {
+    version: MeshNodeUIDVersionMap[keyof MeshNodeUIDVersionMap],
+    name: string,
+  }
+
+  export enum UidCase {
+    UID_NOT_SET = 0,
+    NAME = 2,
+  }
+}
+
+export class MeshNodeRequest extends jspb.Message {
+  hasAddress(): boolean;
+  clearAddress(): void;
+  getAddress(): string;
+  setAddress(value: string): void;
+
+  hasUid(): boolean;
+  clearUid(): void;
+  getUid(): MeshNodeUID | undefined;
+  setUid(value?: MeshNodeUID): void;
+
+  getCommand(): MeshNodeCommandMap[keyof MeshNodeCommandMap];
+  setCommand(value: MeshNodeCommandMap[keyof MeshNodeCommandMap]): void;
+
+  getIdCase(): MeshNodeRequest.IdCase;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): MeshNodeRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: MeshNodeRequest): MeshNodeRequest.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: MeshNodeRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): MeshNodeRequest;
+  static deserializeBinaryFromReader(message: MeshNodeRequest, reader: jspb.BinaryReader): MeshNodeRequest;
+}
+
+export namespace MeshNodeRequest {
+  export type AsObject = {
+    address: string,
+    uid?: MeshNodeUID.AsObject,
+    command: MeshNodeCommandMap[keyof MeshNodeCommandMap],
+  }
+
+  export enum IdCase {
+    ID_NOT_SET = 0,
+    ADDRESS = 1,
+    UID = 2,
+  }
+}
+
+export class MeshNodeResponse extends jspb.Message {
+  getOk(): boolean;
+  setOk(value: boolean): void;
+
+  hasUid(): boolean;
+  clearUid(): void;
+  getUid(): MeshNodeUID | undefined;
+  setUid(value?: MeshNodeUID): void;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): MeshNodeResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: MeshNodeResponse): MeshNodeResponse.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: MeshNodeResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): MeshNodeResponse;
+  static deserializeBinaryFromReader(message: MeshNodeResponse, reader: jspb.BinaryReader): MeshNodeResponse;
+}
+
+export namespace MeshNodeResponse {
+  export type AsObject = {
+    ok: boolean,
+    uid?: MeshNodeUID.AsObject,
+  }
+}
+
+export class MeshInfo extends jspb.Message {
+  hasUid(): boolean;
+  clearUid(): void;
+  getUid(): MeshNodeUID | undefined;
+  setUid(value?: MeshNodeUID): void;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): MeshInfo.AsObject;
+  static toObject(includeInstance: boolean, msg: MeshInfo): MeshInfo.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: MeshInfo, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): MeshInfo;
+  static deserializeBinaryFromReader(message: MeshInfo, reader: jspb.BinaryReader): MeshInfo;
+}
+
+export namespace MeshInfo {
+  export type AsObject = {
+    uid?: MeshNodeUID.AsObject,
+  }
+}
+
+export interface UIDVersionMap {
+  HEADER_HASH_RAND: 0;
+}
+
+export const UIDVersion: UIDVersionMap;
+
+export interface ServiceResponseLevelMap {
+  ALL: 0;
+  RETURN_AND_RESULT: 1;
+  RESULT_ONLY: 2;
+  NONE: 3;
+}
+
+export const ServiceResponseLevel: ServiceResponseLevelMap;
+
+export interface AckStatusMap {
+  RECEIVED: 0;
+  QUEUED: 1;
+  PROGRESS: 2;
+  CANCELLING: 3;
+}
+
+export const AckStatus: AckStatusMap;
+
+export interface ResultStatusMap {
+  COMPLETE_SUCCESS: 0;
+  CANCELLED: 10;
+  COMPLETE_ERROR: 11;
+  TIMED_OUT: 12;
+  REJECTED_ID: 13;
+  REJECTED_AUTH: 14;
+  REJECTED_PAYLOAD: 15;
+  REJECTED_NO_RECEIVER: 16;
+  FATAL: 17;
+}
+
+export const ResultStatus: ResultStatusMap;
+
+export interface StageMap {
+  AGENT: 0;
+  CLOUD_GATEWAY: 1;
+  DEVICE_GATEWAY: 2;
+}
+
+export const Stage: StageMap;
+
+export interface MeshNodeUIDVersionMap {
+  MESH_UID_NAME: 0;
+}
+
+export const MeshNodeUIDVersion: MeshNodeUIDVersionMap;
+
+export interface MeshNodeCommandMap {
+  ADD: 0;
+  DEL: 1;
+}
+
+export const MeshNodeCommand: MeshNodeCommandMap;
+