import * as jspb from 'google-protobuf'



export class PackageBundle extends jspb.Message {
  getPackagedescriptor(): PackageDescriptor | undefined;
  setPackagedescriptor(value?: PackageDescriptor): PackageBundle;
  hasPackagedescriptor(): boolean;
  clearPackagedescriptor(): PackageBundle;

  getChecksum(): string;
  setChecksum(value: string): PackageBundle;

  getPlaform(): string;
  setPlaform(value: string): PackageBundle;

  getSize(): number;
  setSize(value: number): PackageBundle;

  getModified(): number;
  setModified(value: number): PackageBundle;

  getBinairies(): Uint8Array | string;
  getBinairies_asU8(): Uint8Array;
  getBinairies_asB64(): string;
  setBinairies(value: Uint8Array | string): PackageBundle;

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

  getTypename(): string;
  setTypename(value: string): PackageBundle;

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

export namespace PackageBundle {
  export type AsObject = {
    packagedescriptor?: PackageDescriptor.AsObject,
    checksum: string,
    plaform: string,
    size: number,
    modified: number,
    binairies: Uint8Array | string,
    mac: string,
    typename: string,
  }
}

export class SetPackageBundleRequest extends jspb.Message {
  getBundle(): PackageBundle | undefined;
  setBundle(value?: PackageBundle): SetPackageBundleRequest;
  hasBundle(): boolean;
  clearBundle(): SetPackageBundleRequest;

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

export namespace SetPackageBundleRequest {
  export type AsObject = {
    bundle?: PackageBundle.AsObject,
  }
}

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

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

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

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

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

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

export class GetPackageBundleChecksumResponse extends jspb.Message {
  getChecksum(): string;
  setChecksum(value: string): GetPackageBundleChecksumResponse;

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

export namespace GetPackageBundleChecksumResponse {
  export type AsObject = {
    checksum: string,
  }
}

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

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

  getType(): PackageType;
  setType(value: PackageType): PackageDescriptor;

  getPublisherid(): string;
  setPublisherid(value: string): PackageDescriptor;

  getVersion(): string;
  setVersion(value: string): PackageDescriptor;

  getDescription(): string;
  setDescription(value: string): PackageDescriptor;

  getRepositoriesList(): Array<string>;
  setRepositoriesList(value: Array<string>): PackageDescriptor;
  clearRepositoriesList(): PackageDescriptor;
  addRepositories(value: string, index?: number): PackageDescriptor;

  getDiscoveriesList(): Array<string>;
  setDiscoveriesList(value: Array<string>): PackageDescriptor;
  clearDiscoveriesList(): PackageDescriptor;
  addDiscoveries(value: string, index?: number): PackageDescriptor;

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

  getActionsList(): Array<string>;
  setActionsList(value: Array<string>): PackageDescriptor;
  clearActionsList(): PackageDescriptor;
  addActions(value: string, index?: number): PackageDescriptor;

  getRolesList(): Array<Role>;
  setRolesList(value: Array<Role>): PackageDescriptor;
  clearRolesList(): PackageDescriptor;
  addRoles(value?: Role, index?: number): Role;

  getGroupsList(): Array<Group>;
  setGroupsList(value: Array<Group>): PackageDescriptor;
  clearGroupsList(): PackageDescriptor;
  addGroups(value?: Group, index?: number): Group;

  getIcon(): string;
  setIcon(value: string): PackageDescriptor;

  getAlias(): string;
  setAlias(value: string): PackageDescriptor;

  getTypename(): string;
  setTypename(value: string): PackageDescriptor;

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

export namespace PackageDescriptor {
  export type AsObject = {
    id: string,
    name: string,
    type: PackageType,
    publisherid: string,
    version: string,
    description: string,
    repositoriesList: Array<string>,
    discoveriesList: Array<string>,
    keywordsList: Array<string>,
    actionsList: Array<string>,
    rolesList: Array<Role.AsObject>,
    groupsList: Array<Group.AsObject>,
    icon: string,
    alias: string,
    typename: string,
  }
}

export class GetPackageDescriptorRequest extends jspb.Message {
  getServiceid(): string;
  setServiceid(value: string): GetPackageDescriptorRequest;

  getPublisherid(): string;
  setPublisherid(value: string): GetPackageDescriptorRequest;

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

export namespace GetPackageDescriptorRequest {
  export type AsObject = {
    serviceid: string,
    publisherid: string,
  }
}

export class GetPackageDescriptorResponse extends jspb.Message {
  getResultsList(): Array<PackageDescriptor>;
  setResultsList(value: Array<PackageDescriptor>): GetPackageDescriptorResponse;
  clearResultsList(): GetPackageDescriptorResponse;
  addResults(value?: PackageDescriptor, index?: number): PackageDescriptor;

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

export namespace GetPackageDescriptorResponse {
  export type AsObject = {
    resultsList: Array<PackageDescriptor.AsObject>,
  }
}

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

