import * as jspb from 'google-protobuf'



export class HostInfo extends jspb.Message {
  getIp(): string;
  setIp(value: string): HostInfo;

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

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

  getInfos(): string;
  setInfos(value: string): HostInfo;

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

export namespace HostInfo {
  export type AsObject = {
    ip: string,
    mac: string,
    name: string,
    infos: string,
  }
}

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

export namespace getAvailableHostsRequest {
  export type AsObject = {
  }
}

export class getAvailableHostsResponse extends jspb.Message {
  getHostsList(): Array<HostInfo>;
  setHostsList(value: Array<HostInfo>): getAvailableHostsResponse;
  clearHostsList(): getAvailableHostsResponse;
  addHosts(value?: HostInfo, index?: number): HostInfo;

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

export namespace getAvailableHostsResponse {
  export type AsObject = {
    hostsList: Array<HostInfo.AsObject>,
  }
}

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

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

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

  getIsdir(): boolean;
  setIsdir(value: boolean): FileInfo;

  getModtime(): number;
  setModtime(value: number): FileInfo;

  getFilesList(): Array<FileInfo>;
  setFilesList(value: Array<FileInfo>): FileInfo;
  clearFilesList(): FileInfo;
  addFiles(value?: FileInfo, index?: number): FileInfo;

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

export namespace FileInfo {
  export type AsObject = {
    name: string,
    path: string,
    size: number,
    isdir: boolean,
    modtime: number,
    filesList: Array<FileInfo.AsObject>,
  }
}

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

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

export namespace HasRunningProcessRequest {
  export type AsObject = {
    name: string,
  }
}

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

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

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

export class RunCmdRequest extends jspb.Message {
  getCmd(): string;
  setCmd(value: string): RunCmdRequest;

  getArgsList(): Array<string>;
  setArgsList(value: Array<string>): RunCmdRequest;
  clearArgsList(): RunCmdRequest;
  addArgs(value: string, index?: number): RunCmdRequest;

  getBlocking(): boolean;
  setBlocking(value: boolean): RunCmdRequest;

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

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

export namespace RunCmdRequest {
  export type AsObject = {
    cmd: string,
    argsList: Array<string>,
    blocking: boolean,
    path: string,
  }
}

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

  getPid(): number;
  setPid(value: number): RunCmdResponse;

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

export namespace RunCmdResponse {
  export type AsObject = {
    result: string,
    pid: number,
  }
}

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

  getValue(): string;
  setValue(value: string): SetEnvironmentVariableRequest;

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

export namespace SetEnvironmentVariableRequest {
  export type AsObject = {
    name: string,
    value: string,
  }
}

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

export namespace SetEnvironmentVariableResponse {
  export type AsObject = {
  }
}

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

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

export namespace GetEnvironmentVariableRequest {
  export type AsObject = {
    name: string,
  }
}

export class GetEnvironmentVariableResponse extends jspb.Message {
  getValue(): string;
  setValue(value: string): GetEnvironmentVariableResponse;

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

export namespace GetEnvironmentVariableResponse {
  export type AsObject = {
    value: string,
  }
}

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

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

export namespace UnsetEnvironmentVariableRequest {
  export type AsObject = {
    name: string,
  }
}

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

export namespace UnsetEnvironmentVariableResponse {
  export type AsObject = {
  }
}

export class GetCertificatesRequest extends jspb.Message {
  getDomain(): string;
  setDomain(value: string): GetCertificatesRequest;

  getPort(): number;
  setPort(value: number): GetCertificatesRequest;

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

  getCountry(): string;
  setCountry(value: string): GetCertificatesRequest;

  getState(): string;
  setState(value: string): GetCertificatesRequest;

  getCity(): string;
  setCity(value: string): GetCertificatesRequest;

  getOrganization(): string;
  setOrganization(value: string): GetCertificatesRequest;

  getAlternatedomainsList(): Array<string>;
  setAlternatedomainsList(value: Array<string>): GetCertificatesRequest;
  clearAlternatedomainsList(): GetCertificatesRequest;
  addAlternatedomains(value: string, index?: number): GetCertificatesRequest;

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

export namespace GetCertificatesRequest {
  export type AsObject = {
    domain: string,
    port: number,
    path: string,
    country: string,
    state: string,
    city: string,
    organization: string,
    alternatedomainsList: Array<string>,
  }
}

export class GetCertificatesResponse extends jspb.Message {
  getCacert(): string;
  setCacert(value: string): GetCertificatesResponse;

  getCert(): string;
  setCert(value: string): GetCertificatesResponse;

