// package: gradle
// file: gradle.proto

import * as jspb from "google-protobuf";

export class GetBuildRequest extends jspb.Message {
  getProjectDir(): string;
  setProjectDir(value: string): void;

  getCancellationKey(): string;
  setCancellationKey(value: string): void;

  hasGradleConfig(): boolean;
  clearGradleConfig(): void;
  getGradleConfig(): GradleConfig | undefined;
  setGradleConfig(value?: GradleConfig): void;

  getShowOutputColors(): boolean;
  setShowOutputColors(value: boolean): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GetBuildRequest.AsObject;
  static toObject(includeInstance: boolean, msg: GetBuildRequest): GetBuildRequest.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: GetBuildRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GetBuildRequest;
  static deserializeBinaryFromReader(message: GetBuildRequest, reader: jspb.BinaryReader): GetBuildRequest;
}

export namespace GetBuildRequest {
  export type AsObject = {
    projectDir: string,
    cancellationKey: string,
    gradleConfig?: GradleConfig.AsObject,
    showOutputColors: boolean,
  }
}

export class GetBuildReply extends jspb.Message {
  hasGetBuildResult(): boolean;
  clearGetBuildResult(): void;
  getGetBuildResult(): GetBuildResult | undefined;
  setGetBuildResult(value?: GetBuildResult): void;

  hasProgress(): boolean;
  clearProgress(): void;
  getProgress(): Progress | undefined;
  setProgress(value?: Progress): void;

  hasOutput(): boolean;
  clearOutput(): void;
  getOutput(): Output | undefined;
  setOutput(value?: Output): void;

  hasCancelled(): boolean;
  clearCancelled(): void;
  getCancelled(): Cancelled | undefined;
  setCancelled(value?: Cancelled): void;

  hasEnvironment(): boolean;
  clearEnvironment(): void;
  getEnvironment(): Environment | undefined;
  setEnvironment(value?: Environment): void;

  hasCompatibilityCheckError(): boolean;
  clearCompatibilityCheckError(): void;
  getCompatibilityCheckError(): string;
  setCompatibilityCheckError(value: string): void;

  getKindCase(): GetBuildReply.KindCase;
  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GetBuildReply.AsObject;
  static toObject(includeInstance: boolean, msg: GetBuildReply): GetBuildReply.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: GetBuildReply, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GetBuildReply;
  static deserializeBinaryFromReader(message: GetBuildReply, reader: jspb.BinaryReader): GetBuildReply;
}

export namespace GetBuildReply {
  export type AsObject = {
    getBuildResult?: GetBuildResult.AsObject,
    progress?: Progress.AsObject,
    output?: Output.AsObject,
    cancelled?: Cancelled.AsObject,
    environment?: Environment.AsObject,
    compatibilityCheckError: string,
  }

  export enum KindCase {
    KIND_NOT_SET = 0,
    GET_BUILD_RESULT = 1,
    PROGRESS = 2,
    OUTPUT = 3,
    CANCELLED = 4,
    ENVIRONMENT = 5,
    COMPATIBILITY_CHECK_ERROR = 6,
  }
}

export class GetBuildResult extends jspb.Message {
  getMessage(): string;
  setMessage(value: string): void;

  hasBuild(): boolean;
  clearBuild(): void;
  getBuild(): GradleBuild | undefined;
  setBuild(value?: GradleBuild): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GetBuildResult.AsObject;
  static toObject(includeInstance: boolean, msg: GetBuildResult): GetBuildResult.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: GetBuildResult, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GetBuildResult;
  static deserializeBinaryFromReader(message: GetBuildResult, reader: jspb.BinaryReader): GetBuildResult;
}

export namespace GetBuildResult {
  export type AsObject = {
    message: string,
    build?: GradleBuild.AsObject,
  }
}

export class GetProjectsRequest extends jspb.Message {
  getProjectDir(): string;
  setProjectDir(value: string): void;

  hasGradleConfig(): boolean;
  clearGradleConfig(): void;
  getGradleConfig(): GradleConfig | undefined;
  setGradleConfig(value?: GradleConfig): void;