  getOptions(): string;
  setOptions(value: string): GetPackagesDescriptorRequest;

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

export namespace GetPackagesDescriptorRequest {
  export type AsObject = {
    query: string,
    options: string,
  }
}

export class GetPackagesDescriptorResponse extends jspb.Message {
  getResultsList(): Array<PackageDescriptor>;
  setResultsList(value: Array<PackageDescriptor>): GetPackagesDescriptorResponse;
  clearResultsList(): GetPackagesDescriptorResponse;
  addResults(value?: PackageDescriptor, index?: number): PackageDescriptor;

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

export namespace GetPackagesDescriptorResponse {
  export type AsObject = {
    resultsList: Array<PackageDescriptor.AsObject>,
  }
}

export class SetPackageDescriptorRequest extends jspb.Message {
  getPackagedescriptor(): PackageDescriptor | undefined;
  setPackagedescriptor(value?: PackageDescriptor): SetPackageDescriptorRequest;
  hasPackagedescriptor(): boolean;
  clearPackagedescriptor(): SetPackageDescriptorRequest;

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

export namespace SetPackageDescriptorRequest {
  export type AsObject = {
    packagedescriptor?: PackageDescriptor.AsObject,
  }
}

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

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

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

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

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

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

export class FindPackagesDescriptorResponse extends jspb.Message {
  getResultsList(): Array<PackageDescriptor>;
  setResultsList(value: Array<PackageDescriptor>): FindPackagesDescriptorResponse;
  clearResultsList(): FindPackagesDescriptorResponse;
  addResults(value?: PackageDescriptor, index?: number): PackageDescriptor;

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

export namespace FindPackagesDescriptorResponse {
  export type AsObject = {
    resultsList: Array<PackageDescriptor.AsObject>,
  }
}

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

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

  getDomain(): string;
  setDomain(value: string): Role;

  getDescription(): string;
  setDescription(value: string): Role;

  getActionsList(): Array<string>;
  setActionsList(value: Array<string>): Role;
  clearActionsList(): Role;
  addActions(value: string, index?: number): Role;

  getMembersList(): Array<string>;
  setMembersList(value: Array<string>): Role;
  clearMembersList(): Role;
  addMembers(value: string, index?: number): Role;

  getOrganizationsList(): Array<string>;
  setOrganizationsList(value: Array<string>): Role;
  clearOrganizationsList(): Role;
  addOrganizations(value: string, index?: number): Role;

  getTypename(): string;
  setTypename(value: string): Role;

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

export namespace Role {
  export type AsObject = {
    id: string,
    name: string,
    domain: string,
    description: string,
    actionsList: Array<string>,
    membersList: Array<string>,
    organizationsList: Array<string>,
    typename: string,
  }
}

export class AddRoleActionsRqst extends jspb.Message {
  getRoleid(): string;
  setRoleid(value: string): AddRoleActionsRqst;

  getActionsList(): Array<string>;
  setActionsList(value: Array<string>): AddRoleActionsRqst;
  clearActionsList(): AddRoleActionsRqst;
  addActions(value: string, index?: number): AddRoleActionsRqst;

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

export namespace AddRoleActionsRqst {
  export type AsObject = {
    roleid: string,
    actionsList: Array<string>,
  }
}

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

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

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

export class RemoveRoleActionRqst extends jspb.Message {
  getRoleid(): string;
  setRoleid(value: string): RemoveRoleActionRqst;

  getAction(): string;
  setAction(value: string): RemoveRoleActionRqst;

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

export namespace RemoveRoleActionRqst {
  export type AsObject = {
    roleid: string,
    action: string,
  }
}

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

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

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

export class RemoveRolesActionRqst extends jspb.Message {
  getAction(): string;
  setAction(value: string): RemoveRolesActionRqst;

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

export namespace RemoveRolesActionRqst {
  export type AsObject = {
    action: string,
  }
}

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

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

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

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

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

  getEmail(): string;
  setEmail(value: string): Account;

  getPassword(): string;
  setPassword(value: string): Account;

  getDomain(): string;
  setDomain(value: string): Account;

  getProfilepicture(): string;
  setProfilepicture(value: string): Account;

  getFirstname(): string;
  setFirstname(value: string): Account;

  getLastname(): string;
  setLastname(value: string): Account;

  getMiddle(): string;
  setMiddle(value: string): Account;

  getOrganizationsList(): Array<string>;
  setOrganizationsList(value: Array<string>): Account;
  clearOrganizationsList(): Account;
  addOrganizations(value: string, index?: number): Account;

  getGroupsList(): Array<string>;
  setGroupsList(value: Array<string>): Account;
  clearGroupsList(): Account;
  addGroups(value: string, index?: number): Account;

  getRolesList(): Array<string>;
  setRolesList(value: Array<string>): Account;
  clearRolesList(): Account;
  addRoles(value: string, index?: number): Account;

  getTypename(): string;
  setTypename(value: string): Account;

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

export namespace Account {
  export type AsObject = {
    id: string,
    name: string,
    email: string,
    password: string,
    domain: string,
    profilepicture: string,
    firstname: string,
    lastname: string,
    middle: string,
    organizationsList: Array<string>,
    groupsList: Array<string>,
    rolesList: Array<string>,
    typename: string,
  }
}

export class RegisterAccountRqst extends jspb.Message {
  getAccount(): Account | undefined;
  setAccount(value?: Account): RegisterAccountRqst;
  hasAccount(): boolean;
  clearAccount(): RegisterAccountRqst;

  getConfirmPassword(): string;
  setConfirmPassword(value: string): RegisterAccountRqst;

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

export namespace RegisterAccountRqst {
  export type AsObject = {
    account?: Account.AsObject,
    confirmPassword: string,
  }
}

export class RegisterAccountRsp extends jspb.Message {
  getResult(): string;
  setResult(value: string): RegisterAccountRsp;

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

export namespace RegisterAccountRsp {
  export type AsObject = {
    result: string,
  }
}

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

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

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

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

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

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

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

