import * as jspb from 'google-protobuf'

import * as google_protobuf_struct_pb from 'google-protobuf/google/protobuf/struct_pb'; // proto import: "google/protobuf/struct.proto"


export class Empty extends jspb.Message {
  serializeBinary(): Uint8Array;
  toObject(includeInstance?: boolean): Empty.AsObject;
  static toObject(includeInstance: boolean, msg: Empty): Empty.AsObject;
  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 = {
  }
}

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

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

  getMode(): number;
  setMode(value: number): FileInfo;

  getModeTime(): number;
  setModeTime(value: number): FileInfo;

  getIsDir(): boolean;
  setIsDir(value: boolean): FileInfo;

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

  getMime(): string;
  setMime(value: string): FileInfo;

  getThumbnail(): string;
  setThumbnail(value: string): FileInfo;

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

  getMetadata(): google_protobuf_struct_pb.Struct | undefined;
  setMetadata(value?: google_protobuf_struct_pb.Struct): FileInfo;
  hasMetadata(): boolean;
  clearMetadata(): FileInfo;

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

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

export namespace FileInfo {
  export type AsObject = {
    name: string,
    size: number,
    mode: number,
    modeTime: number,
    isDir: boolean,
    path: string,
    mime: string,
    thumbnail: string,
    checksum: string,
    metadata?: google_protobuf_struct_pb.Struct.AsObject,
    filesList: Array<FileInfo.AsObject>,
  }
}

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

  getRecursive(): boolean;
  setRecursive(value: boolean): ReadDirRequest;

  getThumbnailwidth(): number;
  setThumbnailwidth(value: number): ReadDirRequest;

  getThumbnailheight(): number;
  setThumbnailheight(value: number): ReadDirRequest;

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

export namespace ReadDirRequest {
  export type AsObject = {
    path: string,
    recursive: boolean,
    thumbnailwidth: number,
    thumbnailheight: number,
  }
}

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

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

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

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

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

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

export namespace CreateDirRequest {
  export type AsObject = {
    path: string,
    name: string,
  }
}

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

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

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

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

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

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

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

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

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

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

  getNewName(): string;
  setNewName(value: string): RenameRequest;

  getOldName(): string;
  setOldName(value: string): RenameRequest;

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

export namespace RenameRequest {
  export type AsObject = {
    path: string,
    newName: string,
    oldName: string,
  }
}

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

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

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

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

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

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

export namespace CopyRequest {
  export type AsObject = {
    path: string,
    filesList: Array<string>,
  }
}

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

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

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

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

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

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

export namespace MoveRequest {
  export type AsObject = {
    path: string,
    filesList: Array<string>,
  }
}

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

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

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

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

  getThumbnailwidth(): number;
  setThumbnailwidth(value: number): GetFileInfoRequest;

  getThumbnailheight(): number;
  setThumbnailheight(value: number): GetFileInfoRequest;

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

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

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

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

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

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

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

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

export class GetFileMetadataResponse extends jspb.Message {
  getResult(): google_protobuf_struct_pb.Struct | undefined;
  setResult(value?: google_protobuf_struct_pb.Struct): GetFileMetadataResponse;
  hasResult(): boolean;
  clearResult(): GetFileMetadataResponse;

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

export namespace GetFileMetadataResponse {
  export type AsObject = {
    result?: google_protobuf_struct_pb.Struct.AsObject,
  }
}

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

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

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

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

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

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

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

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

  getFileCase(): SaveFileRequest.FileCase;

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

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

  export enum FileCase { 
    FILE_NOT_SET = 0,
    PATH = 1,
    DATA = 2,
  }
}

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

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

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

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

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

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

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

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

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

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

  getRecursive(): boolean;
  setRecursive(value: boolean): GetThumbnailsRequest;

  getThumbnailwidth(): number;
  setThumbnailwidth(value: number): GetThumbnailsRequest;

  getThumbnailheight(): number;
  setThumbnailheight(value: number): GetThumbnailsRequest;

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

export namespace GetThumbnailsRequest {
  export type AsObject = {
    path: string,
    recursive: boolean,
    thumbnailwidth: number,
    thumbnailheight: number,
  }
}

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

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

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

export class CreateArchiveRequest extends jspb.Message {
  getPathsList(): Array<string>;
  setPathsList(value: Array<string>): CreateArchiveRequest;
  clearPathsList(): CreateArchiveRequest;
  addPaths(value: string, index?: number): CreateArchiveRequest;

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

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

export namespace CreateArchiveRequest {
  export type AsObject = {
    pathsList: Array<string>,
    name: string,
  }
}

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

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

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

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

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

  getLnk(): string;
  setLnk(value: string): CreateLnkRequest;

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

export namespace CreateLnkRequest {
  export type AsObject = {
    path: string,
    name: string,
    lnk: string,
  }
}

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

export namespace CreateLnkResponse {
  export type AsObject = {
  }
}

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

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

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

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

export namespace AddPublicDirResponse {
  export type AsObject = {
  }
}

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

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

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

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

export namespace RemovePublicDirResponse {
  export type AsObject = {
  }
}

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

export namespace GetPublicDirsRequest {
  export type AsObject = {
  }
}

export class GetPublicDirsResponse extends jspb.Message {
  getDirsList(): Array<string>;
  setDirsList(value: Array<string>): GetPublicDirsResponse;
  clearDirsList(): GetPublicDirsResponse;
  addDirs(value: string, index?: number): GetPublicDirsResponse;

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

export namespace GetPublicDirsResponse {
  export type AsObject = {
    dirsList: Array<string>,
  }
}

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

  getData(): string;
  setData(value: string): WriteExcelFileRequest;

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

export namespace WriteExcelFileRequest {
  export type AsObject = {
    path: string,
    data: string,
  }
}

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

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

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

export class HtmlToPdfRqst extends jspb.Message {
  getHtml(): string;
  setHtml(value: string): HtmlToPdfRqst;

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

export namespace HtmlToPdfRqst {
  export type AsObject = {
    html: string,
  }
}

export class HtmlToPdfResponse extends jspb.Message {
  getPdf(): Uint8Array | string;
  getPdf_asU8(): Uint8Array;
  getPdf_asB64(): string;
  setPdf(value: Uint8Array | string): HtmlToPdfResponse;

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

export namespace HtmlToPdfResponse {
  export type AsObject = {
    pdf: Uint8Array | string,
  }
}

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

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

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

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

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

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

export namespace UploadFileRequest {
  export type AsObject = {
    url: string,
    dest: string,
    name: string,
    domain: string,
    isdir: boolean,
  }
}

export class UploadFileResponse extends jspb.Message {
  getUploaded(): number;
  setUploaded(value: number): UploadFileResponse;

  getTotal(): number;
  setTotal(value: number): UploadFileResponse;

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

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

export namespace UploadFileResponse {
  export type AsObject = {
    uploaded: number,
    total: number,
    info: string,
  }
}

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 = {
  }
}