  getCancellationKey(): string;
  setCancellationKey(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GetProjectsRequest.AsObject;
  static toObject(includeInstance: boolean, msg: GetProjectsRequest): GetProjectsRequest.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: GetProjectsRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GetProjectsRequest;
  static deserializeBinaryFromReader(message: GetProjectsRequest, reader: jspb.BinaryReader): GetProjectsRequest;
}

export namespace GetProjectsRequest {
  export type AsObject = {
    projectDir: string,
    gradleConfig?: GradleConfig.AsObject,
    cancellationKey: string,
  }
}

export class GetProjectsReply extends jspb.Message {
  hasItem(): boolean;
  clearItem(): void;
  getItem(): DependencyItem | undefined;
  setItem(value?: DependencyItem): void;

  clearPluginsList(): void;
  getPluginsList(): Array<string>;
  setPluginsList(value: Array<string>): void;
  addPlugins(value: string, index?: number): string;

  clearPluginclosuresList(): void;
  getPluginclosuresList(): Array<GrpcGradleClosure>;
  setPluginclosuresList(value: Array<GrpcGradleClosure>): void;
  addPluginclosures(value?: GrpcGradleClosure, index?: number): GrpcGradleClosure;

  clearScriptclasspathsList(): void;
  getScriptclasspathsList(): Array<string>;
  setScriptclasspathsList(value: Array<string>): void;
  addScriptclasspaths(value: string, index?: number): string;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GetProjectsReply.AsObject;
  static toObject(includeInstance: boolean, msg: GetProjectsReply): GetProjectsReply.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: GetProjectsReply, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GetProjectsReply;
  static deserializeBinaryFromReader(message: GetProjectsReply, reader: jspb.BinaryReader): GetProjectsReply;
}

export namespace GetProjectsReply {
  export type AsObject = {
    item?: DependencyItem.AsObject,
    pluginsList: Array<string>,
    pluginclosuresList: Array<GrpcGradleClosure.AsObject>,
    scriptclasspathsList: Array<string>,
  }
}

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

  getType(): GradleDependencyTypeMap[keyof GradleDependencyTypeMap];
  setType(value: GradleDependencyTypeMap[keyof GradleDependencyTypeMap]): void;

  clearChildrenList(): void;
  getChildrenList(): Array<DependencyItem>;
  setChildrenList(value: Array<DependencyItem>): void;
  addChildren(value?: DependencyItem, index?: number): DependencyItem;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): DependencyItem.AsObject;
  static toObject(includeInstance: boolean, msg: DependencyItem): DependencyItem.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: DependencyItem, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): DependencyItem;
  static deserializeBinaryFromReader(message: DependencyItem, reader: jspb.BinaryReader): DependencyItem;
}

export namespace DependencyItem {
  export type AsObject = {
    name: string,
    type: GradleDependencyTypeMap[keyof GradleDependencyTypeMap],
    childrenList: Array<DependencyItem.AsObject>,
  }
}

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

  clearMethodsList(): void;
  getMethodsList(): Array<GrpcGradleMethod>;
  setMethodsList(value: Array<GrpcGradleMethod>): void;
  addMethods(value?: GrpcGradleMethod, index?: number): GrpcGradleMethod;

  clearFieldsList(): void;
  getFieldsList(): Array<GrpcGradleField>;
  setFieldsList(value: Array<GrpcGradleField>): void;
  addFields(value?: GrpcGradleField, index?: number): GrpcGradleField;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GrpcGradleClosure.AsObject;
  static toObject(includeInstance: boolean, msg: GrpcGradleClosure): GrpcGradleClosure.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: GrpcGradleClosure, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GrpcGradleClosure;
  static deserializeBinaryFromReader(message: GrpcGradleClosure, reader: jspb.BinaryReader): GrpcGradleClosure;
}

