// package: runner
// file: proto/runner.proto

import * as jspb from "google-protobuf";

export class Instruction extends jspb.Message {
  hasExecTask(): boolean;
  clearExecTask(): void;
  getExecTask(): Instruction.ExecTask | undefined;
  setExecTask(value?: Instruction.ExecTask): void;

  hasExecCommand(): boolean;
  clearExecCommand(): void;
  getExecCommand(): Instruction.ExecCommand | undefined;
  setExecCommand(value?: Instruction.ExecCommand): void;

  hasLogger(): boolean;
  clearLogger(): void;
  getLogger(): Instruction.Logger | undefined;
  setLogger(value?: Instruction.Logger): void;

  hasAttachfile(): boolean;
  clearAttachfile(): void;
  getAttachfile(): Instruction.AttachFile | undefined;
  setAttachfile(value?: Instruction.AttachFile): void;

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

export namespace Instruction {
  export type AsObject = {
    execTask?: Instruction.ExecTask.AsObject,
    execCommand?: Instruction.ExecCommand.AsObject,
    logger?: Instruction.Logger.AsObject,
    attachfile?: Instruction.AttachFile.AsObject,
  }

  export class Task extends jspb.Message {
    getTaskId(): string;
    setTaskId(value: string): void;

    getTaskExecutionId(): string;
    setTaskExecutionId(value: string): void;

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

  export namespace Task {
    export type AsObject = {
      taskId: string,
      taskExecutionId: string,
    }
  }

  export class ExecTask extends jspb.Message {
    clearTaskList(): void;
    getTaskList(): Array<Instruction.Task>;
    setTaskList(value: Array<Instruction.Task>): void;
    addTask(value?: Instruction.Task, index?: number): Instruction.Task;

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

  export namespace ExecTask {
    export type AsObject = {
      taskList: Array<Instruction.Task.AsObject>,
    }
  }

  export class ExecCommand extends jspb.Message {
    getCommand(): string;
    setCommand(value: string): void;

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

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

  export namespace ExecCommand {
    export type AsObject = {
      command: string,
      argsList: Array<string>,
    }
  }

  export class Logger extends jspb.Message {
    hasInfo(): boolean;
    clearInfo(): void;
    getInfo(): string;
    setInfo(value: string): void;

    hasError(): boolean;
    clearError(): void;
    getError(): string;
    setError(value: string): void;

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

  export namespace Logger {
    export type AsObject = {
      info: string,
      error: string,
    }

    export enum KindCase {
      KIND_NOT_SET = 0,
      INFO = 1,
      ERROR = 2,
    }
  }

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

    getAbsolutePath(): string;
    setAbsolutePath(value: string): void;

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

  export namespace AttachFile {
    export type AsObject = {
      name: string,
      absolutePath: string,
    }
  }

  export enum KindCase {
    KIND_NOT_SET = 0,
    EXEC_TASK = 1,
    EXEC_COMMAND = 2,
    LOGGER = 3,
    ATTACHFILE = 4,
  }
}

export class Job extends jspb.Message {
  getProjectId(): string;
  setProjectId(value: string): void;

  getCommitId(): string;
  setCommitId(value: string): void;

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

export namespace Job {
  export type AsObject = {
    projectId: string,
    commitId: string,
  }
}

export class RegisterTaskRequest extends jspb.Message {
  hasJob(): boolean;
  clearJob(): void;
  getJob(): Job | undefined;
  setJob(value?: Job): void;

  clearTaskList(): void;
  getTaskList(): Array<RegisterTaskRequest.Task>;
  setTaskList(value: Array<RegisterTaskRequest.Task>): void;
  addTask(value?: RegisterTaskRequest.Task, index?: number): RegisterTaskRequest.Task;

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

export namespace RegisterTaskRequest {
  export type AsObject = {
    job?: Job.AsObject,
    taskList: Array<RegisterTaskRequest.Task.AsObject>,
  }

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

    getTaskId(): string;
    setTaskId(value: string): void;

    getParentTaskId(): string;
    setParentTaskId(value: string): void;

    clearDependencyTaskIdList(): void;
    getDependencyTaskIdList(): Array<string>;
    setDependencyTaskIdList(value: Array<string>): void;
    addDependencyTaskId(value: string, index?: number): string;

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

  export namespace Task {
    export type AsObject = {
      name: string,
      taskId: string,
      parentTaskId: string,
      dependencyTaskIdList: Array<string>,
    }
  }
}

export class RegisterTaskResponse extends jspb.Message {
  getRegistrationId(): string;
  setRegistrationId(value: string): void;

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

export namespace RegisterTaskResponse {
  export type AsObject = {
    registrationId: string,
  }
}

export class ExecuteTaskRequest extends jspb.Message {
  hasJob(): boolean;
  clearJob(): void;
  getJob(): Job | undefined;
  setJob(value?: Job): void;