  getOptions(): string;
  setOptions(value: string): GetAccountsRqst;

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

export namespace GetAccountsRqst {
  export type AsObject = {
    query: string,
    options: string,
  }
}

export class GetAccountsRsp extends jspb.Message {
  getAccountsList(): Array<Account>;
  setAccountsList(value: Array<Account>): GetAccountsRsp;
  clearAccountsList(): GetAccountsRsp;
  addAccounts(value?: Account, index?: number): Account;

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

export namespace GetAccountsRsp {
  export type AsObject = {
    accountsList: Array<Account.AsObject>,
  }
}

export class GetAccountRqst extends jspb.Message {
  getAccountid(): string;
  setAccountid(value: string): GetAccountRqst;

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

export namespace GetAccountRqst {
  export type AsObject = {
    accountid: string,
  }
}

export class GetAccountRsp extends jspb.Message {
  getAccount(): Account | undefined;
  setAccount(value?: Account): GetAccountRsp;
  hasAccount(): boolean;
  clearAccount(): GetAccountRsp;

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

export namespace GetAccountRsp {
  export type AsObject = {
    account?: Account.AsObject,
  }
}

export class SetAccountRqst extends jspb.Message {
  getAccount(): Account | undefined;
  setAccount(value?: Account): SetAccountRqst;
  hasAccount(): boolean;
  clearAccount(): SetAccountRqst;

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

export namespace SetAccountRqst {
  export type AsObject = {
    account?: Account.AsObject,
  }
}

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

export namespace SetAccountRsp {
  export type AsObject = {
  }
}

export class SetAccountPasswordRqst extends jspb.Message {
  getAccountid(): string;
  setAccountid(value: string): SetAccountPasswordRqst;

  getOldPassword(): string;
  setOldPassword(value: string): SetAccountPasswordRqst;

  getNewPassword(): string;
  setNewPassword(value: string): SetAccountPasswordRqst;

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

export namespace SetAccountPasswordRqst {
  export type AsObject = {
    accountid: string,
    oldPassword: string,
    newPassword: string,
  }
}

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

export namespace SetAccountPasswordRsp {
  export type AsObject = {
  }
}

export class SetEmailRequest extends jspb.Message {
  getAccountid(): string;
  setAccountid(value: string): SetEmailRequest;

  getOldemail(): string;
  setOldemail(value: string): SetEmailRequest;

  getNewemail(): string;
  setNewemail(value: string): SetEmailRequest;

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

export namespace SetEmailRequest {
  export type AsObject = {
    accountid: string,
    oldemail: string,
    newemail: string,
  }
}

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

export namespace SetEmailResponse {
  export type AsObject = {
  }
}

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

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

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

export class DeleteAccountRsp extends jspb.Message {
  getResult(): string;
  setResult(value: string): DeleteAccountRsp;

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

export namespace DeleteAccountRsp {
  export type AsObject = {
    result: string,
  }
}

export class AddAccountRoleRqst extends jspb.Message {
  getAccountid(): string;
  setAccountid(value: string): AddAccountRoleRqst;

  getRoleid(): string;
  setRoleid(value: string): AddAccountRoleRqst;

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

export namespace AddAccountRoleRqst {
  export type AsObject = {
    accountid: string,
    roleid: string,
  }
}

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

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

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

export class RemoveAccountRoleRqst extends jspb.Message {
  getAccountid(): string;
  setAccountid(value: string): RemoveAccountRoleRqst;

  getRoleid(): string;
  setRoleid(value: string): RemoveAccountRoleRqst;

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

export namespace RemoveAccountRoleRqst {
  export type AsObject = {
    accountid: string,
    roleid: string,
  }
}

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

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

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

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

  getInvitationtime(): number;
  setInvitationtime(value: number): Contact;

  getStatus(): string;
  setStatus(value: string): Contact;

  getRingtone(): string;
  setRingtone(value: string): Contact;

  getProfilepicture(): string;
  setProfilepicture(value: string): Contact;

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

export namespace Contact {
  export type AsObject = {
    id: string,
    invitationtime: number,
    status: string,
    ringtone: string,
    profilepicture: string,
  }
}

export class SetAccountContactRqst extends jspb.Message {
  getAccountid(): string;
  setAccountid(value: string): SetAccountContactRqst;

  getContact(): Contact | undefined;
  setContact(value?: Contact): SetAccountContactRqst;
  hasContact(): boolean;
  clearContact(): SetAccountContactRqst;

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

export namespace SetAccountContactRqst {
  export type AsObject = {
    accountid: string,
    contact?: Contact.AsObject,
  }
}

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

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

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

export class CreateRoleRqst extends jspb.Message {
  getRole(): Role | undefined;
  setRole(value?: Role): CreateRoleRqst;
  hasRole(): boolean;
  clearRole(): CreateRoleRqst;

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

export namespace CreateRoleRqst {
  export type AsObject = {
    role?: Role.AsObject,
  }
}

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

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

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

export class UpdateRoleRqst extends jspb.Message {
  getRoleid(): string;
  setRoleid(value: string): UpdateRoleRqst;

  getValues(): string;
  setValues(value: string): UpdateRoleRqst;

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

export namespace UpdateRoleRqst {
  export type AsObject = {
    roleid: string,
    values: string,
  }
}

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

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

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

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

  getOptions(): string;
  setOptions(value: string): GetRolesRqst;

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

export namespace GetRolesRqst {
  export type AsObject = {
    query: string,
    options: string,
  }
}

export class GetRolesRsp extends jspb.Message {
  getRolesList(): Array<Role>;
  setRolesList(value: Array<Role>): GetRolesRsp;
  clearRolesList(): GetRolesRsp;
  addRoles(value?: Role, index?: number): Role;

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

export namespace GetRolesRsp {
  export type AsObject = {
    rolesList: Array<Role.AsObject>,
  }
}

export class DeleteRoleRqst extends jspb.Message {
  getRoleid(): string;
  setRoleid(value: string): DeleteRoleRqst;

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

export namespace DeleteRoleRqst {
  export type AsObject = {
    roleid: string,
  }
}

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

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

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

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

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