  getCertkey(): string;
  setCertkey(value: string): GetCertificatesResponse;

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

export namespace GetCertificatesResponse {
  export type AsObject = {
    cacert: string,
    cert: string,
    certkey: string,
  }
}

export class KillProcessRequest extends jspb.Message {
  getPid(): number;
  setPid(value: number): KillProcessRequest;

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

export namespace KillProcessRequest {
  export type AsObject = {
    pid: number,
  }
}

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

export namespace KillProcessResponse {
  export type AsObject = {
  }
}

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

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

export namespace KillProcessesRequest {
  export type AsObject = {
    name: string,
  }
}

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

export namespace KillProcessesResponse {
  export type AsObject = {
  }
}

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

  getExec(): string;
  setExec(value: string): ProcessInfo;

  getPid(): number;
  setPid(value: number): ProcessInfo;

  getPpid(): number;
  setPpid(value: number): ProcessInfo;

  getUser(): string;
  setUser(value: string): ProcessInfo;

  getPriority(): string;
  setPriority(value: string): ProcessInfo;

  getCpuUsagePercent(): number;
  setCpuUsagePercent(value: number): ProcessInfo;

  getMemoryUsagePercent(): number;
  setMemoryUsagePercent(value: number): ProcessInfo;

  getMemoryUsage(): number;
  setMemoryUsage(value: number): ProcessInfo;

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

export namespace ProcessInfo {
  export type AsObject = {
    name: string,
    exec: string,
    pid: number,
    ppid: number,
    user: string,
    priority: string,
    cpuUsagePercent: number,
    memoryUsagePercent: number,
    memoryUsage: number,
  }
}

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

  getPid(): number;
  setPid(value: number): GetProcessInfosRequest;

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

export namespace GetProcessInfosRequest {
  export type AsObject = {
    name: string,
    pid: number,
  }
}

export class GetProcessInfosResponse extends jspb.Message {
  getInfosList(): Array<ProcessInfo>;
  setInfosList(value: Array<ProcessInfo>): GetProcessInfosResponse;
  clearInfosList(): GetProcessInfosResponse;
  addInfos(value?: ProcessInfo, index?: number): ProcessInfo;

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

export namespace GetProcessInfosResponse {
  export type AsObject = {
    infosList: Array<ProcessInfo.AsObject>,
  }
}

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

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

export namespace GetPidsRequest {
  export type AsObject = {
    name: string,
  }
}

export class GetPidsResponse extends jspb.Message {
  getPidsList(): Array<number>;
  setPidsList(value: Array<number>): GetPidsResponse;
  clearPidsList(): GetPidsResponse;
  addPids(value: number, index?: number): GetPidsResponse;

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

export namespace GetPidsResponse {
  export type AsObject = {
    pidsList: Array<number>,
  }
}

export class UpdateRequest extends jspb.Message {
  getPlatform(): string;
  setPlatform(value: string): UpdateRequest;

  getData(): Uint8Array | string;
  getData_asU8(): Uint8Array;
  getData_asB64(): string;
  setData(value: Uint8Array | string): UpdateRequest;

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

export namespace UpdateRequest {
  export type AsObject = {
    platform: string,
    data: Uint8Array | string,
  }
}

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

export namespace UpdateResponse {
  export type AsObject = {
  }
}

export class DownloadGlobularRequest extends jspb.Message {
  getPlatform(): string;
  setPlatform(value: string): DownloadGlobularRequest;

  getSource(): string;
  setSource(value: string): DownloadGlobularRequest;

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

export namespace DownloadGlobularRequest {
  export type AsObject = {
    platform: string,
    source: string,
  }
}

export class DownloadGlobularResponse extends jspb.Message {
  getData(): Uint8Array | string;
  getData_asU8(): Uint8Array;
  getData_asB64(): string;
  setData(value: Uint8Array | string): DownloadGlobularResponse;

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

export namespace DownloadGlobularResponse {
  export type AsObject = {
    data: Uint8Array | string,
  }
}

export class SaveConfigRequest extends jspb.Message {
  getConfig(): string;
  setConfig(value: string): SaveConfigRequest;

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

export namespace SaveConfigRequest {
  export type AsObject = {
    config: string,
  }
}

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

export namespace SaveConfigResponse {
  export type AsObject = {
  }
}

export class GetFileInfoRequest extends jspb.Message {
  getPath(): string;
  setPath(value: string): GetFileInfoRequest;

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

export namespace GetFileInfoRequest {
  export type AsObject = {
    path: string,
  }
}

export class GetFileInfoResponse extends jspb.Message {
  getInfo(): FileInfo | undefined;
  setInfo(value?: FileInfo): GetFileInfoResponse;
  hasInfo(): boolean;
  clearInfo(): GetFileInfoResponse;

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

export namespace GetFileInfoResponse {
  export type AsObject = {
    info?: FileInfo.AsObject,
  }
}