  clearTaskList(): void;
  getTaskList(): Array<ExecuteTaskRequest.Task>;
  setTaskList(value: Array<ExecuteTaskRequest.Task>): void;
  addTask(value?: ExecuteTaskRequest.Task, index?: number): ExecuteTaskRequest.Task;

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

export namespace ExecuteTaskRequest {
  export type AsObject = {
    job?: Job.AsObject,
    taskList: Array<ExecuteTaskRequest.Task.AsObject>,
  }

  export class Task extends jspb.Message {
    getTaskId(): string;
    setTaskId(value: string): void;

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

  export namespace Task {
    export type AsObject = {
      taskId: string,
    }
  }
}

export class NextInstructionRequest extends jspb.Message {
  hasJob(): boolean;
  clearJob(): void;
  getJob(): Job | undefined;
  setJob(value?: Job): void;

  getRegistrationId(): string;
  setRegistrationId(value: string): void;

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

export namespace NextInstructionRequest {
  export type AsObject = {
    job?: Job.AsObject,
    registrationId: string,
  }
}

export class RegisterActionRequest extends jspb.Message {
  hasJob(): boolean;
  clearJob(): void;
  getJob(): Job | undefined;
  setJob(value?: Job): void;

  getTaskId(): string;
  setTaskId(value: string): void;

  getTaskExecutionId(): string;
  setTaskExecutionId(value: string): void;

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

  getStreamName(): string;
  setStreamName(value: string): void;

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

export namespace RegisterActionRequest {
  export type AsObject = {
    job?: Job.AsObject,
    taskId: string,
    taskExecutionId: string,
    name: string,
    streamName: string,
  }
}

export class CreateStreamRequest extends jspb.Message {
  hasJob(): boolean;
  clearJob(): void;
  getJob(): Job | undefined;
  setJob(value?: Job): void;

  getTaskId(): string;
  setTaskId(value: string): void;

  getTaskExecutionId(): string;
  setTaskExecutionId(value: string): void;

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

  getSha1(): string;
  setSha1(value: string): void;

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

  getMimetype(): string;
  setMimetype(value: string): void;

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

export namespace CreateStreamRequest {
  export type AsObject = {
    job?: Job.AsObject,
    taskId: string,
    taskExecutionId: string,
    name: string,
    sha1: string,
    size: number,
    mimetype: string,
  }
}

export class CreateStreamResponse extends jspb.Message {
  getStreamId(): string;
  setStreamId(value: string): void;

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

export namespace CreateStreamResponse {
  export type AsObject = {
    streamId: string,
  }
}

export class StreamRequest extends jspb.Message {
  hasJob(): boolean;
  clearJob(): void;
  getJob(): Job | undefined;
  setJob(value?: Job): void;

  getTaskId(): string;
  setTaskId(value: string): void;

  getTaskExecutionId(): string;
  setTaskExecutionId(value: string): void;

  getStreamId(): string;
  setStreamId(value: string): void;

  getContent(): Uint8Array | string;
  getContent_asU8(): Uint8Array;
  getContent_asB64(): string;
  setContent(value: Uint8Array | string): void;

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

export namespace StreamRequest {
  export type AsObject = {
    job?: Job.AsObject,
    taskId: string,
    taskExecutionId: string,
    streamId: string,
    content: Uint8Array | string,
  }
}

export class TaskStateRequest extends jspb.Message {
  hasJob(): boolean;
  clearJob(): void;
  getJob(): Job | undefined;
  setJob(value?: Job): void;

  getTaskId(): string;
  setTaskId(value: string): void;

  getTaskExecutionId(): string;
  setTaskExecutionId(value: string): void;

  getState(): TaskStateRequest.StateMap[keyof TaskStateRequest.StateMap];
  setState(value: TaskStateRequest.StateMap[keyof TaskStateRequest.StateMap]): void;

  getDatetime(): string;
  setDatetime(value: string): void;

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

export namespace TaskStateRequest {
  export type AsObject = {
    job?: Job.AsObject,
    taskId: string,
    taskExecutionId: string,
    state: TaskStateRequest.StateMap[keyof TaskStateRequest.StateMap],
    datetime: string,
  }

  export interface StateMap {
    STARTED: 0;
    ENDED_WITH_SUCCESS: 1;
    ENDED_WITH_ERROR: 2;
    SKIPPED: 3;
    CANCELLED: 4;
  }

  export const State: StateMap;
}

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

export namespace Empty {
  export type AsObject = {
  }
}