import * as jspb from 'google-protobuf'



export class Invitation extends jspb.Message {
  getConversation(): string;
  setConversation(value: string): Invitation;

  getFrom(): string;
  setFrom(value: string): Invitation;

  getTo(): string;
  setTo(value: string): Invitation;

  getInvitationDate(): number;
  setInvitationDate(value: number): Invitation;

  getName(): string;
  setName(value: string): Invitation;

  getMac(): string;
  setMac(value: string): Invitation;

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

export namespace Invitation {
  export type AsObject = {
    conversation: string,
    from: string,
    to: string,
    invitationDate: number,
    name: string,
    mac: string,
  }
}

export class Invitations extends jspb.Message {
  getInvitationsList(): Array<Invitation>;
  setInvitationsList(value: Array<Invitation>): Invitations;
  clearInvitationsList(): Invitations;
  addInvitations(value?: Invitation, index?: number): Invitation;

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

export namespace Invitations {
  export type AsObject = {
    invitationsList: Array<Invitation.AsObject>,
  }
}

export class Message extends jspb.Message {
  getUuid(): string;
  setUuid(value: string): Message;

  getConversation(): string;
  setConversation(value: string): Message;

  getCreationTime(): number;
  setCreationTime(value: number): Message;

  getAuthor(): string;
  setAuthor(value: string): Message;

  getText(): string;
  setText(value: string): Message;

  getInReplyTo(): string;
  setInReplyTo(value: string): Message;

  getLanguage(): string;
  setLanguage(value: string): Message;

  getLikesList(): Array<string>;
  setLikesList(value: Array<string>): Message;
  clearLikesList(): Message;
  addLikes(value: string, index?: number): Message;

  getDislikesList(): Array<string>;
  setDislikesList(value: Array<string>): Message;
  clearDislikesList(): Message;
  addDislikes(value: string, index?: number): Message;

  getReadersList(): Array<string>;
  setReadersList(value: Array<string>): Message;
  clearReadersList(): Message;
  addReaders(value: string, index?: number): Message;

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

export namespace Message {
  export type AsObject = {
    uuid: string,
    conversation: string,
    creationTime: number,
    author: string,
    text: string,
    inReplyTo: string,
    language: string,
    likesList: Array<string>,
    dislikesList: Array<string>,
    readersList: Array<string>,
  }
}

export class Conversation extends jspb.Message {
  getUuid(): string;
  setUuid(value: string): Conversation;

  getName(): string;
  setName(value: string): Conversation;

  getMessagesList(): Array<string>;
  setMessagesList(value: Array<string>): Conversation;
  clearMessagesList(): Conversation;
  addMessages(value: string, index?: number): Conversation;

  getKeywordsList(): Array<string>;
  setKeywordsList(value: Array<string>): Conversation;
  clearKeywordsList(): Conversation;
  addKeywords(value: string, index?: number): Conversation;

  getCreationTime(): number;
  setCreationTime(value: number): Conversation;

  getLastMessageTime(): number;
  setLastMessageTime(value: number): Conversation;

  getLanguage(): string;
  setLanguage(value: string): Conversation;

  getParticipantsList(): Array<string>;
  setParticipantsList(value: Array<string>): Conversation;
  clearParticipantsList(): Conversation;
  addParticipants(value: string, index?: number): Conversation;

  getInvitations(): Invitations | undefined;
  setInvitations(value?: Invitations): Conversation;
  hasInvitations(): boolean;
  clearInvitations(): Conversation;

