@lazycatcloud/sdk 0.1.142 → 0.1.144

package/common/filetrans.ts

@@ -0,0 +1,1936 @@
+/* eslint-disable */
+import { grpc } from "@improbable-eng/grpc-web";
+import { BrowserHeaders } from "browser-headers";
+import Long from "long";
+import _m0 from "protobufjs/minimal";
+import { Observable } from "rxjs";
+import { share } from "rxjs/operators";
+import { Empty } from "../google/protobuf/empty";
+import { Timestamp } from "../google/protobuf/timestamp";
+
+/** Task 所有状态 */
+export enum TaskStatus {
+  /** Pending - 等待下载 */
+  Pending = 0,
+  /** Transmitting - 正在下载 */
+  Transmitting = 1,
+  /** Paused - 暂停 */
+  Paused = 2,
+  /** Finished - 已完成 */
+  Finished = 3,
+  /** Failed - 下载失败 */
+  Failed = 4,
+  UNRECOGNIZED = -1,
+}
+
+export function taskStatusFromJSON(object: any): TaskStatus {
+  switch (object) {
+    case 0:
+    case "Pending":
+      return TaskStatus.Pending;
+    case 1:
+    case "Transmitting":
+      return TaskStatus.Transmitting;
+    case 2:
+    case "Paused":
+      return TaskStatus.Paused;
+    case 3:
+    case "Finished":
+      return TaskStatus.Finished;
+    case 4:
+    case "Failed":
+      return TaskStatus.Failed;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return TaskStatus.UNRECOGNIZED;
+  }
+}
+
+export function taskStatusToJSON(object: TaskStatus): string {
+  switch (object) {
+    case TaskStatus.Pending:
+      return "Pending";
+    case TaskStatus.Transmitting:
+      return "Transmitting";
+    case TaskStatus.Paused:
+      return "Paused";
+    case TaskStatus.Finished:
+      return "Finished";
+    case TaskStatus.Failed:
+      return "Failed";
+    case TaskStatus.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+
+export enum QueueStatus {
+  /** Running - 等待下载 */
+  Running = 0,
+  /** Suspend - 已完成 */
+  Suspend = 1,
+  UNRECOGNIZED = -1,
+}
+
+export function queueStatusFromJSON(object: any): QueueStatus {
+  switch (object) {
+    case 0:
+    case "Running":
+      return QueueStatus.Running;
+    case 1:
+    case "Suspend":
+      return QueueStatus.Suspend;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return QueueStatus.UNRECOGNIZED;
+  }
+}
+
+export function queueStatusToJSON(object: QueueStatus): string {
+  switch (object) {
+    case QueueStatus.Running:
+      return "Running";
+    case QueueStatus.Suspend:
+      return "Suspend";
+    case QueueStatus.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+
+export enum MsgAction {
+  Add = 0,
+  Del = 1,
+  UNRECOGNIZED = -1,
+}
+
+export function msgActionFromJSON(object: any): MsgAction {
+  switch (object) {
+    case 0:
+    case "Add":
+      return MsgAction.Add;
+    case 1:
+    case "Del":
+      return MsgAction.Del;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return MsgAction.UNRECOGNIZED;
+  }
+}
+
+export function msgActionToJSON(object: MsgAction): string {
+  switch (object) {
+    case MsgAction.Add:
+      return "Add";
+    case MsgAction.Del:
+      return "Del";
+    case MsgAction.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+
+export interface FileLocation {
+  locationType: FileLocation_FileLocationType;
+  value: string;
+}
+
+export enum FileLocation_FileLocationType {
+  Url = 0,
+  Local = 2,
+  UNRECOGNIZED = -1,
+}
+
+export function fileLocation_FileLocationTypeFromJSON(object: any): FileLocation_FileLocationType {
+  switch (object) {
+    case 0:
+    case "Url":
+      return FileLocation_FileLocationType.Url;
+    case 2:
+    case "Local":
+      return FileLocation_FileLocationType.Local;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return FileLocation_FileLocationType.UNRECOGNIZED;
+  }
+}
+
+export function fileLocation_FileLocationTypeToJSON(object: FileLocation_FileLocationType): string {
+  switch (object) {
+    case FileLocation_FileLocationType.Url:
+      return "Url";
+    case FileLocation_FileLocationType.Local:
+      return "Local";
+    case FileLocation_FileLocationType.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+
+/** TODO 考虑空文件夹 */
+export interface MetaInfo {
+  metaInfo: string;
+}
+
+/** Task创建请求 */
+export interface TaskCreateRequest {
+  /**
+   * src任意http url
+   * https://7e-febf-6026-f14a-a3ec-0.d.heiyu.space:4443/s/files/home/abc.mp4
+   */
+  src:
+    | FileLocation
+    | undefined;
+  /**
+   * app的files相对路径或具备PUT的webdav地址
+   * /home/abc.mp4 or
+   * https://apis.snyht4.heiyu.space/s/files/home/video/abc.mp4
+   */
+  dst:
+    | FileLocation
+    | undefined;
+  /** abc.mp4 */
+  name: string;
+  /** 若queue 需提前创建，（固定前缀id） */
+  queueId: TaskQueueID | undefined;
+  status?: TaskStatus | undefined;
+  metaInfo?: MetaInfo | undefined;
+}
+
+export interface TaskCreateRequests {
+  Requests: TaskCreateRequest[];
+}
+
+/** Task结构体 */
+export interface TaskID {
+  id: string;
+}
+
+export interface TransmitInfo {
+  /** 总大小， 单位为 Byte */
+  total: number;
+  /** 已传输大小， 单位为 Byte */
+  transmitted: number;
+  /** 当前速度， 单位为 Byte/s */
+  speed: number;
+}
+
+export interface Task {
+  id: TaskID | undefined;
+  src: FileLocation | undefined;
+  dst: FileLocation | undefined;
+  fileName: string;
+  mimeType: string;
+  status: TaskStatus;
+  /** 前端请求可以没有大小，返回需要有 */
+  size?: number | undefined;
+  info?: TransmitInfo | undefined;
+  createdAt?: Date | undefined;
+  updatedAt?: Date | undefined;
+  metaInfo?: MetaInfo | undefined;
+}
+
+/** 任务队列TaskQueue设计 */
+export interface TaskQueueConfig {
+  maxParallel: number;
+  maxRatePerFile: number;
+  maxRate: number;
+}
+
+export interface TaskQueueID {
+  id: string;
+}
+
+export interface TaskQueueConfigReq {
+  id: TaskQueueID | undefined;
+  config: TaskQueueConfig | undefined;
+}
+
+/** TODO 考虑暂停状态问题 */
+export interface TaskQueue {
+  id: TaskQueueID | undefined;
+  status: QueueStatus;
+  tasks: Task[];
+}
+
+export interface FileTaskQueueResp {
+  id: TaskQueueID | undefined;
+  status: QueueStatus;
+  tasks: Task[];
+}
+
+export interface TaskQueueQueryReq {
+  id: TaskQueueID | undefined;
+  status: TaskStatus[];
+}
+
+export interface QueueMessageResp {
+  id: TaskID | undefined;
+  task: Task | undefined;
+  action: MsgAction;
+  status: TaskStatus;
+  errorMessage?: string | undefined;
+}
+
+export interface TaskQueueListResp {
+  ids: TaskQueueID[];
+}
+
+function createBaseFileLocation(): FileLocation {
+  return { locationType: 0, value: "" };
+}
+
+export const FileLocation = {
+  encode(message: FileLocation, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.locationType !== 0) {
+      writer.uint32(8).int32(message.locationType);
+    }
+    if (message.value !== "") {
+      writer.uint32(18).string(message.value);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): FileLocation {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseFileLocation();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.locationType = reader.int32() as any;
+          break;
+        case 2:
+          message.value = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): FileLocation {
+    return {
+      locationType: isSet(object.locationType) ? fileLocation_FileLocationTypeFromJSON(object.locationType) : 0,
+      value: isSet(object.value) ? String(object.value) : "",
+    };
+  },
+
+  toJSON(message: FileLocation): unknown {
+    const obj: any = {};
+    message.locationType !== undefined &&
+      (obj.locationType = fileLocation_FileLocationTypeToJSON(message.locationType));
+    message.value !== undefined && (obj.value = message.value);
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<FileLocation>, I>>(object: I): FileLocation {
+    const message = createBaseFileLocation();
+    message.locationType = object.locationType ?? 0;
+    message.value = object.value ?? "";
+    return message;
+  },
+};
+
+function createBaseMetaInfo(): MetaInfo {
+  return { metaInfo: "" };
+}
+
+export const MetaInfo = {
+  encode(message: MetaInfo, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.metaInfo !== "") {
+      writer.uint32(10).string(message.metaInfo);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): MetaInfo {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseMetaInfo();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.metaInfo = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): MetaInfo {
+    return { metaInfo: isSet(object.metaInfo) ? String(object.metaInfo) : "" };
+  },
+
+  toJSON(message: MetaInfo): unknown {
+    const obj: any = {};
+    message.metaInfo !== undefined && (obj.metaInfo = message.metaInfo);
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<MetaInfo>, I>>(object: I): MetaInfo {
+    const message = createBaseMetaInfo();
+    message.metaInfo = object.metaInfo ?? "";
+    return message;
+  },
+};
+
+function createBaseTaskCreateRequest(): TaskCreateRequest {
+  return { src: undefined, dst: undefined, name: "", queueId: undefined, status: undefined, metaInfo: undefined };
+}
+
+export const TaskCreateRequest = {
+  encode(message: TaskCreateRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.src !== undefined) {
+      FileLocation.encode(message.src, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.dst !== undefined) {
+      FileLocation.encode(message.dst, writer.uint32(18).fork()).ldelim();
+    }
+    if (message.name !== "") {
+      writer.uint32(26).string(message.name);
+    }
+    if (message.queueId !== undefined) {
+      TaskQueueID.encode(message.queueId, writer.uint32(34).fork()).ldelim();
+    }
+    if (message.status !== undefined) {
+      writer.uint32(40).int32(message.status);
+    }
+    if (message.metaInfo !== undefined) {
+      MetaInfo.encode(message.metaInfo, writer.uint32(50).fork()).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): TaskCreateRequest {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTaskCreateRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.src = FileLocation.decode(reader, reader.uint32());
+          break;
+        case 2:
+          message.dst = FileLocation.decode(reader, reader.uint32());
+          break;
+        case 3:
+          message.name = reader.string();
+          break;
+        case 4:
+          message.queueId = TaskQueueID.decode(reader, reader.uint32());
+          break;
+        case 5:
+          message.status = reader.int32() as any;
+          break;
+        case 6:
+          message.metaInfo = MetaInfo.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): TaskCreateRequest {
+    return {
+      src: isSet(object.src) ? FileLocation.fromJSON(object.src) : undefined,
+      dst: isSet(object.dst) ? FileLocation.fromJSON(object.dst) : undefined,
+      name: isSet(object.name) ? String(object.name) : "",
+      queueId: isSet(object.queueId) ? TaskQueueID.fromJSON(object.queueId) : undefined,
+      status: isSet(object.status) ? taskStatusFromJSON(object.status) : undefined,
+      metaInfo: isSet(object.metaInfo) ? MetaInfo.fromJSON(object.metaInfo) : undefined,
+    };
+  },
+
+  toJSON(message: TaskCreateRequest): unknown {
+    const obj: any = {};
+    message.src !== undefined && (obj.src = message.src ? FileLocation.toJSON(message.src) : undefined);
+    message.dst !== undefined && (obj.dst = message.dst ? FileLocation.toJSON(message.dst) : undefined);
+    message.name !== undefined && (obj.name = message.name);
+    message.queueId !== undefined && (obj.queueId = message.queueId ? TaskQueueID.toJSON(message.queueId) : undefined);
+    message.status !== undefined &&
+      (obj.status = message.status !== undefined ? taskStatusToJSON(message.status) : undefined);
+    message.metaInfo !== undefined && (obj.metaInfo = message.metaInfo ? MetaInfo.toJSON(message.metaInfo) : undefined);
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<TaskCreateRequest>, I>>(object: I): TaskCreateRequest {
+    const message = createBaseTaskCreateRequest();
+    message.src = (object.src !== undefined && object.src !== null) ? FileLocation.fromPartial(object.src) : undefined;
+    message.dst = (object.dst !== undefined && object.dst !== null) ? FileLocation.fromPartial(object.dst) : undefined;
+    message.name = object.name ?? "";
+    message.queueId = (object.queueId !== undefined && object.queueId !== null)
+      ? TaskQueueID.fromPartial(object.queueId)
+      : undefined;
+    message.status = object.status ?? undefined;
+    message.metaInfo = (object.metaInfo !== undefined && object.metaInfo !== null)
+      ? MetaInfo.fromPartial(object.metaInfo)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseTaskCreateRequests(): TaskCreateRequests {
+  return { Requests: [] };
+}
+
+export const TaskCreateRequests = {
+  encode(message: TaskCreateRequests, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.Requests) {
+      TaskCreateRequest.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): TaskCreateRequests {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTaskCreateRequests();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.Requests.push(TaskCreateRequest.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): TaskCreateRequests {
+    return {
+      Requests: Array.isArray(object?.Requests) ? object.Requests.map((e: any) => TaskCreateRequest.fromJSON(e)) : [],
+    };
+  },
+
+  toJSON(message: TaskCreateRequests): unknown {
+    const obj: any = {};
+    if (message.Requests) {
+      obj.Requests = message.Requests.map((e) => e ? TaskCreateRequest.toJSON(e) : undefined);
+    } else {
+      obj.Requests = [];
+    }
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<TaskCreateRequests>, I>>(object: I): TaskCreateRequests {
+    const message = createBaseTaskCreateRequests();
+    message.Requests = object.Requests?.map((e) => TaskCreateRequest.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseTaskID(): TaskID {
+  return { id: "" };
+}
+
+export const TaskID = {
+  encode(message: TaskID, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.id !== "") {
+      writer.uint32(10).string(message.id);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): TaskID {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTaskID();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.id = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): TaskID {
+    return { id: isSet(object.id) ? String(object.id) : "" };
+  },
+
+  toJSON(message: TaskID): unknown {
+    const obj: any = {};
+    message.id !== undefined && (obj.id = message.id);
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<TaskID>, I>>(object: I): TaskID {
+    const message = createBaseTaskID();
+    message.id = object.id ?? "";
+    return message;
+  },
+};
+
+function createBaseTransmitInfo(): TransmitInfo {
+  return { total: 0, transmitted: 0, speed: 0 };
+}
+
+export const TransmitInfo = {
+  encode(message: TransmitInfo, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.total !== 0) {
+      writer.uint32(8).int64(message.total);
+    }
+    if (message.transmitted !== 0) {
+      writer.uint32(16).int64(message.transmitted);
+    }
+    if (message.speed !== 0) {
+      writer.uint32(24).int64(message.speed);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): TransmitInfo {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTransmitInfo();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.total = longToNumber(reader.int64() as Long);
+          break;
+        case 2:
+          message.transmitted = longToNumber(reader.int64() as Long);
+          break;
+        case 3:
+          message.speed = longToNumber(reader.int64() as Long);
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): TransmitInfo {
+    return {
+      total: isSet(object.total) ? Number(object.total) : 0,
+      transmitted: isSet(object.transmitted) ? Number(object.transmitted) : 0,
+      speed: isSet(object.speed) ? Number(object.speed) : 0,
+    };
+  },
+
+  toJSON(message: TransmitInfo): unknown {
+    const obj: any = {};
+    message.total !== undefined && (obj.total = Math.round(message.total));
+    message.transmitted !== undefined && (obj.transmitted = Math.round(message.transmitted));
+    message.speed !== undefined && (obj.speed = Math.round(message.speed));
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<TransmitInfo>, I>>(object: I): TransmitInfo {
+    const message = createBaseTransmitInfo();
+    message.total = object.total ?? 0;
+    message.transmitted = object.transmitted ?? 0;
+    message.speed = object.speed ?? 0;
+    return message;
+  },
+};
+
+function createBaseTask(): Task {
+  return {
+    id: undefined,
+    src: undefined,
+    dst: undefined,
+    fileName: "",
+    mimeType: "",
+    status: 0,
+    size: undefined,
+    info: undefined,
+    createdAt: undefined,
+    updatedAt: undefined,
+    metaInfo: undefined,
+  };
+}
+
+export const Task = {
+  encode(message: Task, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.id !== undefined) {
+      TaskID.encode(message.id, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.src !== undefined) {
+      FileLocation.encode(message.src, writer.uint32(18).fork()).ldelim();
+    }
+    if (message.dst !== undefined) {
+      FileLocation.encode(message.dst, writer.uint32(26).fork()).ldelim();
+    }
+    if (message.fileName !== "") {
+      writer.uint32(34).string(message.fileName);
+    }
+    if (message.mimeType !== "") {
+      writer.uint32(42).string(message.mimeType);
+    }
+    if (message.status !== 0) {
+      writer.uint32(48).int32(message.status);
+    }
+    if (message.size !== undefined) {
+      writer.uint32(56).int64(message.size);
+    }
+    if (message.info !== undefined) {
+      TransmitInfo.encode(message.info, writer.uint32(66).fork()).ldelim();
+    }
+    if (message.createdAt !== undefined) {
+      Timestamp.encode(toTimestamp(message.createdAt), writer.uint32(74).fork()).ldelim();
+    }
+    if (message.updatedAt !== undefined) {
+      Timestamp.encode(toTimestamp(message.updatedAt), writer.uint32(82).fork()).ldelim();
+    }
+    if (message.metaInfo !== undefined) {
+      MetaInfo.encode(message.metaInfo, writer.uint32(90).fork()).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): Task {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTask();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.id = TaskID.decode(reader, reader.uint32());
+          break;
+        case 2:
+          message.src = FileLocation.decode(reader, reader.uint32());
+          break;
+        case 3:
+          message.dst = FileLocation.decode(reader, reader.uint32());
+          break;
+        case 4:
+          message.fileName = reader.string();
+          break;
+        case 5:
+          message.mimeType = reader.string();
+          break;
+        case 6:
+          message.status = reader.int32() as any;
+          break;
+        case 7:
+          message.size = longToNumber(reader.int64() as Long);
+          break;
+        case 8:
+          message.info = TransmitInfo.decode(reader, reader.uint32());
+          break;
+        case 9:
+          message.createdAt = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+          break;
+        case 10:
+          message.updatedAt = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+          break;
+        case 11:
+          message.metaInfo = MetaInfo.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): Task {
+    return {
+      id: isSet(object.id) ? TaskID.fromJSON(object.id) : undefined,
+      src: isSet(object.src) ? FileLocation.fromJSON(object.src) : undefined,
+      dst: isSet(object.dst) ? FileLocation.fromJSON(object.dst) : undefined,
+      fileName: isSet(object.fileName) ? String(object.fileName) : "",
+      mimeType: isSet(object.mimeType) ? String(object.mimeType) : "",
+      status: isSet(object.status) ? taskStatusFromJSON(object.status) : 0,
+      size: isSet(object.size) ? Number(object.size) : undefined,
+      info: isSet(object.info) ? TransmitInfo.fromJSON(object.info) : undefined,
+      createdAt: isSet(object.createdAt) ? fromJsonTimestamp(object.createdAt) : undefined,
+      updatedAt: isSet(object.updatedAt) ? fromJsonTimestamp(object.updatedAt) : undefined,
+      metaInfo: isSet(object.metaInfo) ? MetaInfo.fromJSON(object.metaInfo) : undefined,
+    };
+  },
+
+  toJSON(message: Task): unknown {
+    const obj: any = {};
+    message.id !== undefined && (obj.id = message.id ? TaskID.toJSON(message.id) : undefined);
+    message.src !== undefined && (obj.src = message.src ? FileLocation.toJSON(message.src) : undefined);
+    message.dst !== undefined && (obj.dst = message.dst ? FileLocation.toJSON(message.dst) : undefined);
+    message.fileName !== undefined && (obj.fileName = message.fileName);
+    message.mimeType !== undefined && (obj.mimeType = message.mimeType);
+    message.status !== undefined && (obj.status = taskStatusToJSON(message.status));
+    message.size !== undefined && (obj.size = Math.round(message.size));
+    message.info !== undefined && (obj.info = message.info ? TransmitInfo.toJSON(message.info) : undefined);
+    message.createdAt !== undefined && (obj.createdAt = message.createdAt.toISOString());
+    message.updatedAt !== undefined && (obj.updatedAt = message.updatedAt.toISOString());
+    message.metaInfo !== undefined && (obj.metaInfo = message.metaInfo ? MetaInfo.toJSON(message.metaInfo) : undefined);
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<Task>, I>>(object: I): Task {
+    const message = createBaseTask();
+    message.id = (object.id !== undefined && object.id !== null) ? TaskID.fromPartial(object.id) : undefined;
+    message.src = (object.src !== undefined && object.src !== null) ? FileLocation.fromPartial(object.src) : undefined;
+    message.dst = (object.dst !== undefined && object.dst !== null) ? FileLocation.fromPartial(object.dst) : undefined;
+    message.fileName = object.fileName ?? "";
+    message.mimeType = object.mimeType ?? "";
+    message.status = object.status ?? 0;
+    message.size = object.size ?? undefined;
+    message.info = (object.info !== undefined && object.info !== null)
+      ? TransmitInfo.fromPartial(object.info)
+      : undefined;
+    message.createdAt = object.createdAt ?? undefined;
+    message.updatedAt = object.updatedAt ?? undefined;
+    message.metaInfo = (object.metaInfo !== undefined && object.metaInfo !== null)
+      ? MetaInfo.fromPartial(object.metaInfo)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseTaskQueueConfig(): TaskQueueConfig {
+  return { maxParallel: 0, maxRatePerFile: 0, maxRate: 0 };
+}
+
+export const TaskQueueConfig = {
+  encode(message: TaskQueueConfig, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.maxParallel !== 0) {
+      writer.uint32(8).int64(message.maxParallel);
+    }
+    if (message.maxRatePerFile !== 0) {
+      writer.uint32(16).int64(message.maxRatePerFile);
+    }
+    if (message.maxRate !== 0) {
+      writer.uint32(24).int64(message.maxRate);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): TaskQueueConfig {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTaskQueueConfig();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.maxParallel = longToNumber(reader.int64() as Long);
+          break;
+        case 2:
+          message.maxRatePerFile = longToNumber(reader.int64() as Long);
+          break;
+        case 3:
+          message.maxRate = longToNumber(reader.int64() as Long);
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): TaskQueueConfig {
+    return {
+      maxParallel: isSet(object.maxParallel) ? Number(object.maxParallel) : 0,
+      maxRatePerFile: isSet(object.maxRatePerFile) ? Number(object.maxRatePerFile) : 0,
+      maxRate: isSet(object.maxRate) ? Number(object.maxRate) : 0,
+    };
+  },
+
+  toJSON(message: TaskQueueConfig): unknown {
+    const obj: any = {};
+    message.maxParallel !== undefined && (obj.maxParallel = Math.round(message.maxParallel));
+    message.maxRatePerFile !== undefined && (obj.maxRatePerFile = Math.round(message.maxRatePerFile));
+    message.maxRate !== undefined && (obj.maxRate = Math.round(message.maxRate));
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<TaskQueueConfig>, I>>(object: I): TaskQueueConfig {
+    const message = createBaseTaskQueueConfig();
+    message.maxParallel = object.maxParallel ?? 0;
+    message.maxRatePerFile = object.maxRatePerFile ?? 0;
+    message.maxRate = object.maxRate ?? 0;
+    return message;
+  },
+};
+
+function createBaseTaskQueueID(): TaskQueueID {
+  return { id: "" };
+}
+
+export const TaskQueueID = {
+  encode(message: TaskQueueID, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.id !== "") {
+      writer.uint32(10).string(message.id);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): TaskQueueID {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTaskQueueID();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.id = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): TaskQueueID {
+    return { id: isSet(object.id) ? String(object.id) : "" };
+  },
+
+  toJSON(message: TaskQueueID): unknown {
+    const obj: any = {};
+    message.id !== undefined && (obj.id = message.id);
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<TaskQueueID>, I>>(object: I): TaskQueueID {
+    const message = createBaseTaskQueueID();
+    message.id = object.id ?? "";
+    return message;
+  },
+};
+
+function createBaseTaskQueueConfigReq(): TaskQueueConfigReq {
+  return { id: undefined, config: undefined };
+}
+
+export const TaskQueueConfigReq = {
+  encode(message: TaskQueueConfigReq, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.id !== undefined) {
+      TaskQueueID.encode(message.id, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.config !== undefined) {
+      TaskQueueConfig.encode(message.config, writer.uint32(18).fork()).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): TaskQueueConfigReq {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTaskQueueConfigReq();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.id = TaskQueueID.decode(reader, reader.uint32());
+          break;
+        case 2:
+          message.config = TaskQueueConfig.decode(reader, reader.uint32());
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): TaskQueueConfigReq {
+    return {
+      id: isSet(object.id) ? TaskQueueID.fromJSON(object.id) : undefined,
+      config: isSet(object.config) ? TaskQueueConfig.fromJSON(object.config) : undefined,
+    };
+  },
+
+  toJSON(message: TaskQueueConfigReq): unknown {
+    const obj: any = {};
+    message.id !== undefined && (obj.id = message.id ? TaskQueueID.toJSON(message.id) : undefined);
+    message.config !== undefined && (obj.config = message.config ? TaskQueueConfig.toJSON(message.config) : undefined);
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<TaskQueueConfigReq>, I>>(object: I): TaskQueueConfigReq {
+    const message = createBaseTaskQueueConfigReq();
+    message.id = (object.id !== undefined && object.id !== null) ? TaskQueueID.fromPartial(object.id) : undefined;
+    message.config = (object.config !== undefined && object.config !== null)
+      ? TaskQueueConfig.fromPartial(object.config)
+      : undefined;
+    return message;
+  },
+};
+
+function createBaseTaskQueue(): TaskQueue {
+  return { id: undefined, status: 0, tasks: [] };
+}
+
+export const TaskQueue = {
+  encode(message: TaskQueue, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.id !== undefined) {
+      TaskQueueID.encode(message.id, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.status !== 0) {
+      writer.uint32(16).int32(message.status);
+    }
+    for (const v of message.tasks) {
+      Task.encode(v!, writer.uint32(26).fork()).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): TaskQueue {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTaskQueue();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.id = TaskQueueID.decode(reader, reader.uint32());
+          break;
+        case 2:
+          message.status = reader.int32() as any;
+          break;
+        case 3:
+          message.tasks.push(Task.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): TaskQueue {
+    return {
+      id: isSet(object.id) ? TaskQueueID.fromJSON(object.id) : undefined,
+      status: isSet(object.status) ? queueStatusFromJSON(object.status) : 0,
+      tasks: Array.isArray(object?.tasks) ? object.tasks.map((e: any) => Task.fromJSON(e)) : [],
+    };
+  },
+
+  toJSON(message: TaskQueue): unknown {
+    const obj: any = {};
+    message.id !== undefined && (obj.id = message.id ? TaskQueueID.toJSON(message.id) : undefined);
+    message.status !== undefined && (obj.status = queueStatusToJSON(message.status));
+    if (message.tasks) {
+      obj.tasks = message.tasks.map((e) => e ? Task.toJSON(e) : undefined);
+    } else {
+      obj.tasks = [];
+    }
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<TaskQueue>, I>>(object: I): TaskQueue {
+    const message = createBaseTaskQueue();
+    message.id = (object.id !== undefined && object.id !== null) ? TaskQueueID.fromPartial(object.id) : undefined;
+    message.status = object.status ?? 0;
+    message.tasks = object.tasks?.map((e) => Task.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseFileTaskQueueResp(): FileTaskQueueResp {
+  return { id: undefined, status: 0, tasks: [] };
+}
+
+export const FileTaskQueueResp = {
+  encode(message: FileTaskQueueResp, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.id !== undefined) {
+      TaskQueueID.encode(message.id, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.status !== 0) {
+      writer.uint32(16).int32(message.status);
+    }
+    for (const v of message.tasks) {
+      Task.encode(v!, writer.uint32(26).fork()).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): FileTaskQueueResp {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseFileTaskQueueResp();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.id = TaskQueueID.decode(reader, reader.uint32());
+          break;
+        case 2:
+          message.status = reader.int32() as any;
+          break;
+        case 3:
+          message.tasks.push(Task.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): FileTaskQueueResp {
+    return {
+      id: isSet(object.id) ? TaskQueueID.fromJSON(object.id) : undefined,
+      status: isSet(object.status) ? queueStatusFromJSON(object.status) : 0,
+      tasks: Array.isArray(object?.tasks) ? object.tasks.map((e: any) => Task.fromJSON(e)) : [],
+    };
+  },
+
+  toJSON(message: FileTaskQueueResp): unknown {
+    const obj: any = {};
+    message.id !== undefined && (obj.id = message.id ? TaskQueueID.toJSON(message.id) : undefined);
+    message.status !== undefined && (obj.status = queueStatusToJSON(message.status));
+    if (message.tasks) {
+      obj.tasks = message.tasks.map((e) => e ? Task.toJSON(e) : undefined);
+    } else {
+      obj.tasks = [];
+    }
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<FileTaskQueueResp>, I>>(object: I): FileTaskQueueResp {
+    const message = createBaseFileTaskQueueResp();
+    message.id = (object.id !== undefined && object.id !== null) ? TaskQueueID.fromPartial(object.id) : undefined;
+    message.status = object.status ?? 0;
+    message.tasks = object.tasks?.map((e) => Task.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseTaskQueueQueryReq(): TaskQueueQueryReq {
+  return { id: undefined, status: [] };
+}
+
+export const TaskQueueQueryReq = {
+  encode(message: TaskQueueQueryReq, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.id !== undefined) {
+      TaskQueueID.encode(message.id, writer.uint32(10).fork()).ldelim();
+    }
+    writer.uint32(18).fork();
+    for (const v of message.status) {
+      writer.int32(v);
+    }
+    writer.ldelim();
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): TaskQueueQueryReq {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTaskQueueQueryReq();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.id = TaskQueueID.decode(reader, reader.uint32());
+          break;
+        case 2:
+          if ((tag & 7) === 2) {
+            const end2 = reader.uint32() + reader.pos;
+            while (reader.pos < end2) {
+              message.status.push(reader.int32() as any);
+            }
+          } else {
+            message.status.push(reader.int32() as any);
+          }
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): TaskQueueQueryReq {
+    return {
+      id: isSet(object.id) ? TaskQueueID.fromJSON(object.id) : undefined,
+      status: Array.isArray(object?.status) ? object.status.map((e: any) => taskStatusFromJSON(e)) : [],
+    };
+  },
+
+  toJSON(message: TaskQueueQueryReq): unknown {
+    const obj: any = {};
+    message.id !== undefined && (obj.id = message.id ? TaskQueueID.toJSON(message.id) : undefined);
+    if (message.status) {
+      obj.status = message.status.map((e) => taskStatusToJSON(e));
+    } else {
+      obj.status = [];
+    }
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<TaskQueueQueryReq>, I>>(object: I): TaskQueueQueryReq {
+    const message = createBaseTaskQueueQueryReq();
+    message.id = (object.id !== undefined && object.id !== null) ? TaskQueueID.fromPartial(object.id) : undefined;
+    message.status = object.status?.map((e) => e) || [];
+    return message;
+  },
+};
+
+function createBaseQueueMessageResp(): QueueMessageResp {
+  return { id: undefined, task: undefined, action: 0, status: 0, errorMessage: undefined };
+}
+
+export const QueueMessageResp = {
+  encode(message: QueueMessageResp, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.id !== undefined) {
+      TaskID.encode(message.id, writer.uint32(10).fork()).ldelim();
+    }
+    if (message.task !== undefined) {
+      Task.encode(message.task, writer.uint32(18).fork()).ldelim();
+    }
+    if (message.action !== 0) {
+      writer.uint32(24).int32(message.action);
+    }
+    if (message.status !== 0) {
+      writer.uint32(32).int32(message.status);
+    }
+    if (message.errorMessage !== undefined) {
+      writer.uint32(42).string(message.errorMessage);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): QueueMessageResp {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueueMessageResp();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.id = TaskID.decode(reader, reader.uint32());
+          break;
+        case 2:
+          message.task = Task.decode(reader, reader.uint32());
+          break;
+        case 3:
+          message.action = reader.int32() as any;
+          break;
+        case 4:
+          message.status = reader.int32() as any;
+          break;
+        case 5:
+          message.errorMessage = reader.string();
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): QueueMessageResp {
+    return {
+      id: isSet(object.id) ? TaskID.fromJSON(object.id) : undefined,
+      task: isSet(object.task) ? Task.fromJSON(object.task) : undefined,
+      action: isSet(object.action) ? msgActionFromJSON(object.action) : 0,
+      status: isSet(object.status) ? taskStatusFromJSON(object.status) : 0,
+      errorMessage: isSet(object.errorMessage) ? String(object.errorMessage) : undefined,
+    };
+  },
+
+  toJSON(message: QueueMessageResp): unknown {
+    const obj: any = {};
+    message.id !== undefined && (obj.id = message.id ? TaskID.toJSON(message.id) : undefined);
+    message.task !== undefined && (obj.task = message.task ? Task.toJSON(message.task) : undefined);
+    message.action !== undefined && (obj.action = msgActionToJSON(message.action));
+    message.status !== undefined && (obj.status = taskStatusToJSON(message.status));
+    message.errorMessage !== undefined && (obj.errorMessage = message.errorMessage);
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<QueueMessageResp>, I>>(object: I): QueueMessageResp {
+    const message = createBaseQueueMessageResp();
+    message.id = (object.id !== undefined && object.id !== null) ? TaskID.fromPartial(object.id) : undefined;
+    message.task = (object.task !== undefined && object.task !== null) ? Task.fromPartial(object.task) : undefined;
+    message.action = object.action ?? 0;
+    message.status = object.status ?? 0;
+    message.errorMessage = object.errorMessage ?? undefined;
+    return message;
+  },
+};
+
+function createBaseTaskQueueListResp(): TaskQueueListResp {
+  return { ids: [] };
+}
+
+export const TaskQueueListResp = {
+  encode(message: TaskQueueListResp, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    for (const v of message.ids) {
+      TaskQueueID.encode(v!, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): TaskQueueListResp {
+    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTaskQueueListResp();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          message.ids.push(TaskQueueID.decode(reader, reader.uint32()));
+          break;
+        default:
+          reader.skipType(tag & 7);
+          break;
+      }
+    }
+    return message;
+  },
+
+  fromJSON(object: any): TaskQueueListResp {
+    return { ids: Array.isArray(object?.ids) ? object.ids.map((e: any) => TaskQueueID.fromJSON(e)) : [] };
+  },
+
+  toJSON(message: TaskQueueListResp): unknown {
+    const obj: any = {};
+    if (message.ids) {
+      obj.ids = message.ids.map((e) => e ? TaskQueueID.toJSON(e) : undefined);
+    } else {
+      obj.ids = [];
+    }
+    return obj;
+  },
+
+  fromPartial<I extends Exact<DeepPartial<TaskQueueListResp>, I>>(object: I): TaskQueueListResp {
+    const message = createBaseTaskQueueListResp();
+    message.ids = object.ids?.map((e) => TaskQueueID.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+/** Task status */
+export interface FileTransferService {
+  /** 创建队列 */
+  CreateQueue(request: DeepPartial<TaskQueueID>, metadata?: grpc.Metadata): Promise<FileTaskQueueResp>;
+  /** 列出所有 QueueID */
+  ListQueue(request: DeepPartial<Empty>, metadata?: grpc.Metadata): Promise<TaskQueueListResp>;
+  /** 通过队列的 ID 和 Status 获取任务列表 */
+  QueryQueue(request: DeepPartial<TaskQueueQueryReq>, metadata?: grpc.Metadata): Observable<Task>;
+  /** 通过队列的 ID 和 Status 清除任务 */
+  ClearQueue(request: DeepPartial<TaskQueueQueryReq>, metadata?: grpc.Metadata): Promise<Empty>;
+  /** 根据队列 ID 设置队列的速率并发等设置 */
+  ConfigQueue(request: DeepPartial<TaskQueueConfigReq>, metadata?: grpc.Metadata): Promise<Empty>;
+  /** 根据队列 ID 暂停队列 */
+  PauseQueue(request: DeepPartial<TaskQueueID>, metadata?: grpc.Metadata): Promise<Empty>;
+  /** 根据队列 ID 开始队列 */
+  StartQuque(request: DeepPartial<TaskQueueID>, metadata?: grpc.Metadata): Promise<Empty>;
+  /** 根据队列 ID 获取队列动态信息（比如 pending 状态的增加了 task1） */
+  QueryQueueMessage(request: DeepPartial<TaskQueueQueryReq>, metadata?: grpc.Metadata): Observable<QueueMessageResp>;
+  /** 暂时不支持创建Task时创建任务，需要提前创建好任务。queue_id不存在则报错 */
+  CreateTask(request: DeepPartial<TaskCreateRequest>, metadata?: grpc.Metadata): Promise<Task>;
+  CreateTasks(request: DeepPartial<TaskCreateRequests>, metadata?: grpc.Metadata): Observable<Task>;
+  /** 根据 ID 获取单个任务状态 */
+  QueryTask(request: DeepPartial<TaskID>, metadata?: grpc.Metadata): Observable<Task>;
+  /** 根据 ID 开始单个任务 */
+  ResumeTask(request: DeepPartial<TaskID>, metadata?: grpc.Metadata): Promise<Empty>;
+  /** 根据 ID 暂停单个任务 */
+  PauseTask(request: DeepPartial<TaskID>, metadata?: grpc.Metadata): Promise<Empty>;
+  /** 根据 ID 删除单个任务 */
+  DeleteTask(request: DeepPartial<TaskID>, metadata?: grpc.Metadata): Promise<Empty>;
+}
+
+export class FileTransferServiceClientImpl implements FileTransferService {
+  private readonly rpc: Rpc;
+
+  constructor(rpc: Rpc) {
+    this.rpc = rpc;
+    this.CreateQueue = this.CreateQueue.bind(this);
+    this.ListQueue = this.ListQueue.bind(this);
+    this.QueryQueue = this.QueryQueue.bind(this);
+    this.ClearQueue = this.ClearQueue.bind(this);
+    this.ConfigQueue = this.ConfigQueue.bind(this);
+    this.PauseQueue = this.PauseQueue.bind(this);
+    this.StartQuque = this.StartQuque.bind(this);
+    this.QueryQueueMessage = this.QueryQueueMessage.bind(this);
+    this.CreateTask = this.CreateTask.bind(this);
+    this.CreateTasks = this.CreateTasks.bind(this);
+    this.QueryTask = this.QueryTask.bind(this);
+    this.ResumeTask = this.ResumeTask.bind(this);
+    this.PauseTask = this.PauseTask.bind(this);
+    this.DeleteTask = this.DeleteTask.bind(this);
+  }
+
+  CreateQueue(request: DeepPartial<TaskQueueID>, metadata?: grpc.Metadata): Promise<FileTaskQueueResp> {
+    return this.rpc.unary(FileTransferServiceCreateQueueDesc, TaskQueueID.fromPartial(request), metadata);
+  }
+
+  ListQueue(request: DeepPartial<Empty>, metadata?: grpc.Metadata): Promise<TaskQueueListResp> {
+    return this.rpc.unary(FileTransferServiceListQueueDesc, Empty.fromPartial(request), metadata);
+  }
+
+  QueryQueue(request: DeepPartial<TaskQueueQueryReq>, metadata?: grpc.Metadata): Observable<Task> {
+    return this.rpc.invoke(FileTransferServiceQueryQueueDesc, TaskQueueQueryReq.fromPartial(request), metadata);
+  }
+
+  ClearQueue(request: DeepPartial<TaskQueueQueryReq>, metadata?: grpc.Metadata): Promise<Empty> {
+    return this.rpc.unary(FileTransferServiceClearQueueDesc, TaskQueueQueryReq.fromPartial(request), metadata);
+  }
+
+  ConfigQueue(request: DeepPartial<TaskQueueConfigReq>, metadata?: grpc.Metadata): Promise<Empty> {
+    return this.rpc.unary(FileTransferServiceConfigQueueDesc, TaskQueueConfigReq.fromPartial(request), metadata);
+  }
+
+  PauseQueue(request: DeepPartial<TaskQueueID>, metadata?: grpc.Metadata): Promise<Empty> {
+    return this.rpc.unary(FileTransferServicePauseQueueDesc, TaskQueueID.fromPartial(request), metadata);
+  }
+
+  StartQuque(request: DeepPartial<TaskQueueID>, metadata?: grpc.Metadata): Promise<Empty> {
+    return this.rpc.unary(FileTransferServiceStartQuqueDesc, TaskQueueID.fromPartial(request), metadata);
+  }
+
+  QueryQueueMessage(request: DeepPartial<TaskQueueQueryReq>, metadata?: grpc.Metadata): Observable<QueueMessageResp> {
+    return this.rpc.invoke(FileTransferServiceQueryQueueMessageDesc, TaskQueueQueryReq.fromPartial(request), metadata);
+  }
+
+  CreateTask(request: DeepPartial<TaskCreateRequest>, metadata?: grpc.Metadata): Promise<Task> {
+    return this.rpc.unary(FileTransferServiceCreateTaskDesc, TaskCreateRequest.fromPartial(request), metadata);
+  }
+
+  CreateTasks(request: DeepPartial<TaskCreateRequests>, metadata?: grpc.Metadata): Observable<Task> {
+    return this.rpc.invoke(FileTransferServiceCreateTasksDesc, TaskCreateRequests.fromPartial(request), metadata);
+  }
+
+  QueryTask(request: DeepPartial<TaskID>, metadata?: grpc.Metadata): Observable<Task> {
+    return this.rpc.invoke(FileTransferServiceQueryTaskDesc, TaskID.fromPartial(request), metadata);
+  }
+
+  ResumeTask(request: DeepPartial<TaskID>, metadata?: grpc.Metadata): Promise<Empty> {
+    return this.rpc.unary(FileTransferServiceResumeTaskDesc, TaskID.fromPartial(request), metadata);
+  }
+
+  PauseTask(request: DeepPartial<TaskID>, metadata?: grpc.Metadata): Promise<Empty> {
+    return this.rpc.unary(FileTransferServicePauseTaskDesc, TaskID.fromPartial(request), metadata);
+  }
+
+  DeleteTask(request: DeepPartial<TaskID>, metadata?: grpc.Metadata): Promise<Empty> {
+    return this.rpc.unary(FileTransferServiceDeleteTaskDesc, TaskID.fromPartial(request), metadata);
+  }
+}
+
+export const FileTransferServiceDesc = { serviceName: "cloud.lazycat.apis.common.FileTransferService" };
+
+export const FileTransferServiceCreateQueueDesc: UnaryMethodDefinitionish = {
+  methodName: "CreateQueue",
+  service: FileTransferServiceDesc,
+  requestStream: false,
+  responseStream: false,
+  requestType: {
+    serializeBinary() {
+      return TaskQueueID.encode(this).finish();
+    },
+  } as any,
+  responseType: {
+    deserializeBinary(data: Uint8Array) {
+      return {
+        ...FileTaskQueueResp.decode(data),
+        toObject() {
+          return this;
+        },
+      };
+    },
+  } as any,
+};
+
+export const FileTransferServiceListQueueDesc: UnaryMethodDefinitionish = {
+  methodName: "ListQueue",
+  service: FileTransferServiceDesc,
+  requestStream: false,
+  responseStream: false,
+  requestType: {
+    serializeBinary() {
+      return Empty.encode(this).finish();
+    },
+  } as any,
+  responseType: {
+    deserializeBinary(data: Uint8Array) {
+      return {
+        ...TaskQueueListResp.decode(data),
+        toObject() {
+          return this;
+        },
+      };
+    },
+  } as any,
+};
+
+export const FileTransferServiceQueryQueueDesc: UnaryMethodDefinitionish = {
+  methodName: "QueryQueue",
+  service: FileTransferServiceDesc,
+  requestStream: false,
+  responseStream: true,
+  requestType: {
+    serializeBinary() {
+      return TaskQueueQueryReq.encode(this).finish();
+    },
+  } as any,
+  responseType: {
+    deserializeBinary(data: Uint8Array) {
+      return {
+        ...Task.decode(data),
+        toObject() {
+          return this;
+        },
+      };
+    },
+  } as any,
+};
+
+export const FileTransferServiceClearQueueDesc: UnaryMethodDefinitionish = {
+  methodName: "ClearQueue",
+  service: FileTransferServiceDesc,
+  requestStream: false,
+  responseStream: false,
+  requestType: {
+    serializeBinary() {
+      return TaskQueueQueryReq.encode(this).finish();
+    },
+  } as any,
+  responseType: {
+    deserializeBinary(data: Uint8Array) {
+      return {
+        ...Empty.decode(data),
+        toObject() {
+          return this;
+        },
+      };
+    },
+  } as any,
+};
+
+export const FileTransferServiceConfigQueueDesc: UnaryMethodDefinitionish = {
+  methodName: "ConfigQueue",
+  service: FileTransferServiceDesc,
+  requestStream: false,
+  responseStream: false,
+  requestType: {
+    serializeBinary() {
+      return TaskQueueConfigReq.encode(this).finish();
+    },
+  } as any,
+  responseType: {
+    deserializeBinary(data: Uint8Array) {
+      return {
+        ...Empty.decode(data),
+        toObject() {
+          return this;
+        },
+      };
+    },
+  } as any,
+};
+
+export const FileTransferServicePauseQueueDesc: UnaryMethodDefinitionish = {
+  methodName: "PauseQueue",
+  service: FileTransferServiceDesc,
+  requestStream: false,
+  responseStream: false,
+  requestType: {
+    serializeBinary() {
+      return TaskQueueID.encode(this).finish();
+    },
+  } as any,
+  responseType: {
+    deserializeBinary(data: Uint8Array) {
+      return {
+        ...Empty.decode(data),
+        toObject() {
+          return this;
+        },
+      };
+    },
+  } as any,
+};
+
+export const FileTransferServiceStartQuqueDesc: UnaryMethodDefinitionish = {
+  methodName: "StartQuque",
+  service: FileTransferServiceDesc,
+  requestStream: false,
+  responseStream: false,
+  requestType: {
+    serializeBinary() {
+      return TaskQueueID.encode(this).finish();
+    },
+  } as any,
+  responseType: {
+    deserializeBinary(data: Uint8Array) {
+      return {
+        ...Empty.decode(data),
+        toObject() {
+          return this;
+        },
+      };
+    },
+  } as any,
+};
+
+export const FileTransferServiceQueryQueueMessageDesc: UnaryMethodDefinitionish = {
+  methodName: "QueryQueueMessage",
+  service: FileTransferServiceDesc,
+  requestStream: false,
+  responseStream: true,
+  requestType: {
+    serializeBinary() {
+      return TaskQueueQueryReq.encode(this).finish();
+    },
+  } as any,
+  responseType: {
+    deserializeBinary(data: Uint8Array) {
+      return {
+        ...QueueMessageResp.decode(data),
+        toObject() {
+          return this;
+        },
+      };
+    },
+  } as any,
+};
+
+export const FileTransferServiceCreateTaskDesc: UnaryMethodDefinitionish = {
+  methodName: "CreateTask",
+  service: FileTransferServiceDesc,
+  requestStream: false,
+  responseStream: false,
+  requestType: {
+    serializeBinary() {
+      return TaskCreateRequest.encode(this).finish();
+    },
+  } as any,
+  responseType: {
+    deserializeBinary(data: Uint8Array) {
+      return {
+        ...Task.decode(data),
+        toObject() {
+          return this;
+        },
+      };
+    },
+  } as any,
+};
+
+export const FileTransferServiceCreateTasksDesc: UnaryMethodDefinitionish = {
+  methodName: "CreateTasks",
+  service: FileTransferServiceDesc,
+  requestStream: false,
+  responseStream: true,
+  requestType: {
+    serializeBinary() {
+      return TaskCreateRequests.encode(this).finish();
+    },
+  } as any,
+  responseType: {
+    deserializeBinary(data: Uint8Array) {
+      return {
+        ...Task.decode(data),
+        toObject() {
+          return this;
+        },
+      };
+    },
+  } as any,
+};
+
+export const FileTransferServiceQueryTaskDesc: UnaryMethodDefinitionish = {
+  methodName: "QueryTask",
+  service: FileTransferServiceDesc,
+  requestStream: false,
+  responseStream: true,
+  requestType: {
+    serializeBinary() {
+      return TaskID.encode(this).finish();
+    },
+  } as any,
+  responseType: {
+    deserializeBinary(data: Uint8Array) {
+      return {
+        ...Task.decode(data),
+        toObject() {
+          return this;
+        },
+      };
+    },
+  } as any,
+};
+
+export const FileTransferServiceResumeTaskDesc: UnaryMethodDefinitionish = {
+  methodName: "ResumeTask",
+  service: FileTransferServiceDesc,
+  requestStream: false,
+  responseStream: false,
+  requestType: {
+    serializeBinary() {
+      return TaskID.encode(this).finish();
+    },
+  } as any,
+  responseType: {
+    deserializeBinary(data: Uint8Array) {
+      return {
+        ...Empty.decode(data),
+        toObject() {
+          return this;
+        },
+      };
+    },
+  } as any,
+};
+
+export const FileTransferServicePauseTaskDesc: UnaryMethodDefinitionish = {
+  methodName: "PauseTask",
+  service: FileTransferServiceDesc,
+  requestStream: false,
+  responseStream: false,
+  requestType: {
+    serializeBinary() {
+      return TaskID.encode(this).finish();
+    },
+  } as any,
+  responseType: {
+    deserializeBinary(data: Uint8Array) {
+      return {
+        ...Empty.decode(data),
+        toObject() {
+          return this;
+        },
+      };
+    },
+  } as any,
+};
+
+export const FileTransferServiceDeleteTaskDesc: UnaryMethodDefinitionish = {
+  methodName: "DeleteTask",
+  service: FileTransferServiceDesc,
+  requestStream: false,
+  responseStream: false,
+  requestType: {
+    serializeBinary() {
+      return TaskID.encode(this).finish();
+    },
+  } as any,
+  responseType: {
+    deserializeBinary(data: Uint8Array) {
+      return {
+        ...Empty.decode(data),
+        toObject() {
+          return this;
+        },
+      };
+    },
+  } as any,
+};
+
+interface UnaryMethodDefinitionishR extends grpc.UnaryMethodDefinition<any, any> {
+  requestStream: any;
+  responseStream: any;
+}
+
+type UnaryMethodDefinitionish = UnaryMethodDefinitionishR;
+
+interface Rpc {
+  unary<T extends UnaryMethodDefinitionish>(
+    methodDesc: T,
+    request: any,
+    metadata: grpc.Metadata | undefined,
+  ): Promise<any>;
+  invoke<T extends UnaryMethodDefinitionish>(
+    methodDesc: T,
+    request: any,
+    metadata: grpc.Metadata | undefined,
+  ): Observable<any>;
+}
+
+export class GrpcWebImpl {
+  private host: string;
+  private options: {
+    transport?: grpc.TransportFactory;
+    streamingTransport?: grpc.TransportFactory;
+    debug?: boolean;
+    metadata?: grpc.Metadata;
+    upStreamRetryCodes?: number[];
+  };
+
+  constructor(
+    host: string,
+    options: {
+      transport?: grpc.TransportFactory;
+      streamingTransport?: grpc.TransportFactory;
+      debug?: boolean;
+      metadata?: grpc.Metadata;
+      upStreamRetryCodes?: number[];
+    },
+  ) {
+    this.host = host;
+    this.options = options;
+  }
+
+  unary<T extends UnaryMethodDefinitionish>(
+    methodDesc: T,
+    _request: any,
+    metadata: grpc.Metadata | undefined,
+  ): Promise<any> {
+    const request = { ..._request, ...methodDesc.requestType };
+    const maybeCombinedMetadata = metadata && this.options.metadata
+      ? new BrowserHeaders({ ...this.options?.metadata.headersMap, ...metadata?.headersMap })
+      : metadata || this.options.metadata;
+    return new Promise((resolve, reject) => {
+      grpc.unary(methodDesc, {
+        request,
+        host: this.host,
+        metadata: maybeCombinedMetadata,
+        transport: this.options.transport,
+        debug: this.options.debug,
+        onEnd: function (response) {
+          if (response.status === grpc.Code.OK) {
+            resolve(response.message);
+          } else {
+            const err = new GrpcWebError(response.statusMessage, response.status, response.trailers);
+            reject(err);
+          }
+        },
+      });
+    });
+  }
+
+  invoke<T extends UnaryMethodDefinitionish>(
+    methodDesc: T,
+    _request: any,
+    metadata: grpc.Metadata | undefined,
+  ): Observable<any> {
+    const upStreamCodes = this.options.upStreamRetryCodes || [];
+    const DEFAULT_TIMEOUT_TIME: number = 3_000;
+    const request = { ..._request, ...methodDesc.requestType };
+    const maybeCombinedMetadata = metadata && this.options.metadata
+      ? new BrowserHeaders({ ...this.options?.metadata.headersMap, ...metadata?.headersMap })
+      : metadata || this.options.metadata;
+    return new Observable((observer) => {
+      const upStream = (() => {
+        const client = grpc.invoke(methodDesc, {
+          host: this.host,
+          request,
+          transport: this.options.streamingTransport || this.options.transport,
+          metadata: maybeCombinedMetadata,
+          debug: this.options.debug,
+          onMessage: (next) => observer.next(next),
+          onEnd: (code: grpc.Code, message: string, trailers: grpc.Metadata) => {
+            if (code === 0) {
+              observer.complete();
+            } else if (upStreamCodes.includes(code)) {
+              setTimeout(upStream, DEFAULT_TIMEOUT_TIME);
+            } else {
+              const err = new Error(message) as any;
+              err.code = code;
+              err.metadata = trailers;
+              observer.error(err);
+            }
+          },
+        });
+        observer.add(() => client.close());
+      });
+      upStream();
+    }).pipe(share());
+  }
+}
+
+declare var self: any | undefined;
+declare var window: any | undefined;
+declare var global: any | undefined;
+var globalThis: any = (() => {
+  if (typeof globalThis !== "undefined") {
+    return globalThis;
+  }
+  if (typeof self !== "undefined") {
+    return self;
+  }
+  if (typeof window !== "undefined") {
+    return window;
+  }
+  if (typeof global !== "undefined") {
+    return global;
+  }
+  throw "Unable to locate global object";
+})();
+
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+
+type DeepPartial<T> = T extends Builtin ? T
+  : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
+  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
+  : Partial<T>;
+
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+type Exact<P, I extends P> = P extends Builtin ? P
+  : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };
+
+function toTimestamp(date: Date): Timestamp {
+  const seconds = date.getTime() / 1_000;
+  const nanos = (date.getTime() % 1_000) * 1_000_000;
+  return { seconds, nanos };
+}
+
+function fromTimestamp(t: Timestamp): Date {
+  let millis = t.seconds * 1_000;
+  millis += t.nanos / 1_000_000;
+  return new Date(millis);
+}
+
+function fromJsonTimestamp(o: any): Date {
+  if (o instanceof Date) {
+    return o;
+  } else if (typeof o === "string") {
+    return new Date(o);
+  } else {
+    return fromTimestamp(Timestamp.fromJSON(o));
+  }
+}
+
+function longToNumber(long: Long): number {
+  if (long.gt(Number.MAX_SAFE_INTEGER)) {
+    throw new globalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER");
+  }
+  return long.toNumber();
+}
+
+if (_m0.util.Long !== Long) {
+  _m0.util.Long = Long as any;
+  _m0.configure();
+}
+
+function isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}
+
+export class GrpcWebError extends Error {
+  constructor(message: string, public code: grpc.Code, public metadata: grpc.Metadata) {
+    super(message);
+  }
+}