  getDomain(): string;
  setDomain(value: string): Application;

  getPassword(): string;
  setPassword(value: string): Application;

  getPath(): string;
  setPath(value: string): Application;

  getVersion(): string;
  setVersion(value: string): Application;

  getDescription(): string;
  setDescription(value: string): Application;

  getActionsList(): Array<string>;
  setActionsList(value: Array<string>): Application;
  clearActionsList(): Application;
  addActions(value: string, index?: number): Application;

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

  getIcon(): string;
  setIcon(value: string): Application;

  getAlias(): string;
  setAlias(value: string): Application;

  getPublisherid(): string;
  setPublisherid(value: string): Application;

  getCreationDate(): number;
  setCreationDate(value: number): Application;

  getLastDeployed(): number;
  setLastDeployed(value: number): Application;

  getTypename(): string;
  setTypename(value: string): Application;

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

export namespace Application {
  export type AsObject = {
    id: string,
    name: string,
    domain: string,
    password: string,
    path: string,
    version: string,
    description: string,
    actionsList: Array<string>,
    keywordsList: Array<string>,
    icon: string,
    alias: string,
    publisherid: string,
    creationDate: number,
    lastDeployed: number,
    typename: string,
  }
}

export class CreateApplicationRqst extends jspb.Message {
  getApplication(): Application | undefined;
  setApplication(value?: Application): CreateApplicationRqst;
  hasApplication(): boolean;
  clearApplication(): CreateApplicationRqst;

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

export namespace CreateApplicationRqst {
  export type AsObject = {
    application?: Application.AsObject,
  }
}

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

export namespace CreateApplicationRsp {
  export type AsObject = {
  }
}

export class UpdateApplicationRqst extends jspb.Message {
  getApplicationid(): string;
  setApplicationid(value: string): UpdateApplicationRqst;

  getValues(): string;
  setValues(value: string): UpdateApplicationRqst;

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

export namespace UpdateApplicationRqst {
  export type AsObject = {
    applicationid: string,
    values: string,
  }
}

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

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

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

export class DeleteApplicationRqst extends jspb.Message {
  getApplicationid(): string;
  setApplicationid(value: string): DeleteApplicationRqst;

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

export namespace DeleteApplicationRqst {
  export type AsObject = {
    applicationid: string,
  }
}

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

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

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

export class AddApplicationActionsRqst extends jspb.Message {
  getApplicationid(): string;
  setApplicationid(value: string): AddApplicationActionsRqst;

  getActionsList(): Array<string>;
  setActionsList(value: Array<string>): AddApplicationActionsRqst;
  clearActionsList(): AddApplicationActionsRqst;
  addActions(value: string, index?: number): AddApplicationActionsRqst;

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

export namespace AddApplicationActionsRqst {
  export type AsObject = {
    applicationid: string,
    actionsList: Array<string>,
  }
}

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

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

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

export class RemoveApplicationActionRqst extends jspb.Message {
  getApplicationid(): string;
  setApplicationid(value: string): RemoveApplicationActionRqst;

  getAction(): string;
  setAction(value: string): RemoveApplicationActionRqst;

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

export namespace RemoveApplicationActionRqst {
  export type AsObject = {
    applicationid: string,
    action: string,
  }
}

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

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

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

export class RemoveApplicationsActionRqst extends jspb.Message {
  getAction(): string;
  setAction(value: string): RemoveApplicationsActionRqst;

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

export namespace RemoveApplicationsActionRqst {
  export type AsObject = {
    action: string,
  }
}

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

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

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

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

  getOptions(): string;
  setOptions(value: string): GetApplicationsRqst;

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

export namespace GetApplicationsRqst {
  export type AsObject = {
    query: string,
    options: string,
  }
}

export class GetApplicationsRsp extends jspb.Message {
  getApplicationsList(): Array<Application>;
  setApplicationsList(value: Array<Application>): GetApplicationsRsp;
  clearApplicationsList(): GetApplicationsRsp;
  addApplications(value?: Application, index?: number): Application;

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

export namespace GetApplicationsRsp {
  export type AsObject = {
    applicationsList: Array<Application.AsObject>,
  }
}

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

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

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

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

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

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

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

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

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

export class GetApplicationIconRsp extends jspb.Message {
  getIcon(): string;
  setIcon(value: string): GetApplicationIconRsp;

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

export namespace GetApplicationIconRsp {
  export type AsObject = {
    icon: string,
  }
}

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

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

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

export class GetApplicationAliasRsp extends jspb.Message {
  getAlias(): string;
  setAlias(value: string): GetApplicationAliasRsp;

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

export namespace GetApplicationAliasRsp {
  export type AsObject = {
    alias: string,
  }
}

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

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

  getDomain(): string;
  setDomain(value: string): Group;

  getDescription(): string;
  setDescription(value: string): Group;

  getMembersList(): Array<string>;
  setMembersList(value: Array<string>): Group;
  clearMembersList(): Group;
  addMembers(value: string, index?: number): Group;

  getOrganizationsList(): Array<string>;
  setOrganizationsList(value: Array<string>): Group;
  clearOrganizationsList(): Group;
  addOrganizations(value: string, index?: number): Group;

  getTypename(): string;
  setTypename(value: string): Group;

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

export namespace Group {
  export type AsObject = {
    id: string,
    name: string,
    domain: string,
    description: string,
    membersList: Array<string>,
    organizationsList: Array<string>,
    typename: string,
  }
}

export class CreateGroupRqst extends jspb.Message {
  getGroup(): Group | undefined;
  setGroup(value?: Group): CreateGroupRqst;
  hasGroup(): boolean;
  clearGroup(): CreateGroupRqst;

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

export namespace CreateGroupRqst {
  export type AsObject = {
    group?: Group.AsObject,
  }
}

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

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

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

export class UpdateGroupRqst extends jspb.Message {
  getGroupid(): string;
  setGroupid(value: string): UpdateGroupRqst;

