import * as jspb from 'google-protobuf'

import * as google_protobuf_wrappers_pb from 'google-protobuf/google/protobuf/wrappers_pb'; // proto import: "google/protobuf/wrappers.proto"


export class Peer extends jspb.Message {
  getPeerId(): string;
  setPeerId(value: string): Peer;

  getOrganizationId(): string;
  setOrganizationId(value: string): Peer;

  getUserId(): google_protobuf_wrappers_pb.StringValue | undefined;
  setUserId(value?: google_protobuf_wrappers_pb.StringValue): Peer;
  hasUserId(): boolean;
  clearUserId(): Peer;

  getDeviceId(): google_protobuf_wrappers_pb.StringValue | undefined;
  setDeviceId(value?: google_protobuf_wrappers_pb.StringValue): Peer;
  hasDeviceId(): boolean;
  clearDeviceId(): Peer;

  getSessionIdsList(): Array<string>;
  setSessionIdsList(value: Array<string>): Peer;
  clearSessionIdsList(): Peer;
  addSessionIds(value: string, index?: number): Peer;

  getPeerCreatedTimestamp(): google_protobuf_wrappers_pb.Int64Value | undefined;
  setPeerCreatedTimestamp(value?: google_protobuf_wrappers_pb.Int64Value): Peer;
  hasPeerCreatedTimestamp(): boolean;
  clearPeerCreatedTimestamp(): Peer;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): Peer.AsObject;
  static toObject(includeInstance: boolean, msg: Peer): Peer.AsObject;
  static serializeBinaryToWriter(message: Peer, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): Peer;
  static deserializeBinaryFromReader(message: Peer, reader: jspb.BinaryReader): Peer;
}

export namespace Peer {
  export type AsObject = {
    peerId: string,
    organizationId: string,
    userId?: google_protobuf_wrappers_pb.StringValue.AsObject,
    deviceId?: google_protobuf_wrappers_pb.StringValue.AsObject,
    sessionIdsList: Array<string>,
    peerCreatedTimestamp?: google_protobuf_wrappers_pb.Int64Value.AsObject,
  }
}

export class Signal extends jspb.Message {
  getSessionId(): google_protobuf_wrappers_pb.StringValue | undefined;
  setSessionId(value?: google_protobuf_wrappers_pb.StringValue): Signal;
  hasSessionId(): boolean;
  clearSessionId(): Signal;

  getSessionCreatedTimestamp(): google_protobuf_wrappers_pb.Int64Value | undefined;
  setSessionCreatedTimestamp(value?: google_protobuf_wrappers_pb.Int64Value): Signal;
  hasSessionCreatedTimestamp(): boolean;
  clearSessionCreatedTimestamp(): Signal;

  getSenderId(): string;
  setSenderId(value: string): Signal;

  getReceiverId(): string;
  setReceiverId(value: string): Signal;

  getPayload(): string;
  setPayload(value: string): Signal;

  getIceServers(): string;
  setIceServers(value: string): Signal;

  getIceTransportPolicy(): string;
  setIceTransportPolicy(value: string): Signal;

  getSessionType(): SessionType;
  setSessionType(value: SessionType): Signal;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): Signal.AsObject;
  static toObject(includeInstance: boolean, msg: Signal): Signal.AsObject;
  static serializeBinaryToWriter(message: Signal, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): Signal;
  static deserializeBinaryFromReader(message: Signal, reader: jspb.BinaryReader): Signal;
}

export namespace Signal {
  export type AsObject = {
    sessionId?: google_protobuf_wrappers_pb.StringValue.AsObject,
    sessionCreatedTimestamp?: google_protobuf_wrappers_pb.Int64Value.AsObject,
    senderId: string,
    receiverId: string,
    payload: string,
    iceServers: string,
    iceTransportPolicy: string,
    sessionType: SessionType,
  }
}

export class RtcSession extends jspb.Message {
  getSessionId(): string;
  setSessionId(value: string): RtcSession;

  getOfferPeerId(): string;
  setOfferPeerId(value: string): RtcSession;

  getAnswerPeerId(): string;
  setAnswerPeerId(value: string): RtcSession;

  getOrganizationId(): string;
  setOrganizationId(value: string): RtcSession;