export namespace GrpcGradleClosure {
  export type AsObject = {
    name: string,
    methodsList: Array<GrpcGradleMethod.AsObject>,
    fieldsList: Array<GrpcGradleField.AsObject>,
  }
}

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

  clearParametertypesList(): void;
  getParametertypesList(): Array<string>;
  setParametertypesList(value: Array<string>): void;
  addParametertypes(value: string, index?: number): string;

  getDeprecated(): boolean;
  setDeprecated(value: boolean): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GrpcGradleMethod.AsObject;
  static toObject(includeInstance: boolean, msg: GrpcGradleMethod): GrpcGradleMethod.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: GrpcGradleMethod, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GrpcGradleMethod;
  static deserializeBinaryFromReader(message: GrpcGradleMethod, reader: jspb.BinaryReader): GrpcGradleMethod;
}

export namespace GrpcGradleMethod {
  export type AsObject = {
    name: string,
    parametertypesList: Array<string>,
    deprecated: boolean,
  }
}

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

  getDeprecated(): boolean;
  setDeprecated(value: boolean): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GrpcGradleField.AsObject;
  static toObject(includeInstance: boolean, msg: GrpcGradleField): GrpcGradleField.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: GrpcGradleField, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GrpcGradleField;
  static deserializeBinaryFromReader(message: GrpcGradleField, reader: jspb.BinaryReader): GrpcGradleField;
}

export namespace GrpcGradleField {
  export type AsObject = {
    name: string,
    deprecated: boolean,
  }
}

export class RunBuildRequest extends jspb.Message {
  getProjectDir(): string;
  setProjectDir(value: string): void;

  getCancellationKey(): string;
  setCancellationKey(value: string): void;

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

  getJavaDebugPort(): number;
  setJavaDebugPort(value: number): void;

  hasGradleConfig(): boolean;
  clearGradleConfig(): void;
  getGradleConfig(): GradleConfig | undefined;
  setGradleConfig(value?: GradleConfig): void;

  getInput(): string;
  setInput(value: string): void;

  getShowOutputColors(): boolean;
  setShowOutputColors(value: boolean): void;

  getJavaDebugCleanOutputCache(): boolean;
  setJavaDebugCleanOutputCache(value: boolean): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): RunBuildRequest.AsObject;
  static toObject(includeInstance: boolean, msg: RunBuildRequest): RunBuildRequest.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: RunBuildRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): RunBuildRequest;
  static deserializeBinaryFromReader(message: RunBuildRequest, reader: jspb.BinaryReader): RunBuildRequest;
}

export namespace RunBuildRequest {
  export type AsObject = {
    projectDir: string,
    cancellationKey: string,
    argsList: Array<string>,
    javaDebugPort: number,
    gradleConfig?: GradleConfig.AsObject,
    input: string,
    showOutputColors: boolean,
    javaDebugCleanOutputCache: boolean,
  }
}

export class RunBuildResult extends jspb.Message {
  getMessage(): string;
  setMessage(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): RunBuildResult.AsObject;
  static toObject(includeInstance: boolean, msg: RunBuildResult): RunBuildResult.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: RunBuildResult, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): RunBuildResult;
  static deserializeBinaryFromReader(message: RunBuildResult, reader: jspb.BinaryReader): RunBuildResult;
}

export namespace RunBuildResult {
  export type AsObject = {
    message: string,
  }
}

export class RunBuildReply extends jspb.Message {
  hasRunBuildResult(): boolean;
  clearRunBuildResult(): void;
  getRunBuildResult(): RunBuildResult | undefined;
  setRunBuildResult(value?: RunBuildResult): void;

  hasProgress(): boolean;
  clearProgress(): void;
  getProgress(): Progress | undefined;
  setProgress(value?: Progress): void;

  hasOutput(): boolean;
  clearOutput(): void;
  getOutput(): Output | undefined;
  setOutput(value?: Output): void;

  hasCancelled(): boolean;
  clearCancelled(): void;
  getCancelled(): Cancelled | undefined;
  setCancelled(value?: Cancelled): void;

  getKindCase(): RunBuildReply.KindCase;
  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): RunBuildReply.AsObject;
  static toObject(includeInstance: boolean, msg: RunBuildReply): RunBuildReply.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: RunBuildReply, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): RunBuildReply;
  static deserializeBinaryFromReader(message: RunBuildReply, reader: jspb.BinaryReader): RunBuildReply;
}