  getValues(): string;
  setValues(value: string): UpdateGroupRqst;

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

export namespace UpdateGroupRqst {
  export type AsObject = {
    groupid: string,
    values: string,
  }
}

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

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

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

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

  getOptions(): string;
  setOptions(value: string): GetGroupsRqst;

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

export namespace GetGroupsRqst {
  export type AsObject = {
    query: string,
    options: string,
  }
}

export class GetGroupsRsp extends jspb.Message {
  getGroupsList(): Array<Group>;
  setGroupsList(value: Array<Group>): GetGroupsRsp;
  clearGroupsList(): GetGroupsRsp;
  addGroups(value?: Group, index?: number): Group;

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

export namespace GetGroupsRsp {
  export type AsObject = {
    groupsList: Array<Group.AsObject>,
  }
}

export class DeleteGroupRqst extends jspb.Message {
  getGroup(): string;
  setGroup(value: string): DeleteGroupRqst;

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

export namespace DeleteGroupRqst {
  export type AsObject = {
    group: string,
  }
}

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

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

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

export class AddGroupMemberAccountRqst extends jspb.Message {
  getGroupid(): string;
  setGroupid(value: string): AddGroupMemberAccountRqst;

  getAccountid(): string;
  setAccountid(value: string): AddGroupMemberAccountRqst;

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

export namespace AddGroupMemberAccountRqst {
  export type AsObject = {
    groupid: string,
    accountid: string,
  }
}

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

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

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

export class RemoveGroupMemberAccountRqst extends jspb.Message {
  getGroupid(): string;
  setGroupid(value: string): RemoveGroupMemberAccountRqst;

  getAccountid(): string;
  setAccountid(value: string): RemoveGroupMemberAccountRqst;

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

export namespace RemoveGroupMemberAccountRqst {
  export type AsObject = {
    groupid: string,
    accountid: string,
  }
}

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

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

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

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

  getDomain(): string;
  setDomain(value: string): Organization;

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

  getEmail(): string;
  setEmail(value: string): Organization;

  getIcon(): string;
  setIcon(value: string): Organization;

  getDescription(): string;
  setDescription(value: string): Organization;

  getAccountsList(): Array<string>;
  setAccountsList(value: Array<string>): Organization;
  clearAccountsList(): Organization;
  addAccounts(value: string, index?: number): Organization;

  getGroupsList(): Array<string>;
  setGroupsList(value: Array<string>): Organization;
  clearGroupsList(): Organization;
  addGroups(value: string, index?: number): Organization;

  getRolesList(): Array<string>;
  setRolesList(value: Array<string>): Organization;
  clearRolesList(): Organization;
  addRoles(value: string, index?: number): Organization;

  getApplicationsList(): Array<string>;
  setApplicationsList(value: Array<string>): Organization;
  clearApplicationsList(): Organization;
  addApplications(value: string, index?: number): Organization;

  getTypename(): string;
  setTypename(value: string): Organization;

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

export namespace Organization {
  export type AsObject = {
    id: string,
    domain: string,
    name: string,
    email: string,
    icon: string,
    description: string,
    accountsList: Array<string>,
    groupsList: Array<string>,
    rolesList: Array<string>,
    applicationsList: Array<string>,
    typename: string,
  }
}

export class CreateOrganizationRqst extends jspb.Message {
  getOrganization(): Organization | undefined;
  setOrganization(value?: Organization): CreateOrganizationRqst;
  hasOrganization(): boolean;
  clearOrganization(): CreateOrganizationRqst;

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

export namespace CreateOrganizationRqst {
  export type AsObject = {
    organization?: Organization.AsObject,
  }
}

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

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

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

export class UpdateOrganizationRqst extends jspb.Message {
  getOrganizationid(): string;
  setOrganizationid(value: string): UpdateOrganizationRqst;

  getValues(): string;
  setValues(value: string): UpdateOrganizationRqst;

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

export namespace UpdateOrganizationRqst {
  export type AsObject = {
    organizationid: string,
    values: string,
  }
}

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

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

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

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

  getOptions(): string;
  setOptions(value: string): GetOrganizationsRqst;

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

export namespace GetOrganizationsRqst {
  export type AsObject = {
    query: string,
    options: string,
  }
}

export class GetOrganizationsRsp extends jspb.Message {
  getOrganizationsList(): Array<Organization>;
  setOrganizationsList(value: Array<Organization>): GetOrganizationsRsp;
  clearOrganizationsList(): GetOrganizationsRsp;
  addOrganizations(value?: Organization, index?: number): Organization;

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

export namespace GetOrganizationsRsp {
  export type AsObject = {
    organizationsList: Array<Organization.AsObject>,
  }
}

export class AddOrganizationAccountRqst extends jspb.Message {
  getOrganizationid(): string;
  setOrganizationid(value: string): AddOrganizationAccountRqst;

  getAccountid(): string;
  setAccountid(value: string): AddOrganizationAccountRqst;

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

export namespace AddOrganizationAccountRqst {
  export type AsObject = {
    organizationid: string,
    accountid: string,
  }
}

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

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

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

export class AddOrganizationGroupRqst extends jspb.Message {
  getOrganizationid(): string;
  setOrganizationid(value: string): AddOrganizationGroupRqst;