  getMac(): string;
  setMac(value: string): Conversation;

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

export namespace Conversation {
  export type AsObject = {
    uuid: string,
    name: string,
    messagesList: Array<string>,
    keywordsList: Array<string>,
    creationTime: number,
    lastMessageTime: number,
    language: string,
    participantsList: Array<string>,
    invitations?: Invitations.AsObject,
    mac: string,
  }
}

export class Conversations extends jspb.Message {
  getConversationsList(): Array<Conversation>;
  setConversationsList(value: Array<Conversation>): Conversations;
  clearConversationsList(): Conversations;
  addConversations(value?: Conversation, index?: number): Conversation;

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

export namespace Conversations {
  export type AsObject = {
    conversationsList: Array<Conversation.AsObject>,
  }
}

export class ConnectRequest extends jspb.Message {
  getUuid(): string;
  setUuid(value: string): ConnectRequest;

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

export namespace ConnectRequest {
  export type AsObject = {
    uuid: string,
  }
}

export class ConnectResponse extends jspb.Message {
  getMsg(): Message | undefined;
  setMsg(value?: Message): ConnectResponse;
  hasMsg(): boolean;
  clearMsg(): ConnectResponse;

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

export namespace ConnectResponse {
  export type AsObject = {
    msg?: Message.AsObject,
  }
}

export class DisconnectRequest extends jspb.Message {
  getUuid(): string;
  setUuid(value: string): DisconnectRequest;

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

export namespace DisconnectRequest {
  export type AsObject = {
    uuid: string,
  }
}

export class DisconnectResponse extends jspb.Message {
  getResult(): boolean;
  setResult(value: boolean): DisconnectResponse;

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

export namespace DisconnectResponse {
  export type AsObject = {
    result: boolean,
  }
}

export class CreateConversationRequest extends jspb.Message {
  getName(): string;
  setName(value: string): CreateConversationRequest;

  getKeywordsList(): Array<string>;
  setKeywordsList(value: Array<string>): CreateConversationRequest;
  clearKeywordsList(): CreateConversationRequest;
  addKeywords(value: string, index?: number): CreateConversationRequest;

  getLanguage(): string;
  setLanguage(value: string): CreateConversationRequest;

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

export namespace CreateConversationRequest {
  export type AsObject = {
    name: string,
    keywordsList: Array<string>,
    language: string,
  }
}

export class CreateConversationResponse extends jspb.Message {
  getConversation(): Conversation | undefined;
  setConversation(value?: Conversation): CreateConversationResponse;
  hasConversation(): boolean;
  clearConversation(): CreateConversationResponse;

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

export namespace CreateConversationResponse {
  export type AsObject = {
    conversation?: Conversation.AsObject,
  }
}

export class DeleteConversationRequest extends jspb.Message {
  getConversationUuid(): string;
  setConversationUuid(value: string): DeleteConversationRequest;

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

export namespace DeleteConversationRequest {
  export type AsObject = {
    conversationUuid: string,
  }
}

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

export namespace DeleteConversationResponse {
  export type AsObject = {
  }
}

export class SendInvitationRequest extends jspb.Message {
  getInvitation(): Invitation | undefined;
  setInvitation(value?: Invitation): SendInvitationRequest;
  hasInvitation(): boolean;
  clearInvitation(): SendInvitationRequest;

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

export namespace SendInvitationRequest {
  export type AsObject = {
    invitation?: Invitation.AsObject,
  }
}

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

export namespace SendInvitationResponse {
  export type AsObject = {
  }
}

export class AcceptInvitationRequest extends jspb.Message {
  getInvitation(): Invitation | undefined;
  setInvitation(value?: Invitation): AcceptInvitationRequest;
  hasInvitation(): boolean;
  clearInvitation(): AcceptInvitationRequest;

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

export namespace AcceptInvitationRequest {
  export type AsObject = {
    invitation?: Invitation.AsObject,
  }
}

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

export namespace AcceptInvitationResponse {
  export type AsObject = {
  }
}

export class DeclineInvitationRequest extends jspb.Message {
  getInvitation(): Invitation | undefined;
  setInvitation(value?: Invitation): DeclineInvitationRequest;
  hasInvitation(): boolean;
  clearInvitation(): DeclineInvitationRequest;

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

export namespace DeclineInvitationRequest {
  export type AsObject = {
    invitation?: Invitation.AsObject,
  }
}

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

export namespace DeclineInvitationResponse {
  export type AsObject = {
  }
}

export class RevokeInvitationRequest extends jspb.Message {
  getInvitation(): Invitation | undefined;
  setInvitation(value?: Invitation): RevokeInvitationRequest;
  hasInvitation(): boolean;
  clearInvitation(): RevokeInvitationRequest;

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

export namespace RevokeInvitationRequest {
  export type AsObject = {
    invitation?: Invitation.AsObject,
  }
}

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

export namespace RevokeInvitationResponse {
  export type AsObject = {
  }
}

export class GetReceivedInvitationsRequest extends jspb.Message {
  getAccount(): string;
  setAccount(value: string): GetReceivedInvitationsRequest;

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

export namespace GetReceivedInvitationsRequest {
  export type AsObject = {
    account: string,
  }
}

export class GetReceivedInvitationsResponse extends jspb.Message {
  getInvitations(): Invitations | undefined;
  setInvitations(value?: Invitations): GetReceivedInvitationsResponse;
  hasInvitations(): boolean;
  clearInvitations(): GetReceivedInvitationsResponse;

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

export namespace GetReceivedInvitationsResponse {
  export type AsObject = {
    invitations?: Invitations.AsObject,
  }
}

export class GetSentInvitationsRequest extends jspb.Message {
  getAccount(): string;
  setAccount(value: string): GetSentInvitationsRequest;

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

export namespace GetSentInvitationsRequest {
  export type AsObject = {
    account: string,
  }
}

export class GetSentInvitationsResponse extends jspb.Message {
  getInvitations(): Invitations | undefined;
  setInvitations(value?: Invitations): GetSentInvitationsResponse;
  hasInvitations(): boolean;
  clearInvitations(): GetSentInvitationsResponse;

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

export namespace GetSentInvitationsResponse {
  export type AsObject = {
    invitations?: Invitations.AsObject,
  }
}

export class FindConversationsRequest extends jspb.Message {
  getQuery(): string;
  setQuery(value: string): FindConversationsRequest;

