@aneoconsultingfr/armonik.api/dist/chunk-E7TUDUPV.mjs

gRPC API to interact with ArmoniK built for the web

import {
  taskStatusFromJSON,
  taskStatusToJSON
} from "./chunk-RHCXWRLW.mjs";
import {
  Duration
} from "./chunk-3UVKLUQF.mjs";

// src/generated/objects.ts
import _m0 from "protobufjs/minimal.js";
var protobufPackage = "armonik.api.grpc.v1";
function createBaseEmpty() {
  return {};
}
var Empty = {
  encode(_, writer = _m0.Writer.create()) {
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
    let end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseEmpty();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skipType(tag & 7);
    }
    return message;
  },
  fromJSON(_) {
    return {};
  },
  toJSON(_) {
    const obj = {};
    return obj;
  },
  create(base) {
    return Empty.fromPartial(base ?? {});
  },
  fromPartial(_) {
    const message = createBaseEmpty();
    return message;
  }
};
function createBaseTaskOptions() {
  return {
    options: {},
    maxDuration: void 0,
    maxRetries: 0,
    priority: 0,
    partitionId: "",
    applicationName: "",
    applicationVersion: "",
    applicationNamespace: "",
    applicationService: "",
    engineType: ""
  };
}
var TaskOptions = {
  encode(message, writer = _m0.Writer.create()) {
    Object.entries(message.options).forEach(([key, value]) => {
      TaskOptions_OptionsEntry.encode({ key, value }, writer.uint32(10).fork()).ldelim();
    });
    if (message.maxDuration !== void 0) {
      Duration.encode(message.maxDuration, writer.uint32(18).fork()).ldelim();
    }
    if (message.maxRetries !== 0) {
      writer.uint32(24).int32(message.maxRetries);
    }
    if (message.priority !== 0) {
      writer.uint32(32).int32(message.priority);
    }
    if (message.partitionId !== "") {
      writer.uint32(42).string(message.partitionId);
    }
    if (message.applicationName !== "") {
      writer.uint32(50).string(message.applicationName);
    }
    if (message.applicationVersion !== "") {
      writer.uint32(58).string(message.applicationVersion);
    }
    if (message.applicationNamespace !== "") {
      writer.uint32(66).string(message.applicationNamespace);
    }
    if (message.applicationService !== "") {
      writer.uint32(74).string(message.applicationService);
    }
    if (message.engineType !== "") {
      writer.uint32(82).string(message.engineType);
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
    let end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseTaskOptions();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          if (tag !== 10) {
            break;
          }
          const entry1 = TaskOptions_OptionsEntry.decode(reader, reader.uint32());
          if (entry1.value !== void 0) {
            message.options[entry1.key] = entry1.value;
          }
          continue;
        case 2:
          if (tag !== 18) {
            break;
          }
          message.maxDuration = Duration.decode(reader, reader.uint32());
          continue;
        case 3:
          if (tag !== 24) {
            break;
          }
          message.maxRetries = reader.int32();
          continue;
        case 4:
          if (tag !== 32) {
            break;
          }
          message.priority = reader.int32();
          continue;
        case 5:
          if (tag !== 42) {
            break;
          }
          message.partitionId = reader.string();
          continue;
        case 6:
          if (tag !== 50) {
            break;
          }
          message.applicationName = reader.string();
          continue;
        case 7:
          if (tag !== 58) {
            break;
          }
          message.applicationVersion = reader.string();
          continue;
        case 8:
          if (tag !== 66) {
            break;
          }
          message.applicationNamespace = reader.string();
          continue;
        case 9:
          if (tag !== 74) {
            break;
          }
          message.applicationService = reader.string();
          continue;
        case 10:
          if (tag !== 82) {
            break;
          }
          message.engineType = reader.string();
          continue;
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skipType(tag & 7);
    }
    return message;
  },
  fromJSON(object) {
    return {
      options: isObject(object.options) ? Object.entries(object.options).reduce((acc, [key, value]) => {
        acc[key] = String(value);
        return acc;
      }, {}) : {},
      maxDuration: isSet(object.maxDuration) ? Duration.fromJSON(object.maxDuration) : void 0,
      maxRetries: isSet(object.maxRetries) ? Number(object.maxRetries) : 0,
      priority: isSet(object.priority) ? Number(object.priority) : 0,
      partitionId: isSet(object.partitionId) ? String(object.partitionId) : "",
      applicationName: isSet(object.applicationName) ? String(object.applicationName) : "",
      applicationVersion: isSet(object.applicationVersion) ? String(object.applicationVersion) : "",
      applicationNamespace: isSet(object.applicationNamespace) ? String(object.applicationNamespace) : "",
      applicationService: isSet(object.applicationService) ? String(object.applicationService) : "",
      engineType: isSet(object.engineType) ? String(object.engineType) : ""
    };
  },
  toJSON(message) {
    const obj = {};
    if (message.options) {
      const entries = Object.entries(message.options);
      if (entries.length > 0) {
        obj.options = {};
        entries.forEach(([k, v]) => {
          obj.options[k] = v;
        });
      }
    }
    if (message.maxDuration !== void 0) {
      obj.maxDuration = Duration.toJSON(message.maxDuration);
    }
    if (message.maxRetries !== 0) {
      obj.maxRetries = Math.round(message.maxRetries);
    }
    if (message.priority !== 0) {
      obj.priority = Math.round(message.priority);
    }
    if (message.partitionId !== "") {
      obj.partitionId = message.partitionId;
    }
    if (message.applicationName !== "") {
      obj.applicationName = message.applicationName;
    }
    if (message.applicationVersion !== "") {
      obj.applicationVersion = message.applicationVersion;
    }
    if (message.applicationNamespace !== "") {
      obj.applicationNamespace = message.applicationNamespace;
    }
    if (message.applicationService !== "") {
      obj.applicationService = message.applicationService;
    }
    if (message.engineType !== "") {
      obj.engineType = message.engineType;
    }
    return obj;
  },
  create(base) {
    return TaskOptions.fromPartial(base ?? {});
  },
  fromPartial(object) {
    const message = createBaseTaskOptions();
    message.options = Object.entries(object.options ?? {}).reduce((acc, [key, value]) => {
      if (value !== void 0) {
        acc[key] = String(value);
      }
      return acc;
    }, {});
    message.maxDuration = object.maxDuration !== void 0 && object.maxDuration !== null ? Duration.fromPartial(object.maxDuration) : void 0;
    message.maxRetries = object.maxRetries ?? 0;
    message.priority = object.priority ?? 0;
    message.partitionId = object.partitionId ?? "";
    message.applicationName = object.applicationName ?? "";
    message.applicationVersion = object.applicationVersion ?? "";
    message.applicationNamespace = object.applicationNamespace ?? "";
    message.applicationService = object.applicationService ?? "";
    message.engineType = object.engineType ?? "";
    return message;
  }
};
function createBaseTaskOptions_OptionsEntry() {
  return { key: "", value: "" };
}
var TaskOptions_OptionsEntry = {
  encode(message, writer = _m0.Writer.create()) {
    if (message.key !== "") {
      writer.uint32(10).string(message.key);
    }
    if (message.value !== "") {
      writer.uint32(18).string(message.value);
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
    let end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseTaskOptions_OptionsEntry();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          if (tag !== 10) {
            break;
          }
          message.key = reader.string();
          continue;
        case 2:
          if (tag !== 18) {
            break;
          }
          message.value = reader.string();
          continue;
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skipType(tag & 7);
    }
    return message;
  },
  fromJSON(object) {
    return { key: isSet(object.key) ? String(object.key) : "", value: isSet(object.value) ? String(object.value) : "" };
  },
  toJSON(message) {
    const obj = {};
    if (message.key !== "") {
      obj.key = message.key;
    }
    if (message.value !== "") {
      obj.value = message.value;
    }
    return obj;
  },
  create(base) {
    return TaskOptions_OptionsEntry.fromPartial(base ?? {});
  },
  fromPartial(object) {
    const message = createBaseTaskOptions_OptionsEntry();
    message.key = object.key ?? "";
    message.value = object.value ?? "";
    return message;
  }
};
function createBaseSession() {
  return { id: "" };
}
var Session = {
  encode(message, writer = _m0.Writer.create()) {
    if (message.id !== "") {
      writer.uint32(10).string(message.id);
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
    let end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseSession();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          if (tag !== 10) {
            break;
          }
          message.id = reader.string();
          continue;
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skipType(tag & 7);
    }
    return message;
  },
  fromJSON(object) {
    return { id: isSet(object.id) ? String(object.id) : "" };
  },
  toJSON(message) {
    const obj = {};
    if (message.id !== "") {
      obj.id = message.id;
    }
    return obj;
  },
  create(base) {
    return Session.fromPartial(base ?? {});
  },
  fromPartial(object) {
    const message = createBaseSession();
    message.id = object.id ?? "";
    return message;
  }
};
function createBaseConfiguration() {
  return { dataChunkMaxSize: 0 };
}
var Configuration = {
  encode(message, writer = _m0.Writer.create()) {
    if (message.dataChunkMaxSize !== 0) {
      writer.uint32(8).int32(message.dataChunkMaxSize);
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
    let end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseConfiguration();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          if (tag !== 8) {
            break;
          }
          message.dataChunkMaxSize = reader.int32();
          continue;
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skipType(tag & 7);
    }
    return message;
  },
  fromJSON(object) {
    return { dataChunkMaxSize: isSet(object.dataChunkMaxSize) ? Number(object.dataChunkMaxSize) : 0 };
  },
  toJSON(message) {
    const obj = {};
    if (message.dataChunkMaxSize !== 0) {
      obj.dataChunkMaxSize = Math.round(message.dataChunkMaxSize);
    }
    return obj;
  },
  create(base) {
    return Configuration.fromPartial(base ?? {});
  },
  fromPartial(object) {
    const message = createBaseConfiguration();
    message.dataChunkMaxSize = object.dataChunkMaxSize ?? 0;
    return message;
  }
};
function createBaseOutput() {
  return { ok: void 0, error: void 0 };
}
var Output = {
  encode(message, writer = _m0.Writer.create()) {
    if (message.ok !== void 0) {
      Empty.encode(message.ok, writer.uint32(18).fork()).ldelim();
    }
    if (message.error !== void 0) {
      Output_Error.encode(message.error, writer.uint32(26).fork()).ldelim();
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
    let end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseOutput();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 2:
          if (tag !== 18) {
            break;
          }
          message.ok = Empty.decode(reader, reader.uint32());
          continue;
        case 3:
          if (tag !== 26) {
            break;
          }
          message.error = Output_Error.decode(reader, reader.uint32());
          continue;
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skipType(tag & 7);
    }
    return message;
  },
  fromJSON(object) {
    return {
      ok: isSet(object.ok) ? Empty.fromJSON(object.ok) : void 0,
      error: isSet(object.error) ? Output_Error.fromJSON(object.error) : void 0
    };
  },
  toJSON(message) {
    const obj = {};
    if (message.ok !== void 0) {
      obj.ok = Empty.toJSON(message.ok);
    }
    if (message.error !== void 0) {
      obj.error = Output_Error.toJSON(message.error);
    }
    return obj;
  },
  create(base) {
    return Output.fromPartial(base ?? {});
  },
  fromPartial(object) {
    const message = createBaseOutput();
    message.ok = object.ok !== void 0 && object.ok !== null ? Empty.fromPartial(object.ok) : void 0;
    message.error = object.error !== void 0 && object.error !== null ? Output_Error.fromPartial(object.error) : void 0;
    return message;
  }
};
function createBaseOutput_Error() {
  return { details: "" };
}
var Output_Error = {
  encode(message, writer = _m0.Writer.create()) {
    if (message.details !== "") {
      writer.uint32(10).string(message.details);
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
    let end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseOutput_Error();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          if (tag !== 10) {
            break;
          }
          message.details = reader.string();
          continue;
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skipType(tag & 7);
    }
    return message;
  },
  fromJSON(object) {
    return { details: isSet(object.details) ? String(object.details) : "" };
  },
  toJSON(message) {
    const obj = {};
    if (message.details !== "") {
      obj.details = message.details;
    }
    return obj;
  },
  create(base) {
    return Output_Error.fromPartial(base ?? {});
  },
  fromPartial(object) {
    const message = createBaseOutput_Error();
    message.details = object.details ?? "";
    return message;
  }
};
function createBaseTaskRequest() {
  return { expectedOutputKeys: [], dataDependencies: [], payload: new Uint8Array(0), payloadName: "" };
}
var TaskRequest = {
  encode(message, writer = _m0.Writer.create()) {
    for (const v of message.expectedOutputKeys) {
      writer.uint32(10).string(v);
    }
    for (const v of message.dataDependencies) {
      writer.uint32(18).string(v);
    }
    if (message.payload.length !== 0) {
      writer.uint32(26).bytes(message.payload);
    }
    if (message.payloadName !== "") {
      writer.uint32(34).string(message.payloadName);
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
    let end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseTaskRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          if (tag !== 10) {
            break;
          }
          message.expectedOutputKeys.push(reader.string());
          continue;
        case 2:
          if (tag !== 18) {
            break;
          }
          message.dataDependencies.push(reader.string());
          continue;
        case 3:
          if (tag !== 26) {
            break;
          }
          message.payload = reader.bytes();
          continue;
        case 4:
          if (tag !== 34) {
            break;
          }
          message.payloadName = reader.string();
          continue;
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skipType(tag & 7);
    }
    return message;
  },
  fromJSON(object) {
    return {
      expectedOutputKeys: Array.isArray(object == null ? void 0 : object.expectedOutputKeys) ? object.expectedOutputKeys.map((e) => String(e)) : [],
      dataDependencies: Array.isArray(object == null ? void 0 : object.dataDependencies) ? object.dataDependencies.map((e) => String(e)) : [],
      payload: isSet(object.payload) ? bytesFromBase64(object.payload) : new Uint8Array(0),
      payloadName: isSet(object.payloadName) ? String(object.payloadName) : ""
    };
  },
  toJSON(message) {
    var _a, _b;
    const obj = {};
    if ((_a = message.expectedOutputKeys) == null ? void 0 : _a.length) {
      obj.expectedOutputKeys = message.expectedOutputKeys;
    }
    if ((_b = message.dataDependencies) == null ? void 0 : _b.length) {
      obj.dataDependencies = message.dataDependencies;
    }
    if (message.payload.length !== 0) {
      obj.payload = base64FromBytes(message.payload);
    }
    if (message.payloadName !== "") {
      obj.payloadName = message.payloadName;
    }
    return obj;
  },
  create(base) {
    return TaskRequest.fromPartial(base ?? {});
  },
  fromPartial(object) {
    var _a, _b;
    const message = createBaseTaskRequest();
    message.expectedOutputKeys = ((_a = object.expectedOutputKeys) == null ? void 0 : _a.map((e) => e)) || [];
    message.dataDependencies = ((_b = object.dataDependencies) == null ? void 0 : _b.map((e) => e)) || [];
    message.payload = object.payload ?? new Uint8Array(0);
    message.payloadName = object.payloadName ?? "";
    return message;
  }
};
function createBaseInitKeyedDataStream() {
  return { key: void 0, lastResult: void 0 };
}
var InitKeyedDataStream = {
  encode(message, writer = _m0.Writer.create()) {
    if (message.key !== void 0) {
      writer.uint32(10).string(message.key);
    }
    if (message.lastResult !== void 0) {
      writer.uint32(16).bool(message.lastResult);
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
    let end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseInitKeyedDataStream();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          if (tag !== 10) {
            break;
          }
          message.key = reader.string();
          continue;
        case 2:
          if (tag !== 16) {
            break;
          }
          message.lastResult = reader.bool();
          continue;
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skipType(tag & 7);
    }
    return message;
  },
  fromJSON(object) {
    return {
      key: isSet(object.key) ? String(object.key) : void 0,
      lastResult: isSet(object.lastResult) ? Boolean(object.lastResult) : void 0
    };
  },
  toJSON(message) {
    const obj = {};
    if (message.key !== void 0) {
      obj.key = message.key;
    }
    if (message.lastResult !== void 0) {
      obj.lastResult = message.lastResult;
    }
    return obj;
  },
  create(base) {
    return InitKeyedDataStream.fromPartial(base ?? {});
  },
  fromPartial(object) {
    const message = createBaseInitKeyedDataStream();
    message.key = object.key ?? void 0;
    message.lastResult = object.lastResult ?? void 0;
    return message;
  }
};
function createBaseDataChunk() {
  return { data: void 0, dataComplete: void 0 };
}
var DataChunk = {
  encode(message, writer = _m0.Writer.create()) {
    if (message.data !== void 0) {
      writer.uint32(10).bytes(message.data);
    }
    if (message.dataComplete !== void 0) {
      writer.uint32(16).bool(message.dataComplete);
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
    let end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseDataChunk();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          if (tag !== 10) {
            break;
          }
          message.data = reader.bytes();
          continue;
        case 2:
          if (tag !== 16) {
            break;
          }
          message.dataComplete = reader.bool();
          continue;
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skipType(tag & 7);
    }
    return message;
  },
  fromJSON(object) {
    return {
      data: isSet(object.data) ? bytesFromBase64(object.data) : void 0,
      dataComplete: isSet(object.dataComplete) ? Boolean(object.dataComplete) : void 0
    };
  },
  toJSON(message) {
    const obj = {};
    if (message.data !== void 0) {
      obj.data = base64FromBytes(message.data);
    }
    if (message.dataComplete !== void 0) {
      obj.dataComplete = message.dataComplete;
    }
    return obj;
  },
  create(base) {
    return DataChunk.fromPartial(base ?? {});
  },
  fromPartial(object) {
    const message = createBaseDataChunk();
    message.data = object.data ?? void 0;
    message.dataComplete = object.dataComplete ?? void 0;
    return message;
  }
};
function createBaseTaskRequestHeader() {
  return { expectedOutputKeys: [], dataDependencies: [] };
}
var TaskRequestHeader = {
  encode(message, writer = _m0.Writer.create()) {
    for (const v of message.expectedOutputKeys) {
      writer.uint32(10).string(v);
    }
    for (const v of message.dataDependencies) {
      writer.uint32(18).string(v);
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
    let end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseTaskRequestHeader();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          if (tag !== 10) {
            break;
          }
          message.expectedOutputKeys.push(reader.string());
          continue;
        case 2:
          if (tag !== 18) {
            break;
          }
          message.dataDependencies.push(reader.string());
          continue;
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skipType(tag & 7);
    }
    return message;
  },
  fromJSON(object) {
    return {
      expectedOutputKeys: Array.isArray(object == null ? void 0 : object.expectedOutputKeys) ? object.expectedOutputKeys.map((e) => String(e)) : [],
      dataDependencies: Array.isArray(object == null ? void 0 : object.dataDependencies) ? object.dataDependencies.map((e) => String(e)) : []
    };
  },
  toJSON(message) {
    var _a, _b;
    const obj = {};
    if ((_a = message.expectedOutputKeys) == null ? void 0 : _a.length) {
      obj.expectedOutputKeys = message.expectedOutputKeys;
    }
    if ((_b = message.dataDependencies) == null ? void 0 : _b.length) {
      obj.dataDependencies = message.dataDependencies;
    }
    return obj;
  },
  create(base) {
    return TaskRequestHeader.fromPartial(base ?? {});
  },
  fromPartial(object) {
    var _a, _b;
    const message = createBaseTaskRequestHeader();
    message.expectedOutputKeys = ((_a = object.expectedOutputKeys) == null ? void 0 : _a.map((e) => e)) || [];
    message.dataDependencies = ((_b = object.dataDependencies) == null ? void 0 : _b.map((e) => e)) || [];
    return message;
  }
};
function createBaseInitTaskRequest() {
  return { header: void 0, lastTask: void 0 };
}
var InitTaskRequest = {
  encode(message, writer = _m0.Writer.create()) {
    if (message.header !== void 0) {
      TaskRequestHeader.encode(message.header, writer.uint32(10).fork()).ldelim();
    }
    if (message.lastTask !== void 0) {
      writer.uint32(16).bool(message.lastTask);
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
    let end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseInitTaskRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          if (tag !== 10) {
            break;
          }
          message.header = TaskRequestHeader.decode(reader, reader.uint32());
          continue;
        case 2:
          if (tag !== 16) {
            break;
          }
          message.lastTask = reader.bool();
          continue;
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skipType(tag & 7);
    }
    return message;
  },
  fromJSON(object) {
    return {
      header: isSet(object.header) ? TaskRequestHeader.fromJSON(object.header) : void 0,
      lastTask: isSet(object.lastTask) ? Boolean(object.lastTask) : void 0
    };
  },
  toJSON(message) {
    const obj = {};
    if (message.header !== void 0) {
      obj.header = TaskRequestHeader.toJSON(message.header);
    }
    if (message.lastTask !== void 0) {
      obj.lastTask = message.lastTask;
    }
    return obj;
  },
  create(base) {
    return InitTaskRequest.fromPartial(base ?? {});
  },
  fromPartial(object) {
    const message = createBaseInitTaskRequest();
    message.header = object.header !== void 0 && object.header !== null ? TaskRequestHeader.fromPartial(object.header) : void 0;
    message.lastTask = object.lastTask ?? void 0;
    return message;
  }
};
function createBaseTaskId() {
  return { session: "", task: "" };
}
var TaskId = {
  encode(message, writer = _m0.Writer.create()) {
    if (message.session !== "") {
      writer.uint32(10).string(message.session);
    }
    if (message.task !== "") {
      writer.uint32(18).string(message.task);
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
    let end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseTaskId();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          if (tag !== 10) {
            break;
          }
          message.session = reader.string();
          continue;
        case 2:
          if (tag !== 18) {
            break;
          }
          message.task = reader.string();
          continue;
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skipType(tag & 7);
    }
    return message;
  },
  fromJSON(object) {
    return {
      session: isSet(object.session) ? String(object.session) : "",
      task: isSet(object.task) ? String(object.task) : ""
    };
  },
  toJSON(message) {
    const obj = {};
    if (message.session !== "") {
      obj.session = message.session;
    }
    if (message.task !== "") {
      obj.task = message.task;
    }
    return obj;
  },
  create(base) {
    return TaskId.fromPartial(base ?? {});
  },
  fromPartial(object) {
    const message = createBaseTaskId();
    message.session = object.session ?? "";
    message.task = object.task ?? "";
    return message;
  }
};
function createBaseTaskIdList() {
  return { taskIds: [] };
}
var TaskIdList = {
  encode(message, writer = _m0.Writer.create()) {
    for (const v of message.taskIds) {
      writer.uint32(10).string(v);
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
    let end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseTaskIdList();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          if (tag !== 10) {
            break;
          }
          message.taskIds.push(reader.string());
          continue;
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skipType(tag & 7);
    }
    return message;
  },
  fromJSON(object) {
    return { taskIds: Array.isArray(object == null ? void 0 : object.taskIds) ? object.taskIds.map((e) => String(e)) : [] };
  },
  toJSON(message) {
    var _a;
    const obj = {};
    if ((_a = message.taskIds) == null ? void 0 : _a.length) {
      obj.taskIds = message.taskIds;
    }
    return obj;
  },
  create(base) {
    return TaskIdList.fromPartial(base ?? {});
  },
  fromPartial(object) {
    var _a;
    const message = createBaseTaskIdList();
    message.taskIds = ((_a = object.taskIds) == null ? void 0 : _a.map((e) => e)) || [];
    return message;
  }
};
function createBaseStatusCount() {
  return { status: 0, count: 0 };
}
var StatusCount = {
  encode(message, writer = _m0.Writer.create()) {
    if (message.status !== 0) {
      writer.uint32(8).int32(message.status);
    }
    if (message.count !== 0) {
      writer.uint32(16).int32(message.count);
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
    let end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseStatusCount();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          if (tag !== 8) {
            break;
          }
          message.status = reader.int32();
          continue;
        case 2:
          if (tag !== 16) {
            break;
          }
          message.count = reader.int32();
          continue;
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skipType(tag & 7);
    }
    return message;
  },
  fromJSON(object) {
    return {
      status: isSet(object.status) ? taskStatusFromJSON(object.status) : 0,
      count: isSet(object.count) ? Number(object.count) : 0
    };
  },
  toJSON(message) {
    const obj = {};
    if (message.status !== 0) {
      obj.status = taskStatusToJSON(message.status);
    }
    if (message.count !== 0) {
      obj.count = Math.round(message.count);
    }
    return obj;
  },
  create(base) {
    return StatusCount.fromPartial(base ?? {});
  },
  fromPartial(object) {
    const message = createBaseStatusCount();
    message.status = object.status ?? 0;
    message.count = object.count ?? 0;
    return message;
  }
};
function createBaseCount() {
  return { values: [] };
}
var Count = {
  encode(message, writer = _m0.Writer.create()) {
    for (const v of message.values) {
      StatusCount.encode(v, writer.uint32(10).fork()).ldelim();
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
    let end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseCount();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          if (tag !== 10) {
            break;
          }
          message.values.push(StatusCount.decode(reader, reader.uint32()));
          continue;
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skipType(tag & 7);
    }
    return message;
  },
  fromJSON(object) {
    return { values: Array.isArray(object == null ? void 0 : object.values) ? object.values.map((e) => StatusCount.fromJSON(e)) : [] };
  },
  toJSON(message) {
    var _a;
    const obj = {};
    if ((_a = message.values) == null ? void 0 : _a.length) {
      obj.values = message.values.map((e) => StatusCount.toJSON(e));
    }
    return obj;
  },
  create(base) {
    return Count.fromPartial(base ?? {});
  },
  fromPartial(object) {
    var _a;
    const message = createBaseCount();
    message.values = ((_a = object.values) == null ? void 0 : _a.map((e) => StatusCount.fromPartial(e))) || [];
    return message;
  }
};
function createBaseResultRequest() {
  return { session: "", resultId: "" };
}
var ResultRequest = {
  encode(message, writer = _m0.Writer.create()) {
    if (message.session !== "") {
      writer.uint32(10).string(message.session);
    }
    if (message.resultId !== "") {
      writer.uint32(18).string(message.resultId);
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
    let end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseResultRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          if (tag !== 10) {
            break;
          }
          message.session = reader.string();
          continue;
        case 2:
          if (tag !== 18) {
            break;
          }
          message.resultId = reader.string();
          continue;
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skipType(tag & 7);
    }
    return message;
  },
  fromJSON(object) {
    return {
      session: isSet(object.session) ? String(object.session) : "",
      resultId: isSet(object.resultId) ? String(object.resultId) : ""
    };
  },
  toJSON(message) {
    const obj = {};
    if (message.session !== "") {
      obj.session = message.session;
    }
    if (message.resultId !== "") {
      obj.resultId = message.resultId;
    }
    return obj;
  },
  create(base) {
    return ResultRequest.fromPartial(base ?? {});
  },
  fromPartial(object) {
    const message = createBaseResultRequest();
    message.session = object.session ?? "";
    message.resultId = object.resultId ?? "";
    return message;
  }
};
function createBaseTaskOutputRequest() {
  return { session: "", taskId: "" };
}
var TaskOutputRequest = {
  encode(message, writer = _m0.Writer.create()) {
    if (message.session !== "") {
      writer.uint32(10).string(message.session);
    }
    if (message.taskId !== "") {
      writer.uint32(18).string(message.taskId);
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
    let end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseTaskOutputRequest();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          if (tag !== 10) {
            break;
          }
          message.session = reader.string();
          continue;
        case 2:
          if (tag !== 18) {
            break;
          }
          message.taskId = reader.string();
          continue;
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skipType(tag & 7);
    }
    return message;
  },
  fromJSON(object) {
    return {
      session: isSet(object.session) ? String(object.session) : "",
      taskId: isSet(object.taskId) ? String(object.taskId) : ""
    };
  },
  toJSON(message) {
    const obj = {};
    if (message.session !== "") {
      obj.session = message.session;
    }
    if (message.taskId !== "") {
      obj.taskId = message.taskId;
    }
    return obj;
  },
  create(base) {
    return TaskOutputRequest.fromPartial(base ?? {});
  },
  fromPartial(object) {
    const message = createBaseTaskOutputRequest();
    message.session = object.session ?? "";
    message.taskId = object.taskId ?? "";
    return message;
  }
};
function createBaseError() {
  return { taskStatus: 0, detail: "" };
}
var Error = {
  encode(message, writer = _m0.Writer.create()) {
    if (message.taskStatus !== 0) {
      writer.uint32(8).int32(message.taskStatus);
    }
    if (message.detail !== "") {
      writer.uint32(18).string(message.detail);
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
    let end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseError();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          if (tag !== 8) {
            break;
          }
          message.taskStatus = reader.int32();
          continue;
        case 2:
          if (tag !== 18) {
            break;
          }
          message.detail = reader.string();
          continue;
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skipType(tag & 7);
    }
    return message;
  },
  fromJSON(object) {
    return {
      taskStatus: isSet(object.taskStatus) ? taskStatusFromJSON(object.taskStatus) : 0,
      detail: isSet(object.detail) ? String(object.detail) : ""
    };
  },
  toJSON(message) {
    const obj = {};
    if (message.taskStatus !== 0) {
      obj.taskStatus = taskStatusToJSON(message.taskStatus);
    }
    if (message.detail !== "") {
      obj.detail = message.detail;
    }
    return obj;
  },
  create(base) {
    return Error.fromPartial(base ?? {});
  },
  fromPartial(object) {
    const message = createBaseError();
    message.taskStatus = object.taskStatus ?? 0;
    message.detail = object.detail ?? "";
    return message;
  }
};
function createBaseTaskError() {
  return { taskId: "", errors: [] };
}
var TaskError = {
  encode(message, writer = _m0.Writer.create()) {
    if (message.taskId !== "") {
      writer.uint32(10).string(message.taskId);
    }
    for (const v of message.errors) {
      Error.encode(v, writer.uint32(18).fork()).ldelim();
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
    let end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseTaskError();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          if (tag !== 10) {
            break;
          }
          message.taskId = reader.string();
          continue;
        case 2:
          if (tag !== 18) {
            break;
          }
          message.errors.push(Error.decode(reader, reader.uint32()));
          continue;
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skipType(tag & 7);
    }
    return message;
  },
  fromJSON(object) {
    return {
      taskId: isSet(object.taskId) ? String(object.taskId) : "",
      errors: Array.isArray(object == null ? void 0 : object.errors) ? object.errors.map((e) => Error.fromJSON(e)) : []
    };
  },
  toJSON(message) {
    var _a;
    const obj = {};
    if (message.taskId !== "") {
      obj.taskId = message.taskId;
    }
    if ((_a = message.errors) == null ? void 0 : _a.length) {
      obj.errors = message.errors.map((e) => Error.toJSON(e));
    }
    return obj;
  },
  create(base) {
    return TaskError.fromPartial(base ?? {});
  },
  fromPartial(object) {
    var _a;
    const message = createBaseTaskError();
    message.taskId = object.taskId ?? "";
    message.errors = ((_a = object.errors) == null ? void 0 : _a.map((e) => Error.fromPartial(e))) || [];
    return message;
  }
};
function createBaseTaskList() {
  return { taskIds: [] };
}
var TaskList = {
  encode(message, writer = _m0.Writer.create()) {
    for (const v of message.taskIds) {
      TaskId.encode(v, writer.uint32(10).fork()).ldelim();
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
    let end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseTaskList();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          if (tag !== 10) {
            break;
          }
          message.taskIds.push(TaskId.decode(reader, reader.uint32()));
          continue;
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skipType(tag & 7);
    }
    return message;
  },
  fromJSON(object) {
    return { taskIds: Array.isArray(object == null ? void 0 : object.taskIds) ? object.taskIds.map((e) => TaskId.fromJSON(e)) : [] };
  },
  toJSON(message) {
    var _a;
    const obj = {};
    if ((_a = message.taskIds) == null ? void 0 : _a.length) {
      obj.taskIds = message.taskIds.map((e) => TaskId.toJSON(e));
    }
    return obj;
  },
  create(base) {
    return TaskList.fromPartial(base ?? {});
  },
  fromPartial(object) {
    var _a;
    const message = createBaseTaskList();
    message.taskIds = ((_a = object.taskIds) == null ? void 0 : _a.map((e) => TaskId.fromPartial(e))) || [];
    return message;
  }
};
function createBaseTaskIdWithStatus() {
  return { taskId: void 0, status: 0 };
}
var TaskIdWithStatus = {
  encode(message, writer = _m0.Writer.create()) {
    if (message.taskId !== void 0) {
      TaskId.encode(message.taskId, writer.uint32(10).fork()).ldelim();
    }
    if (message.status !== 0) {
      writer.uint32(16).int32(message.status);
    }
    return writer;
  },
  decode(input, length) {
    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
    let end = length === void 0 ? reader.len : reader.pos + length;
    const message = createBaseTaskIdWithStatus();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          if (tag !== 10) {
            break;
          }
          message.taskId = TaskId.decode(reader, reader.uint32());
          continue;
        case 2:
          if (tag !== 16) {
            break;
          }
          message.status = reader.int32();
          continue;
      }
      if ((tag & 7) === 4 || tag === 0) {
        break;
      }
      reader.skipType(tag & 7);
    }
    return message;
  },
  fromJSON(object) {
    return {
      taskId: isSet(object.taskId) ? TaskId.fromJSON(object.taskId) : void 0,
      status: isSet(object.status) ? taskStatusFromJSON(object.status) : 0
    };
  },
  toJSON(message) {
    const obj = {};
    if (message.taskId !== void 0) {
      obj.taskId = TaskId.toJSON(message.taskId);
    }
    if (message.status !== 0) {
      obj.status = taskStatusToJSON(message.status);
    }
    return obj;
  },
  create(base) {
    return TaskIdWithStatus.fromPartial(base ?? {});
  },
  fromPartial(object) {
    const message = createBaseTaskIdWithStatus();
    message.taskId = object.taskId !== void 0 && object.taskId !== null ? TaskId.fromPartial(object.taskId) : void 0;
    message.status = object.status ?? 0;
    return message;
  }
};
var tsProtoGlobalThis = (() => {
  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";
})();
function bytesFromBase64(b64) {
  if (tsProtoGlobalThis.Buffer) {
    return Uint8Array.from(tsProtoGlobalThis.Buffer.from(b64, "base64"));
  } else {
    const bin = tsProtoGlobalThis.atob(b64);
    const arr = new Uint8Array(bin.length);
    for (let i = 0; i < bin.length; ++i) {
      arr[i] = bin.charCodeAt(i);
    }
    return arr;
  }
}
function base64FromBytes(arr) {
  if (tsProtoGlobalThis.Buffer) {
    return tsProtoGlobalThis.Buffer.from(arr).toString("base64");
  } else {
    const bin = [];
    arr.forEach((byte) => {
      bin.push(String.fromCharCode(byte));
    });
    return tsProtoGlobalThis.btoa(bin.join(""));
  }
}
function isObject(value) {
  return typeof value === "object" && value !== null;
}
function isSet(value) {
  return value !== null && value !== void 0;
}

export {
  protobufPackage,
  Empty,
  TaskOptions,
  TaskOptions_OptionsEntry,
  Session,
  Configuration,
  Output,
  Output_Error,
  TaskRequest,
  InitKeyedDataStream,
  DataChunk,
  TaskRequestHeader,
  InitTaskRequest,
  TaskId,
  TaskIdList,
  StatusCount,
  Count,
  ResultRequest,
  TaskOutputRequest,
  Error,
  TaskError,
  TaskList,
  TaskIdWithStatus
};