  getGroupid(): string;
  setGroupid(value: string): AddOrganizationGroupRqst;

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

export namespace AddOrganizationGroupRqst {
  export type AsObject = {
    organizationid: string,
    groupid: string,
  }
}

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

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

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

export class AddOrganizationRoleRqst extends jspb.Message {
  getOrganizationid(): string;
  setOrganizationid(value: string): AddOrganizationRoleRqst;

  getRoleid(): string;
  setRoleid(value: string): AddOrganizationRoleRqst;

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

export namespace AddOrganizationRoleRqst {
  export type AsObject = {
    organizationid: string,
    roleid: string,
  }
}

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

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

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

export class AddOrganizationApplicationRqst extends jspb.Message {
  getOrganizationid(): string;
  setOrganizationid(value: string): AddOrganizationApplicationRqst;

  getApplicationid(): string;
  setApplicationid(value: string): AddOrganizationApplicationRqst;

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

export namespace AddOrganizationApplicationRqst {
  export type AsObject = {
    organizationid: string,
    applicationid: string,
  }
}

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

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

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

export class RemoveOrganizationGroupRqst extends jspb.Message {
  getOrganizationid(): string;
  setOrganizationid(value: string): RemoveOrganizationGroupRqst;

  getGroupid(): string;
  setGroupid(value: string): RemoveOrganizationGroupRqst;

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

export namespace RemoveOrganizationGroupRqst {
  export type AsObject = {
    organizationid: string,
    groupid: string,
  }
}

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

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

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

export class RemoveOrganizationRoleRqst extends jspb.Message {
  getOrganizationid(): string;
  setOrganizationid(value: string): RemoveOrganizationRoleRqst;

  getRoleid(): string;
  setRoleid(value: string): RemoveOrganizationRoleRqst;

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

export namespace RemoveOrganizationRoleRqst {
  export type AsObject = {
    organizationid: string,
    roleid: string,
  }
}

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

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

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

export class RemoveOrganizationApplicationRqst extends jspb.Message {
  getOrganizationid(): string;
  setOrganizationid(value: string): RemoveOrganizationApplicationRqst;

  getApplicationid(): string;
  setApplicationid(value: string): RemoveOrganizationApplicationRqst;

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

export namespace RemoveOrganizationApplicationRqst {
  export type AsObject = {
    organizationid: string,
    applicationid: string,
  }
}

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

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

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

export class RemoveOrganizationAccountRqst extends jspb.Message {
  getOrganizationid(): string;
  setOrganizationid(value: string): RemoveOrganizationAccountRqst;

  getAccountid(): string;
  setAccountid(value: string): RemoveOrganizationAccountRqst;

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

export namespace RemoveOrganizationAccountRqst {
  export type AsObject = {
    organizationid: string,
    accountid: string,
  }
}

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

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

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

export class IsOrgnanizationMemberRqst extends jspb.Message {
  getOrganizationid(): string;
  setOrganizationid(value: string): IsOrgnanizationMemberRqst;

  getAccountid(): string;
  setAccountid(value: string): IsOrgnanizationMemberRqst;

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

export namespace IsOrgnanizationMemberRqst {
  export type AsObject = {
    organizationid: string,
    accountid: string,
  }
}

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

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

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

export class DeleteOrganizationRqst extends jspb.Message {
  getOrganization(): string;
  setOrganization(value: string): DeleteOrganizationRqst;

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

export namespace DeleteOrganizationRqst {
  export type AsObject = {
    organization: string,
  }
}

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

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

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

export class Peer extends jspb.Message {
  getHostname(): string;
  setHostname(value: string): Peer;

  getDomain(): string;
  setDomain(value: string): Peer;

  getExternalIpAddress(): string;
  setExternalIpAddress(value: string): Peer;

  getLocalIpAddress(): string;
  setLocalIpAddress(value: string): Peer;

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

  getPorthttp(): number;
  setPorthttp(value: number): Peer;

  getPorthttps(): number;
  setPorthttps(value: number): Peer;

  getProtocol(): string;
  setProtocol(value: string): Peer;

  getState(): PeerApprovalState;
  setState(value: PeerApprovalState): Peer;

  getActionsList(): Array<string>;
  setActionsList(value: Array<string>): Peer;
  clearActionsList(): Peer;
  addActions(value: string, index?: number): Peer;

  getTypename(): string;
  setTypename(value: string): 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 = {
    hostname: string,
    domain: string,
    externalIpAddress: string,
    localIpAddress: string,
    mac: string,
    porthttp: number,
    porthttps: number,
    protocol: string,
    state: PeerApprovalState,
    actionsList: Array<string>,
    typename: string,
  }
}

export class GetPeerApprovalStateRqst extends jspb.Message {
  getMac(): string;
  setMac(value: string): GetPeerApprovalStateRqst;

  getRemotePeerAddress(): string;
  setRemotePeerAddress(value: string): GetPeerApprovalStateRqst;

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

export namespace GetPeerApprovalStateRqst {
  export type AsObject = {
    mac: string,
    remotePeerAddress: string,
  }
}

export class GetPeerApprovalStateRsp extends jspb.Message {
  getState(): PeerApprovalState;
  setState(value: PeerApprovalState): GetPeerApprovalStateRsp;

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

export namespace GetPeerApprovalStateRsp {
  export type AsObject = {
    state: PeerApprovalState,
  }
}

export class GetPeerPublicKeyRqst extends jspb.Message {
  getMac(): string;
  setMac(value: string): GetPeerPublicKeyRqst;

  getRemotePeerAddress(): string;
  setRemotePeerAddress(value: string): GetPeerPublicKeyRqst;

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

export namespace GetPeerPublicKeyRqst {
  export type AsObject = {
    mac: string,
    remotePeerAddress: string,
  }
}

export class GetPeerPublicKeyRsp extends jspb.Message {
  getPublicKey(): string;
  setPublicKey(value: string): GetPeerPublicKeyRsp;

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

export namespace GetPeerPublicKeyRsp {
  export type AsObject = {
    publicKey: string,
  }
}

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