  getLanguage(): string;
  setLanguage(value: string): FindConversationsRequest;

  getOffset(): number;
  setOffset(value: number): FindConversationsRequest;

  getPagesize(): number;
  setPagesize(value: number): FindConversationsRequest;

  getSnippetsize(): number;
  setSnippetsize(value: number): FindConversationsRequest;

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

export namespace FindConversationsRequest {
  export type AsObject = {
    query: string,
    language: string,
    offset: number,
    pagesize: number,
    snippetsize: number,
  }
}

export class FindConversationsResponse extends jspb.Message {
  getConversationsList(): Array<Conversation>;
  setConversationsList(value: Array<Conversation>): FindConversationsResponse;
  clearConversationsList(): FindConversationsResponse;
  addConversations(value?: Conversation, index?: number): Conversation;

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

export namespace FindConversationsResponse {
  export type AsObject = {
    conversationsList: Array<Conversation.AsObject>,
  }
}

export class JoinConversationRequest extends jspb.Message {
  getConversationUuid(): string;
  setConversationUuid(value: string): JoinConversationRequest;

  getConnectionUuid(): string;
  setConnectionUuid(value: string): JoinConversationRequest;

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

export namespace JoinConversationRequest {
  export type AsObject = {
    conversationUuid: string,
    connectionUuid: string,
  }
}

export class JoinConversationResponse extends jspb.Message {
  getMsg(): Message | undefined;
  setMsg(value?: Message): JoinConversationResponse;
  hasMsg(): boolean;
  clearMsg(): JoinConversationResponse;

  getConversation(): Conversation | undefined;
  setConversation(value?: Conversation): JoinConversationResponse;
  hasConversation(): boolean;
  clearConversation(): JoinConversationResponse;

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

export namespace JoinConversationResponse {
  export type AsObject = {
    msg?: Message.AsObject,
    conversation?: Conversation.AsObject,
  }
}

export class KickoutFromConversationRequest extends jspb.Message {
  getConversationUuid(): string;
  setConversationUuid(value: string): KickoutFromConversationRequest;

  getAccount(): string;
  setAccount(value: string): KickoutFromConversationRequest;

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

export namespace KickoutFromConversationRequest {
  export type AsObject = {
    conversationUuid: string,
    account: string,
  }
}

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

export namespace KickoutFromConversationResponse {
  export type AsObject = {
  }
}

export class GetConversationRequest extends jspb.Message {
  getId(): string;
  setId(value: string): GetConversationRequest;

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

export namespace GetConversationRequest {
  export type AsObject = {
    id: string,
  }
}

export class GetConversationResponse extends jspb.Message {
  getConversation(): Conversation | undefined;
  setConversation(value?: Conversation): GetConversationResponse;
  hasConversation(): boolean;
  clearConversation(): GetConversationResponse;

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

export namespace GetConversationResponse {
  export type AsObject = {
    conversation?: Conversation.AsObject,
  }
}

export class GetConversationsRequest extends jspb.Message {
  getCreator(): string;
  setCreator(value: string): GetConversationsRequest;

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

export namespace GetConversationsRequest {
  export type AsObject = {
    creator: string,
  }
}

export class GetConversationsResponse extends jspb.Message {
  getConversations(): Conversations | undefined;
  setConversations(value?: Conversations): GetConversationsResponse;
  hasConversations(): boolean;
  clearConversations(): GetConversationsResponse;

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

export namespace GetConversationsResponse {
  export type AsObject = {
    conversations?: Conversations.AsObject,
  }
}

export class LeaveConversationRequest extends jspb.Message {
  getConversationUuid(): string;
  setConversationUuid(value: string): LeaveConversationRequest;