export namespace RunBuildReply {
  export type AsObject = {
    runBuildResult?: RunBuildResult.AsObject,
    progress?: Progress.AsObject,
    output?: Output.AsObject,
    cancelled?: Cancelled.AsObject,
  }

  export enum KindCase {
    KIND_NOT_SET = 0,
    RUN_BUILD_RESULT = 1,
    PROGRESS = 2,
    OUTPUT = 3,
    CANCELLED = 4,
  }
}

export class CancelBuildRequest extends jspb.Message {
  getCancellationKey(): string;
  setCancellationKey(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): CancelBuildRequest.AsObject;
  static toObject(includeInstance: boolean, msg: CancelBuildRequest): CancelBuildRequest.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: CancelBuildRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): CancelBuildRequest;
  static deserializeBinaryFromReader(message: CancelBuildRequest, reader: jspb.BinaryReader): CancelBuildRequest;
}

export namespace CancelBuildRequest {
  export type AsObject = {
    cancellationKey: string,
  }
}

export class CancelBuildsRequest extends jspb.Message {
  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): CancelBuildsRequest.AsObject;
  static toObject(includeInstance: boolean, msg: CancelBuildsRequest): CancelBuildsRequest.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: CancelBuildsRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): CancelBuildsRequest;
  static deserializeBinaryFromReader(message: CancelBuildsRequest, reader: jspb.BinaryReader): CancelBuildsRequest;
}

export namespace CancelBuildsRequest {
  export type AsObject = {
  }
}

export class CancelBuildReply extends jspb.Message {
  getMessage(): string;
  setMessage(value: string): void;

  getBuildRunning(): boolean;
  setBuildRunning(value: boolean): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): CancelBuildReply.AsObject;
  static toObject(includeInstance: boolean, msg: CancelBuildReply): CancelBuildReply.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: CancelBuildReply, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): CancelBuildReply;
  static deserializeBinaryFromReader(message: CancelBuildReply, reader: jspb.BinaryReader): CancelBuildReply;
}

export namespace CancelBuildReply {
  export type AsObject = {
    message: string,
    buildRunning: boolean,
  }
}

export class CancelBuildsReply extends jspb.Message {
  getMessage(): string;
  setMessage(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): CancelBuildsReply.AsObject;
  static toObject(includeInstance: boolean, msg: CancelBuildsReply): CancelBuildsReply.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: CancelBuildsReply, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): CancelBuildsReply;
  static deserializeBinaryFromReader(message: CancelBuildsReply, reader: jspb.BinaryReader): CancelBuildsReply;
}

export namespace CancelBuildsReply {
  export type AsObject = {
    message: string,
  }
}

export class CancelProjectsRequest extends jspb.Message {
  getCancellationKey(): string;
  setCancellationKey(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): CancelProjectsRequest.AsObject;
  static toObject(includeInstance: boolean, msg: CancelProjectsRequest): CancelProjectsRequest.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: CancelProjectsRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): CancelProjectsRequest;
  static deserializeBinaryFromReader(message: CancelProjectsRequest, reader: jspb.BinaryReader): CancelProjectsRequest;
}

export namespace CancelProjectsRequest {
  export type AsObject = {
    cancellationKey: string,
  }
}

export class CancelProjectsReply extends jspb.Message {
  getMessage(): string;
  setMessage(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): CancelProjectsReply.AsObject;
  static toObject(includeInstance: boolean, msg: CancelProjectsReply): CancelProjectsReply.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: CancelProjectsReply, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): CancelProjectsReply;
  static deserializeBinaryFromReader(message: CancelProjectsReply, reader: jspb.BinaryReader): CancelProjectsReply;
}

export namespace CancelProjectsReply {
  export type AsObject = {
    message: string,
  }
}