  getPublicKey(): string;
  setPublicKey(value: string): RegisterPeerRqst;

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

export namespace RegisterPeerRqst {
  export type AsObject = {
    peer?: Peer.AsObject,
    publicKey: string,
  }
}

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

  getPublicKey(): string;
  setPublicKey(value: string): RegisterPeerRsp;

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

export namespace RegisterPeerRsp {
  export type AsObject = {
    peer?: Peer.AsObject,
    publicKey: string,
  }
}

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

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

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

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

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

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

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

  getOptions(): string;
  setOptions(value: string): GetPeersRqst;

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

export namespace GetPeersRqst {
  export type AsObject = {
    query: string,
    options: string,
  }
}

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

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

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

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

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

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

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

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

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

export class AddPeerActionsRqst extends jspb.Message {
  getMac(): string;
  setMac(value: string): AddPeerActionsRqst;

  getActionsList(): Array<string>;
  setActionsList(value: Array<string>): AddPeerActionsRqst;
  clearActionsList(): AddPeerActionsRqst;
  addActions(value: string, index?: number): AddPeerActionsRqst;

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

export namespace AddPeerActionsRqst {
  export type AsObject = {
    mac: string,
    actionsList: Array<string>,
  }
}

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

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

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

export class RemovePeerActionRqst extends jspb.Message {
  getMac(): string;
  setMac(value: string): RemovePeerActionRqst;

  getAction(): string;
  setAction(value: string): RemovePeerActionRqst;

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

export namespace RemovePeerActionRqst {
  export type AsObject = {
    mac: string,
    action: string,
  }
}

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

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

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

export class RemovePeersActionRqst extends jspb.Message {
  getAction(): string;
  setAction(value: string): RemovePeersActionRqst;

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

export namespace RemovePeersActionRqst {
  export type AsObject = {
    action: string,
  }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  getCaller(): string;
  setCaller(value: string): Call;

  getCallee(): string;
  setCallee(value: string): Call;

  getStarttime(): number;
  setStarttime(value: number): Call;

  getEndtime(): number;
  setEndtime(value: number): Call;

  getTypename(): string;
  setTypename(value: string): Call;

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

export namespace Call {
  export type AsObject = {
    uuid: string,
    caller: string,
    callee: string,
    starttime: number,
    endtime: number,
    typename: string,
  }
}

export class GetCallHistoryRqst extends jspb.Message {
  getAccountId(): string;
  setAccountId(value: string): GetCallHistoryRqst;

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

export namespace GetCallHistoryRqst {
  export type AsObject = {
    accountId: string,
  }
}

export class GetCallHistoryRsp extends jspb.Message {
  getCallsList(): Array<Call>;
  setCallsList(value: Array<Call>): GetCallHistoryRsp;
  clearCallsList(): GetCallHistoryRsp;
  addCalls(value?: Call, index?: number): Call;

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

export namespace GetCallHistoryRsp {
  export type AsObject = {
    callsList: Array<Call.AsObject>,
  }
}

export class SetCallRqst extends jspb.Message {
  getCall(): Call | undefined;
  setCall(value?: Call): SetCallRqst;
  hasCall(): boolean;
  clearCall(): SetCallRqst;

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

export namespace SetCallRqst {
  export type AsObject = {
    call?: Call.AsObject,
  }
}

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

export namespace SetCallRsp {
  export type AsObject = {
  }
}

export class DeleteCallRqst extends jspb.Message {
  getAccountId(): string;
  setAccountId(value: string): DeleteCallRqst;

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

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

export namespace DeleteCallRqst {
  export type AsObject = {
    accountId: string,
    uuid: string,
  }
}

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

export namespace DeleteCallRsp {
  export type AsObject = {
  }
}

export class ClearCallsRqst extends jspb.Message {
  getAccountId(): string;
  setAccountId(value: string): ClearCallsRqst;

  getFilter(): string;
  setFilter(value: string): ClearCallsRqst;

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

export namespace ClearCallsRqst {
  export type AsObject = {
    accountId: string,
    filter: string,
  }
}

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

export namespace ClearCallsRsp {
  export type AsObject = {
  }
}

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

  getDate(): number;
  setDate(value: number): Notification;

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

  getRecipient(): string;
  setRecipient(value: string): Notification;

  getSender(): string;
  setSender(value: string): Notification;

  getNotificationType(): NotificationType;
  setNotificationType(value: NotificationType): Notification;

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

  getTypename(): string;
  setTypename(value: string): Notification;

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

export namespace Notification {
  export type AsObject = {
    id: string,
    date: number,
    message: string,
    recipient: string,
    sender: string,
    notificationType: NotificationType,
    mac: string,
    typename: string,
  }
}

export class CreateNotificationRqst extends jspb.Message {
  getNotification(): Notification | undefined;
  setNotification(value?: Notification): CreateNotificationRqst;
  hasNotification(): boolean;
  clearNotification(): CreateNotificationRqst;

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

export namespace CreateNotificationRqst {
  export type AsObject = {
    notification?: Notification.AsObject,
  }
}

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

export namespace CreateNotificationRsp {
  export type AsObject = {
  }
}

export class GetNotificationsRqst extends jspb.Message {
  getRecipient(): string;
  setRecipient(value: string): GetNotificationsRqst;

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

export namespace GetNotificationsRqst {
  export type AsObject = {
    recipient: string,
  }
}

export class GetNotificationsRsp extends jspb.Message {
  getNotificationsList(): Array<Notification>;
  setNotificationsList(value: Array<Notification>): GetNotificationsRsp;
  clearNotificationsList(): GetNotificationsRsp;
  addNotifications(value?: Notification, index?: number): Notification;

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

export namespace GetNotificationsRsp {
  export type AsObject = {
    notificationsList: Array<Notification.AsObject>,
  }
}

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