  getConnectionUuid(): string;
  setConnectionUuid(value: string): LeaveConversationRequest;

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

export namespace LeaveConversationRequest {
  export type AsObject = {
    conversationUuid: string,
    connectionUuid: string,
  }
}

export class LeaveConversationResponse extends jspb.Message {
  getConversation(): Conversation | undefined;
  setConversation(value?: Conversation): LeaveConversationResponse;
  hasConversation(): boolean;
  clearConversation(): LeaveConversationResponse;

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

export namespace LeaveConversationResponse {
  export type AsObject = {
    conversation?: Conversation.AsObject,
  }
}

export class SendMessageRequest extends jspb.Message {
  getMsg(): Message | undefined;
  setMsg(value?: Message): SendMessageRequest;
  hasMsg(): boolean;
  clearMsg(): SendMessageRequest;

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

export namespace SendMessageRequest {
  export type AsObject = {
    msg?: Message.AsObject,
  }
}

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

export namespace SendMessageResponse {
  export type AsObject = {
  }
}

export class DeleteMessageRequest extends jspb.Message {
  getConversation(): string;
  setConversation(value: string): DeleteMessageRequest;

  getUuid(): string;
  setUuid(value: string): DeleteMessageRequest;

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

export namespace DeleteMessageRequest {
  export type AsObject = {
    conversation: string,
    uuid: string,
  }
}

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

export namespace DeleteMessageResponse {
  export type AsObject = {
  }
}

export class FindMessagesRequest extends jspb.Message {
  getKeywordsList(): Array<string>;
  setKeywordsList(value: Array<string>): FindMessagesRequest;
  clearKeywordsList(): FindMessagesRequest;
  addKeywords(value: string, index?: number): FindMessagesRequest;

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

export namespace FindMessagesRequest {
  export type AsObject = {
    keywordsList: Array<string>,
  }
}

export class FindMessagesResponse extends jspb.Message {
  getMessage(): Message | undefined;
  setMessage(value?: Message): FindMessagesResponse;
  hasMessage(): boolean;
  clearMessage(): FindMessagesResponse;

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

export namespace FindMessagesResponse {
  export type AsObject = {
    message?: Message.AsObject,
  }
}

export class LikeMessageRqst extends jspb.Message {
  getConversation(): string;
  setConversation(value: string): LikeMessageRqst;

  getMessage(): string;
  setMessage(value: string): LikeMessageRqst;

  getAccount(): string;
  setAccount(value: string): LikeMessageRqst;

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

export namespace LikeMessageRqst {
  export type AsObject = {
    conversation: string,
    message: string,
    account: string,
  }
}

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

export namespace LikeMessageResponse {
  export type AsObject = {
  }
}

export class DislikeMessageRqst extends jspb.Message {
  getConversation(): string;
  setConversation(value: string): DislikeMessageRqst;

  getMessage(): string;
  setMessage(value: string): DislikeMessageRqst;

  getAccount(): string;
  setAccount(value: string): DislikeMessageRqst;

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

export namespace DislikeMessageRqst {
  export type AsObject = {
    conversation: string,
    message: string,
    account: string,
  }
}

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

export namespace DislikeMessageResponse {
  export type AsObject = {
  }
}

export class SetMessageReadRqst extends jspb.Message {
  getConversation(): string;
  setConversation(value: string): SetMessageReadRqst;

  getMessage(): string;
  setMessage(value: string): SetMessageReadRqst;

  getAccount(): string;
  setAccount(value: string): SetMessageReadRqst;

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

export namespace SetMessageReadRqst {
  export type AsObject = {
    conversation: string,
    message: string,
    account: string,
  }
}

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

export namespace SetMessageReadResponse {
  export type AsObject = {
  }
}

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

export namespace StopRequest {
  export type AsObject = {
  }
}

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

export namespace StopResponse {
  export type AsObject = {
  }
}

export enum ConversationState { 
  ACTIVE = 0,
  SUSPENDED = 1,
}