export class GetDaemonsStatusRequest extends jspb.Message {
  getProjectDir(): string;
  setProjectDir(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GetDaemonsStatusRequest.AsObject;
  static toObject(includeInstance: boolean, msg: GetDaemonsStatusRequest): GetDaemonsStatusRequest.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: GetDaemonsStatusRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GetDaemonsStatusRequest;
  static deserializeBinaryFromReader(message: GetDaemonsStatusRequest, reader: jspb.BinaryReader): GetDaemonsStatusRequest;
}

export namespace GetDaemonsStatusRequest {
  export type AsObject = {
    projectDir: string,
  }
}

export class GetDaemonsStatusReply extends jspb.Message {
  clearDaemonInfoList(): void;
  getDaemonInfoList(): Array<DaemonInfo>;
  setDaemonInfoList(value: Array<DaemonInfo>): void;
  addDaemonInfo(value?: DaemonInfo, index?: number): DaemonInfo;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GetDaemonsStatusReply.AsObject;
  static toObject(includeInstance: boolean, msg: GetDaemonsStatusReply): GetDaemonsStatusReply.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: GetDaemonsStatusReply, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GetDaemonsStatusReply;
  static deserializeBinaryFromReader(message: GetDaemonsStatusReply, reader: jspb.BinaryReader): GetDaemonsStatusReply;
}

export namespace GetDaemonsStatusReply {
  export type AsObject = {
    daemonInfoList: Array<DaemonInfo.AsObject>,
  }
}

export class StopDaemonsRequest extends jspb.Message {
  getProjectDir(): string;
  setProjectDir(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): StopDaemonsRequest.AsObject;
  static toObject(includeInstance: boolean, msg: StopDaemonsRequest): StopDaemonsRequest.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: StopDaemonsRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): StopDaemonsRequest;
  static deserializeBinaryFromReader(message: StopDaemonsRequest, reader: jspb.BinaryReader): StopDaemonsRequest;
}

export namespace StopDaemonsRequest {
  export type AsObject = {
    projectDir: string,
  }
}

export class StopDaemonsReply extends jspb.Message {
  getMessage(): string;
  setMessage(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): StopDaemonsReply.AsObject;
  static toObject(includeInstance: boolean, msg: StopDaemonsReply): StopDaemonsReply.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: StopDaemonsReply, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): StopDaemonsReply;
  static deserializeBinaryFromReader(message: StopDaemonsReply, reader: jspb.BinaryReader): StopDaemonsReply;
}

export namespace StopDaemonsReply {
  export type AsObject = {
    message: string,
  }
}

export class StopDaemonRequest extends jspb.Message {
  getPid(): string;
  setPid(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): StopDaemonRequest.AsObject;
  static toObject(includeInstance: boolean, msg: StopDaemonRequest): StopDaemonRequest.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: StopDaemonRequest, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): StopDaemonRequest;
  static deserializeBinaryFromReader(message: StopDaemonRequest, reader: jspb.BinaryReader): StopDaemonRequest;
}

export namespace StopDaemonRequest {
  export type AsObject = {
    pid: string,
  }
}

export class StopDaemonReply extends jspb.Message {
  getMessage(): string;
  setMessage(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): StopDaemonReply.AsObject;
  static toObject(includeInstance: boolean, msg: StopDaemonReply): StopDaemonReply.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: StopDaemonReply, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): StopDaemonReply;
  static deserializeBinaryFromReader(message: StopDaemonReply, reader: jspb.BinaryReader): StopDaemonReply;
}

export namespace StopDaemonReply {
  export type AsObject = {
    message: string,
  }
}

export class DaemonInfo extends jspb.Message {
  getPid(): string;
  setPid(value: string): void;

  getStatus(): DaemonInfo.DaemonStatusMap[keyof DaemonInfo.DaemonStatusMap];
  setStatus(value: DaemonInfo.DaemonStatusMap[keyof DaemonInfo.DaemonStatusMap]): void;

  getInfo(): string;
  setInfo(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): DaemonInfo.AsObject;
  static toObject(includeInstance: boolean, msg: DaemonInfo): DaemonInfo.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: DaemonInfo, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): DaemonInfo;
  static deserializeBinaryFromReader(message: DaemonInfo, reader: jspb.BinaryReader): DaemonInfo;
}

export namespace DaemonInfo {
  export type AsObject = {
    pid: string,
    status: DaemonInfo.DaemonStatusMap[keyof DaemonInfo.DaemonStatusMap],
    info: string,
  }