  getSessionType(): string;
  setSessionType(value: string): RtcSession;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): RtcSession.AsObject;
  static toObject(includeInstance: boolean, msg: RtcSession): RtcSession.AsObject;
  static serializeBinaryToWriter(message: RtcSession, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): RtcSession;
  static deserializeBinaryFromReader(message: RtcSession, reader: jspb.BinaryReader): RtcSession;
}

export namespace RtcSession {
  export type AsObject = {
    sessionId: string,
    offerPeerId: string,
    answerPeerId: string,
    organizationId: string,
    sessionType: string,
  }
}

export class GetSessionsRequest extends jspb.Message {
  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GetSessionsRequest.AsObject;
  static toObject(includeInstance: boolean, msg: GetSessionsRequest): GetSessionsRequest.AsObject;
  static serializeBinaryToWriter(message: GetSessionsRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GetSessionsRequest;
  static deserializeBinaryFromReader(message: GetSessionsRequest, reader: jspb.BinaryReader): GetSessionsRequest;
}

export namespace GetSessionsRequest {
  export type AsObject = {
  }
}

export class GetSessionsResponse extends jspb.Message {
  getSessionsList(): Array<RtcSession>;
  setSessionsList(value: Array<RtcSession>): GetSessionsResponse;
  clearSessionsList(): GetSessionsResponse;
  addSessions(value?: RtcSession, index?: number): RtcSession;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GetSessionsResponse.AsObject;
  static toObject(includeInstance: boolean, msg: GetSessionsResponse): GetSessionsResponse.AsObject;
  static serializeBinaryToWriter(message: GetSessionsResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GetSessionsResponse;
  static deserializeBinaryFromReader(message: GetSessionsResponse, reader: jspb.BinaryReader): GetSessionsResponse;
}

export namespace GetSessionsResponse {
  export type AsObject = {
    sessionsList: Array<RtcSession.AsObject>,
  }
}

export class GetHealthRequest extends jspb.Message {
  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GetHealthRequest.AsObject;
  static toObject(includeInstance: boolean, msg: GetHealthRequest): GetHealthRequest.AsObject;
  static serializeBinaryToWriter(message: GetHealthRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GetHealthRequest;
  static deserializeBinaryFromReader(message: GetHealthRequest, reader: jspb.BinaryReader): GetHealthRequest;
}

export namespace GetHealthRequest {
  export type AsObject = {
  }
}

export class GetHealthResponse extends jspb.Message {
  getVersion(): string;
  setVersion(value: string): GetHealthResponse;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GetHealthResponse.AsObject;
  static toObject(includeInstance: boolean, msg: GetHealthResponse): GetHealthResponse.AsObject;
  static serializeBinaryToWriter(message: GetHealthResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GetHealthResponse;
  static deserializeBinaryFromReader(message: GetHealthResponse, reader: jspb.BinaryReader): GetHealthResponse;
}

export namespace GetHealthResponse {
  export type AsObject = {
    version: string,
  }
}

export class CreatePeerRequest extends jspb.Message {
  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): CreatePeerRequest.AsObject;
  static toObject(includeInstance: boolean, msg: CreatePeerRequest): CreatePeerRequest.AsObject;
  static serializeBinaryToWriter(message: CreatePeerRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): CreatePeerRequest;
  static deserializeBinaryFromReader(message: CreatePeerRequest, reader: jspb.BinaryReader): CreatePeerRequest;
}

export namespace CreatePeerRequest {
  export type AsObject = {
  }
}

export class CreatePeerResponse extends jspb.Message {
  getPeer(): Peer | undefined;
  setPeer(value?: Peer): CreatePeerResponse;
  hasPeer(): boolean;
  clearPeer(): CreatePeerResponse;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): CreatePeerResponse.AsObject;
  static toObject(includeInstance: boolean, msg: CreatePeerResponse): CreatePeerResponse.AsObject;
  static serializeBinaryToWriter(message: CreatePeerResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): CreatePeerResponse;
  static deserializeBinaryFromReader(message: CreatePeerResponse, reader: jspb.BinaryReader): CreatePeerResponse;
}

export namespace CreatePeerResponse {
  export type AsObject = {
    peer?: Peer.AsObject,
  }
}

export class DeletePeerRequest extends jspb.Message {
  getPeerId(): string;
  setPeerId(value: string): DeletePeerRequest;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): DeletePeerRequest.AsObject;
  static toObject(includeInstance: boolean, msg: DeletePeerRequest): DeletePeerRequest.AsObject;
  static serializeBinaryToWriter(message: DeletePeerRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): DeletePeerRequest;
  static deserializeBinaryFromReader(message: DeletePeerRequest, reader: jspb.BinaryReader): DeletePeerRequest;
}

export namespace DeletePeerRequest {
  export type AsObject = {
    peerId: string,
  }
}

export class DeletePeerResponse extends jspb.Message {
  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): DeletePeerResponse.AsObject;
  static toObject(includeInstance: boolean, msg: DeletePeerResponse): DeletePeerResponse.AsObject;
  static serializeBinaryToWriter(message: DeletePeerResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): DeletePeerResponse;
  static deserializeBinaryFromReader(message: DeletePeerResponse, reader: jspb.BinaryReader): DeletePeerResponse;
}