  getRecipient(): string;
  setRecipient(value: string): DeleteNotificationRqst;

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

export namespace DeleteNotificationRqst {
  export type AsObject = {
    id: string,
    recipient: string,
  }
}

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

export namespace DeleteNotificationRsp {
  export type AsObject = {
  }
}

export class ClearAllNotificationsRqst extends jspb.Message {
  getRecipient(): string;
  setRecipient(value: string): ClearAllNotificationsRqst;

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

export namespace ClearAllNotificationsRqst {
  export type AsObject = {
    recipient: string,
  }
}

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

export namespace ClearAllNotificationsRsp {
  export type AsObject = {
  }
}

export class ClearNotificationsByTypeRqst extends jspb.Message {
  getRecipient(): string;
  setRecipient(value: string): ClearNotificationsByTypeRqst;

  getNotificationType(): NotificationType;
  setNotificationType(value: NotificationType): ClearNotificationsByTypeRqst;

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

export namespace ClearNotificationsByTypeRqst {
  export type AsObject = {
    recipient: string,
    notificationType: NotificationType,
  }
}

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

export namespace ClearNotificationsByTypeRsp {
  export type AsObject = {
  }
}

export class Session extends jspb.Message {
  getAccountid(): string;
  setAccountid(value: string): Session;

  getState(): SessionState;
  setState(value: SessionState): Session;

  getLastStateTime(): number;
  setLastStateTime(value: number): Session;

  getExpireAt(): number;
  setExpireAt(value: number): Session;

  getTypename(): string;
  setTypename(value: string): Session;

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

export namespace Session {
  export type AsObject = {
    accountid: string,
    state: SessionState,
    lastStateTime: number,
    expireAt: number,
    typename: string,
  }
}

export class UpdateSessionRequest extends jspb.Message {
  getSession(): Session | undefined;
  setSession(value?: Session): UpdateSessionRequest;
  hasSession(): boolean;
  clearSession(): UpdateSessionRequest;

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

export namespace UpdateSessionRequest {
  export type AsObject = {
    session?: Session.AsObject,
  }
}

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

export namespace UpdateSessionResponse {
  export type AsObject = {
  }
}

export class RemoveSessionRequest extends jspb.Message {
  getAccountid(): string;
  setAccountid(value: string): RemoveSessionRequest;

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

export namespace RemoveSessionRequest {
  export type AsObject = {
    accountid: string,
  }
}

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

export namespace RemoveSessionResponse {
  export type AsObject = {
  }
}

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

  getOptions(): string;
  setOptions(value: string): GetSessionsRequest;

  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 = {
    query: string,
    options: string,
  }
}

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

  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<Session.AsObject>,
  }
}

export class GetSessionRequest extends jspb.Message {
  getAccountid(): string;
  setAccountid(value: string): GetSessionRequest;

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

export namespace GetSessionRequest {
  export type AsObject = {
    accountid: string,
  }
}

export class GetSessionResponse extends jspb.Message {
  getSession(): Session | undefined;
  setSession(value?: Session): GetSessionResponse;
  hasSession(): boolean;
  clearSession(): GetSessionResponse;

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

export namespace GetSessionResponse {
  export type AsObject = {
    session?: Session.AsObject,
  }
}

export class CreateReferenceRqst extends jspb.Message {
  getSourceid(): string;
  setSourceid(value: string): CreateReferenceRqst;

  getSourcecollection(): string;
  setSourcecollection(value: string): CreateReferenceRqst;

  getFieldname(): string;
  setFieldname(value: string): CreateReferenceRqst;

  getTargetid(): string;
  setTargetid(value: string): CreateReferenceRqst;

  getTargetcollection(): string;
  setTargetcollection(value: string): CreateReferenceRqst;

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

export namespace CreateReferenceRqst {
  export type AsObject = {
    sourceid: string,
    sourcecollection: string,
    fieldname: string,
    targetid: string,
    targetcollection: string,
  }
}

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

export namespace CreateReferenceRsp {
  export type AsObject = {
  }
}

export class DeleteReferenceRqst extends jspb.Message {
  getRefid(): string;
  setRefid(value: string): DeleteReferenceRqst;

  getTargetid(): string;
  setTargetid(value: string): DeleteReferenceRqst;

  getTargetfield(): string;
  setTargetfield(value: string): DeleteReferenceRqst;

  getTargetcollection(): string;
  setTargetcollection(value: string): DeleteReferenceRqst;

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

export namespace DeleteReferenceRqst {
  export type AsObject = {
    refid: string,
    targetid: string,
    targetfield: string,
    targetcollection: string,
  }
}

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

export namespace DeleteReferenceRsp {
  export type AsObject = {
  }
}

export enum PackageType { 
  UNKNOW_TYPE = 0,
  SERVICE_TYPE = 1,
  APPLICATION_TYPE = 2,
}
export enum PeerApprovalState { 
  PEER_PENDING = 0,
  PEER_ACCETEP = 1,
  PEER_REJECTED = 2,
}
export enum NotificationType { 
  USER_NOTIFICATION = 0,
  APPLICATION_NOTIFICATION = 1,
  SYSTEM_NOTIFICATION = 2,
}
export enum SessionState { 
  ONLINE = 0,
  OFFLINE = 1,
  AWAY = 2,
}