  export interface DaemonStatusMap {
    IDLE: 0;
    BUSY: 1;
    STOPPED: 2;
    STOPPING: 3;
    CANCELED: 4;
  }

  export const DaemonStatus: DaemonStatusMap;
}

export class GradleConfig extends jspb.Message {
  getGradleHome(): string;
  setGradleHome(value: string): void;

  getUserHome(): string;
  setUserHome(value: string): void;

  getJvmArguments(): string;
  setJvmArguments(value: string): void;

  getWrapperEnabled(): boolean;
  setWrapperEnabled(value: boolean): void;

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

  getJavaExtensionVersion(): string;
  setJavaExtensionVersion(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GradleConfig.AsObject;
  static toObject(includeInstance: boolean, msg: GradleConfig): GradleConfig.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: GradleConfig, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GradleConfig;
  static deserializeBinaryFromReader(message: GradleConfig, reader: jspb.BinaryReader): GradleConfig;
}

export namespace GradleConfig {
  export type AsObject = {
    gradleHome: string,
    userHome: string,
    jvmArguments: string,
    wrapperEnabled: boolean,
    version: string,
    javaExtensionVersion: string,
  }
}

export class GradleBuild extends jspb.Message {
  hasProject(): boolean;
  clearProject(): void;
  getProject(): GradleProject | undefined;
  setProject(value?: GradleProject): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GradleBuild.AsObject;
  static toObject(includeInstance: boolean, msg: GradleBuild): GradleBuild.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: GradleBuild, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GradleBuild;
  static deserializeBinaryFromReader(message: GradleBuild, reader: jspb.BinaryReader): GradleBuild;
}

export namespace GradleBuild {
  export type AsObject = {
    project?: GradleProject.AsObject,
  }
}

export class GradleProject extends jspb.Message {
  getIsRoot(): boolean;
  setIsRoot(value: boolean): void;

  clearTasksList(): void;
  getTasksList(): Array<GradleTask>;
  setTasksList(value: Array<GradleTask>): void;
  addTasks(value?: GradleTask, index?: number): GradleTask;

  clearProjectsList(): void;
  getProjectsList(): Array<GradleProject>;
  setProjectsList(value: Array<GradleProject>): void;
  addProjects(value?: GradleProject, index?: number): GradleProject;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GradleProject.AsObject;
  static toObject(includeInstance: boolean, msg: GradleProject): GradleProject.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: GradleProject, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GradleProject;
  static deserializeBinaryFromReader(message: GradleProject, reader: jspb.BinaryReader): GradleProject;
}

export namespace GradleProject {
  export type AsObject = {
    isRoot: boolean,
    tasksList: Array<GradleTask.AsObject>,
    projectsList: Array<GradleProject.AsObject>,
  }
}

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

  getGroup(): string;
  setGroup(value: string): void;

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

  getProject(): string;
  setProject(value: string): void;

  getBuildfile(): string;
  setBuildfile(value: string): void;

  getRootproject(): string;
  setRootproject(value: string): void;

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

  getDebuggable(): boolean;
  setDebuggable(value: boolean): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GradleTask.AsObject;
  static toObject(includeInstance: boolean, msg: GradleTask): GradleTask.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: GradleTask, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GradleTask;
  static deserializeBinaryFromReader(message: GradleTask, reader: jspb.BinaryReader): GradleTask;
}

export namespace GradleTask {
  export type AsObject = {
    name: string,
    group: string,
    path: string,
    project: string,
    buildfile: string,
    rootproject: string,
    description: string,
    debuggable: boolean,
  }
}

export class Cancelled extends jspb.Message {
  getMessage(): string;
  setMessage(value: string): void;

  getProjectDir(): string;
  setProjectDir(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): Cancelled.AsObject;
  static toObject(includeInstance: boolean, msg: Cancelled): Cancelled.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: Cancelled, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): Cancelled;
  static deserializeBinaryFromReader(message: Cancelled, reader: jspb.BinaryReader): Cancelled;
}