export namespace DeletePeerResponse {
  export type AsObject = {
  }
}

export class RefreshPeerRequest extends jspb.Message {
  getPeer(): Peer | undefined;
  setPeer(value?: Peer): RefreshPeerRequest;
  hasPeer(): boolean;
  clearPeer(): RefreshPeerRequest;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): RefreshPeerRequest.AsObject;
  static toObject(includeInstance: boolean, msg: RefreshPeerRequest): RefreshPeerRequest.AsObject;
  static serializeBinaryToWriter(message: RefreshPeerRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): RefreshPeerRequest;
  static deserializeBinaryFromReader(message: RefreshPeerRequest, reader: jspb.BinaryReader): RefreshPeerRequest;
}

export namespace RefreshPeerRequest {
  export type AsObject = {
    peer?: Peer.AsObject,
  }
}

export class RefreshPeerResponse extends jspb.Message {
  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): RefreshPeerResponse.AsObject;
  static toObject(includeInstance: boolean, msg: RefreshPeerResponse): RefreshPeerResponse.AsObject;
  static serializeBinaryToWriter(message: RefreshPeerResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): RefreshPeerResponse;
  static deserializeBinaryFromReader(message: RefreshPeerResponse, reader: jspb.BinaryReader): RefreshPeerResponse;
}

export namespace RefreshPeerResponse {
  export type AsObject = {
  }
}

export class GetPeersRequest extends jspb.Message {
  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GetPeersRequest.AsObject;
  static toObject(includeInstance: boolean, msg: GetPeersRequest): GetPeersRequest.AsObject;
  static serializeBinaryToWriter(message: GetPeersRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GetPeersRequest;
  static deserializeBinaryFromReader(message: GetPeersRequest, reader: jspb.BinaryReader): GetPeersRequest;
}

export namespace GetPeersRequest {
  export type AsObject = {
  }
}

export class GetPeersResponse extends jspb.Message {
  getPeersList(): Array<Peer>;
  setPeersList(value: Array<Peer>): GetPeersResponse;
  clearPeersList(): GetPeersResponse;
  addPeers(value?: Peer, index?: number): Peer;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GetPeersResponse.AsObject;
  static toObject(includeInstance: boolean, msg: GetPeersResponse): GetPeersResponse.AsObject;
  static serializeBinaryToWriter(message: GetPeersResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GetPeersResponse;
  static deserializeBinaryFromReader(message: GetPeersResponse, reader: jspb.BinaryReader): GetPeersResponse;
}

export namespace GetPeersResponse {
  export type AsObject = {
    peersList: Array<Peer.AsObject>,
  }
}

export class GetIceServersRequest extends jspb.Message {
  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GetIceServersRequest.AsObject;
  static toObject(includeInstance: boolean, msg: GetIceServersRequest): GetIceServersRequest.AsObject;
  static serializeBinaryToWriter(message: GetIceServersRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GetIceServersRequest;
  static deserializeBinaryFromReader(message: GetIceServersRequest, reader: jspb.BinaryReader): GetIceServersRequest;
}

export namespace GetIceServersRequest {
  export type AsObject = {
  }
}

export class GetIceServersResponse extends jspb.Message {
  getIceServers(): string;
  setIceServers(value: string): GetIceServersResponse;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GetIceServersResponse.AsObject;
  static toObject(includeInstance: boolean, msg: GetIceServersResponse): GetIceServersResponse.AsObject;
  static serializeBinaryToWriter(message: GetIceServersResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GetIceServersResponse;
  static deserializeBinaryFromReader(message: GetIceServersResponse, reader: jspb.BinaryReader): GetIceServersResponse;
}

export namespace GetIceServersResponse {
  export type AsObject = {
    iceServers: string,
  }
}

export class SendSignalRequest extends jspb.Message {
  getSignal(): Signal | undefined;
  setSignal(value?: Signal): SendSignalRequest;
  hasSignal(): boolean;
  clearSignal(): SendSignalRequest;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): SendSignalRequest.AsObject;
  static toObject(includeInstance: boolean, msg: SendSignalRequest): SendSignalRequest.AsObject;
  static serializeBinaryToWriter(message: SendSignalRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): SendSignalRequest;
  static deserializeBinaryFromReader(message: SendSignalRequest, reader: jspb.BinaryReader): SendSignalRequest;
}

export namespace SendSignalRequest {
  export type AsObject = {
    signal?: Signal.AsObject,
  }
}

export class SendSignalResponse extends jspb.Message {
  getSessionId(): google_protobuf_wrappers_pb.StringValue | undefined;
  setSessionId(value?: google_protobuf_wrappers_pb.StringValue): SendSignalResponse;
  hasSessionId(): boolean;
  clearSessionId(): SendSignalResponse;

