import * as jspb from 'google-protobuf'



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

  getNb(): number;
  setNb(value: number): CreateVideoPreviewRequest;

  getHeight(): number;
  setHeight(value: number): CreateVideoPreviewRequest;

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

export namespace CreateVideoPreviewRequest {
  export type AsObject = {
    path: string,
    nb: number,
    height: number,
  }
}

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

export namespace CreateVideoPreviewResponse {
  export type AsObject = {
  }
}

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

  getWidth(): number;
  setWidth(value: number): CreateVideoTimeLineRequest;

  getFps(): number;
  setFps(value: number): CreateVideoTimeLineRequest;

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

export namespace CreateVideoTimeLineRequest {
  export type AsObject = {
    path: string,
    width: number,
    fps: number,
  }
}

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

export namespace CreateVideoTimeLineResponse {
  export type AsObject = {
  }
}

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

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

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

export class ConvertVideoToMpeg4H264Response extends jspb.Message {
  getOutput(): string;
  setOutput(value: string): ConvertVideoToMpeg4H264Response;

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

export namespace ConvertVideoToMpeg4H264Response {
  export type AsObject = {
    output: string,
  }
}

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

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

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

export class ConvertVideoToHlsResponse extends jspb.Message {
  getOutput(): string;
  setOutput(value: string): ConvertVideoToHlsResponse;

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

export namespace ConvertVideoToHlsResponse {
  export type AsObject = {
    output: string,
  }
}

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

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

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

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

export namespace StartProcessVideoResponse {
  export type AsObject = {
  }
}

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

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

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

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

export namespace StartProcessAudioResponse {
  export type AsObject = {
  }
}

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

export namespace IsProcessVideoRequest {
  export type AsObject = {
  }
}

export class IsProcessVideoResponse extends jspb.Message {
  getIsprocessvideo(): boolean;
  setIsprocessvideo(value: boolean): IsProcessVideoResponse;

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

export namespace IsProcessVideoResponse {
  export type AsObject = {
    isprocessvideo: boolean,
  }
}

export class UploadVideoRequest extends jspb.Message {
  getUrl(): string;
  setUrl(value: string): UploadVideoRequest;

  getDest(): string;
  setDest(value: string): UploadVideoRequest;

  getFormat(): string;
  setFormat(value: string): UploadVideoRequest;

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

export namespace UploadVideoRequest {
  export type AsObject = {
    url: string,
    dest: string,
    format: string,
  }
}

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

  getResult(): string;
  setResult(value: string): UploadVideoResponse;

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

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

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

export namespace StopProcessVideoRequest {
  export type AsObject = {
  }
}

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

export namespace StopProcessVideoResponse {
  export type AsObject = {
  }
}

export class SetVideoConversionRequest extends jspb.Message {
  getValue(): boolean;
  setValue(value: boolean): SetVideoConversionRequest;

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

export namespace SetVideoConversionRequest {
  export type AsObject = {
    value: boolean,
  }
}

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

export namespace SetVideoConversionResponse {
  export type AsObject = {
  }
}

export class SetVideoStreamConversionRequest extends jspb.Message {
  getValue(): boolean;
  setValue(value: boolean): SetVideoStreamConversionRequest;

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

export namespace SetVideoStreamConversionRequest {
  export type AsObject = {
    value: boolean,
  }
}

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

export namespace SetVideoStreamConversionResponse {
  export type AsObject = {
  }
}

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

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

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

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

export namespace SetStartVideoConversionHourResponse {
  export type AsObject = {
  }
}

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

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

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

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

export namespace SetMaximumVideoConversionDelayResponse {
  export type AsObject = {
  }
}

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

  getError(): string;
  setError(value: string): VideoConversionError;

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

export namespace VideoConversionError {
  export type AsObject = {
    path: string,
    error: string,
  }
}

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

export namespace GetVideoConversionErrorsRequest {
  export type AsObject = {
  }
}

export class GetVideoConversionErrorsResponse extends jspb.Message {
  getErrorsList(): Array<VideoConversionError>;
  setErrorsList(value: Array<VideoConversionError>): GetVideoConversionErrorsResponse;
  clearErrorsList(): GetVideoConversionErrorsResponse;
  addErrors(value?: VideoConversionError, index?: number): VideoConversionError;

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

export namespace GetVideoConversionErrorsResponse {
  export type AsObject = {
    errorsList: Array<VideoConversionError.AsObject>,
  }
}

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

export namespace ClearVideoConversionErrorsRequest {
  export type AsObject = {
  }
}

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

export namespace ClearVideoConversionErrorsResponse {
  export type AsObject = {
  }
}

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

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

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

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

export namespace ClearVideoConversionErrorResponse {
  export type AsObject = {
  }
}

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

export namespace ClearVideoConversionLogsRequest {
  export type AsObject = {
  }
}

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

export namespace ClearVideoConversionLogsResponse {
  export type AsObject = {
  }
}

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

  getMsg(): string;
  setMsg(value: string): VideoConversionLog;

  getLogTime(): number;
  setLogTime(value: number): VideoConversionLog;

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

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

export namespace VideoConversionLog {
  export type AsObject = {
    path: string,
    msg: string,
    logTime: number,
    status: string,
  }
}

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

export namespace GetVideoConversionLogsRequest {
  export type AsObject = {
  }
}

export class GetVideoConversionLogsResponse extends jspb.Message {
  getLogsList(): Array<VideoConversionLog>;
  setLogsList(value: Array<VideoConversionLog>): GetVideoConversionLogsResponse;
  clearLogsList(): GetVideoConversionLogsResponse;
  addLogs(value?: VideoConversionLog, index?: number): VideoConversionLog;

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

export namespace GetVideoConversionLogsResponse {
  export type AsObject = {
    logsList: Array<VideoConversionLog.AsObject>,
  }
}

export class GeneratePlaylistRequest extends jspb.Message {
  getDir(): string;
  setDir(value: string): GeneratePlaylistRequest;

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

export namespace GeneratePlaylistRequest {
  export type AsObject = {
    dir: string,
  }
}

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

export namespace GeneratePlaylistResponse {
  export type AsObject = {
  }
}

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

  getFps(): number;
  setFps(value: number): CreateVttFileRequest;

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

export namespace CreateVttFileRequest {
  export type AsObject = {
    path: string,
    fps: number,
  }
}

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

export namespace CreateVttFileResponse {
  export type AsObject = {
  }
}

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

export namespace StopRequest {
  export type AsObject = {
  }
}

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

export namespace StopResponse {
  export type AsObject = {
  }
}