export namespace Cancelled {
  export type AsObject = {
    message: string,
    projectDir: string,
  }
}

export class Progress extends jspb.Message {
  getMessage(): string;
  setMessage(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): Progress.AsObject;
  static toObject(includeInstance: boolean, msg: Progress): Progress.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: Progress, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): Progress;
  static deserializeBinaryFromReader(message: Progress, reader: jspb.BinaryReader): Progress;
}

export namespace Progress {
  export type AsObject = {
    message: string,
  }
}

export class Environment extends jspb.Message {
  hasJavaEnvironment(): boolean;
  clearJavaEnvironment(): void;
  getJavaEnvironment(): JavaEnvironment | undefined;
  setJavaEnvironment(value?: JavaEnvironment): void;

  hasGradleEnvironment(): boolean;
  clearGradleEnvironment(): void;
  getGradleEnvironment(): GradleEnvironment | undefined;
  setGradleEnvironment(value?: GradleEnvironment): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): Environment.AsObject;
  static toObject(includeInstance: boolean, msg: Environment): Environment.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: Environment, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): Environment;
  static deserializeBinaryFromReader(message: Environment, reader: jspb.BinaryReader): Environment;
}

export namespace Environment {
  export type AsObject = {
    javaEnvironment?: JavaEnvironment.AsObject,
    gradleEnvironment?: GradleEnvironment.AsObject,
  }
}

export class JavaEnvironment extends jspb.Message {
  getJavaHome(): string;
  setJavaHome(value: string): void;

  clearJvmArgsList(): void;
  getJvmArgsList(): Array<string>;
  setJvmArgsList(value: Array<string>): void;
  addJvmArgs(value: string, index?: number): string;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): JavaEnvironment.AsObject;
  static toObject(includeInstance: boolean, msg: JavaEnvironment): JavaEnvironment.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: JavaEnvironment, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): JavaEnvironment;
  static deserializeBinaryFromReader(message: JavaEnvironment, reader: jspb.BinaryReader): JavaEnvironment;
}

export namespace JavaEnvironment {
  export type AsObject = {
    javaHome: string,
    jvmArgsList: Array<string>,
  }
}

export class GradleEnvironment extends jspb.Message {
  getGradleUserHome(): string;
  setGradleUserHome(value: string): void;

  getGradleVersion(): string;
  setGradleVersion(value: string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): GradleEnvironment.AsObject;
  static toObject(includeInstance: boolean, msg: GradleEnvironment): GradleEnvironment.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: GradleEnvironment, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): GradleEnvironment;
  static deserializeBinaryFromReader(message: GradleEnvironment, reader: jspb.BinaryReader): GradleEnvironment;
}

export namespace GradleEnvironment {
  export type AsObject = {
    gradleUserHome: string,
    gradleVersion: string,
  }
}

export class Output extends jspb.Message {
  getOutputType(): Output.OutputTypeMap[keyof Output.OutputTypeMap];
  setOutputType(value: Output.OutputTypeMap[keyof Output.OutputTypeMap]): void;

  getOutputBytes(): Uint8Array | string;
  getOutputBytes_asU8(): Uint8Array;
  getOutputBytes_asB64(): string;
  setOutputBytes(value: Uint8Array | string): void;

  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): Output.AsObject;
  static toObject(includeInstance: boolean, msg: Output): Output.AsObject;
  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
  static serializeBinaryToWriter(message: Output, writer: jspb.BinaryWriter): void;
  static deserializeBinary(bytes: Uint8Array): Output;
  static deserializeBinaryFromReader(message: Output, reader: jspb.BinaryReader): Output;
}

export namespace Output {
  export type AsObject = {
    outputType: Output.OutputTypeMap[keyof Output.OutputTypeMap],
    outputBytes: Uint8Array | string,
  }

  export interface OutputTypeMap {
    STDERR: 0;
    STDOUT: 1;
  }

  export const OutputType: OutputTypeMap;
}

export interface GradleDependencyTypeMap {
  PROJECT: 0;
  CONFIGURATION: 1;
  DEPENDENCY: 2;
}

export const GradleDependencyType: GradleDependencyTypeMap;