  getSessionCreatedTimestamp(): google_protobuf_wrappers_pb.Int64Value | undefined;
  setSessionCreatedTimestamp(value?: google_protobuf_wrappers_pb.Int64Value): SendSignalResponse;
  hasSessionCreatedTimestamp(): boolean;
  clearSessionCreatedTimestamp(): SendSignalResponse;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): SendSignalResponse.AsObject;
  static toObject(includeInstance: boolean, msg: SendSignalResponse): SendSignalResponse.AsObject;
  static serializeBinaryToWriter(message: SendSignalResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): SendSignalResponse;
  static deserializeBinaryFromReader(message: SendSignalResponse, reader: jspb.BinaryReader): SendSignalResponse;
}

export namespace SendSignalResponse {
  export type AsObject = {
    sessionId?: google_protobuf_wrappers_pb.StringValue.AsObject,
    sessionCreatedTimestamp?: google_protobuf_wrappers_pb.Int64Value.AsObject,
  }
}

export class ReceiveSignalStreamRequest extends jspb.Message {
  getPeerId(): string;
  setPeerId(value: string): ReceiveSignalStreamRequest;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): ReceiveSignalStreamRequest.AsObject;
  static toObject(includeInstance: boolean, msg: ReceiveSignalStreamRequest): ReceiveSignalStreamRequest.AsObject;
  static serializeBinaryToWriter(message: ReceiveSignalStreamRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): ReceiveSignalStreamRequest;
  static deserializeBinaryFromReader(message: ReceiveSignalStreamRequest, reader: jspb.BinaryReader): ReceiveSignalStreamRequest;
}

export namespace ReceiveSignalStreamRequest {
  export type AsObject = {
    peerId: string,
  }
}

export class ReceiveSignalStreamResponse extends jspb.Message {
  getSignal(): Signal | undefined;
  setSignal(value?: Signal): ReceiveSignalStreamResponse;
  hasSignal(): boolean;
  clearSignal(): ReceiveSignalStreamResponse;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): ReceiveSignalStreamResponse.AsObject;
  static toObject(includeInstance: boolean, msg: ReceiveSignalStreamResponse): ReceiveSignalStreamResponse.AsObject;
  static serializeBinaryToWriter(message: ReceiveSignalStreamResponse, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): ReceiveSignalStreamResponse;
  static deserializeBinaryFromReader(message: ReceiveSignalStreamResponse, reader: jspb.BinaryReader): ReceiveSignalStreamResponse;
}

export namespace ReceiveSignalStreamResponse {
  export type AsObject = {
    signal?: Signal.AsObject,
  }
}

export enum SessionType { 
  UNKNOWN = 0,
  TELEOP = 1,
  PORT_FORWARD = 2,
  OBSERVE = 3,
  HEADLESS = 4,
}