@aneoconsultingfr/armonik.api.angular 3.4.0

package/esm2020/lib/generated/tasks-common.pb.mjs

@@ -0,0 +1,2398 @@
+import { BinaryReader, BinaryWriter } from 'google-protobuf';
+import * as armonikApiGrpcV1Task_status001 from './task-status.pb';
+import * as googleProtobuf002 from '@ngx-grpc/well-known-types';
+import * as armonikApiGrpcV1003 from './objects.pb';
+/**
+ * Message implementation for armonik.api.grpc.v1.tasks.TaskRaw
+ */
+export class TaskRaw {
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new TaskRaw();
+        TaskRaw.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+        return instance;
+    }
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance) {
+        _instance.id = _instance.id || '';
+        _instance.sessionId = _instance.sessionId || '';
+        _instance.ownerPodId = _instance.ownerPodId || '';
+        _instance.parentTaskIds = _instance.parentTaskIds || [];
+        _instance.dataDependencies = _instance.dataDependencies || [];
+        _instance.expectedOutputIds = _instance.expectedOutputIds || [];
+        _instance.retryOfIds = _instance.retryOfIds || [];
+        _instance.status = _instance.status || 0;
+        _instance.statusMessage = _instance.statusMessage || '';
+        _instance.options = _instance.options || undefined;
+        _instance.createdAt = _instance.createdAt || undefined;
+        _instance.submittedAt = _instance.submittedAt || undefined;
+        _instance.startedAt = _instance.startedAt || undefined;
+        _instance.endedAt = _instance.endedAt || undefined;
+        _instance.podTtl = _instance.podTtl || undefined;
+        _instance.output = _instance.output || undefined;
+        _instance.podHostname = _instance.podHostname || '';
+        _instance.receivedAt = _instance.receivedAt || undefined;
+        _instance.acquiredAt = _instance.acquiredAt || undefined;
+    }
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance, _reader) {
+        while (_reader.nextField()) {
+            if (_reader.isEndGroup())
+                break;
+            switch (_reader.getFieldNumber()) {
+                case 1:
+                    _instance.id = _reader.readString();
+                    break;
+                case 2:
+                    _instance.sessionId = _reader.readString();
+                    break;
+                case 3:
+                    _instance.ownerPodId = _reader.readString();
+                    break;
+                case 4:
+                    (_instance.parentTaskIds = _instance.parentTaskIds || []).push(_reader.readString());
+                    break;
+                case 5:
+                    (_instance.dataDependencies = _instance.dataDependencies || []).push(_reader.readString());
+                    break;
+                case 6:
+                    (_instance.expectedOutputIds =
+                        _instance.expectedOutputIds || []).push(_reader.readString());
+                    break;
+                case 7:
+                    (_instance.retryOfIds = _instance.retryOfIds || []).push(_reader.readString());
+                    break;
+                case 8:
+                    _instance.status = _reader.readEnum();
+                    break;
+                case 9:
+                    _instance.statusMessage = _reader.readString();
+                    break;
+                case 10:
+                    _instance.options = new armonikApiGrpcV1003.TaskOptions();
+                    _reader.readMessage(_instance.options, armonikApiGrpcV1003.TaskOptions.deserializeBinaryFromReader);
+                    break;
+                case 11:
+                    _instance.createdAt = new googleProtobuf002.Timestamp();
+                    _reader.readMessage(_instance.createdAt, googleProtobuf002.Timestamp.deserializeBinaryFromReader);
+                    break;
+                case 12:
+                    _instance.submittedAt = new googleProtobuf002.Timestamp();
+                    _reader.readMessage(_instance.submittedAt, googleProtobuf002.Timestamp.deserializeBinaryFromReader);
+                    break;
+                case 13:
+                    _instance.startedAt = new googleProtobuf002.Timestamp();
+                    _reader.readMessage(_instance.startedAt, googleProtobuf002.Timestamp.deserializeBinaryFromReader);
+                    break;
+                case 14:
+                    _instance.endedAt = new googleProtobuf002.Timestamp();
+                    _reader.readMessage(_instance.endedAt, googleProtobuf002.Timestamp.deserializeBinaryFromReader);
+                    break;
+                case 15:
+                    _instance.podTtl = new googleProtobuf002.Timestamp();
+                    _reader.readMessage(_instance.podTtl, googleProtobuf002.Timestamp.deserializeBinaryFromReader);
+                    break;
+                case 16:
+                    _instance.output = new TaskRaw.Output();
+                    _reader.readMessage(_instance.output, TaskRaw.Output.deserializeBinaryFromReader);
+                    break;
+                case 17:
+                    _instance.podHostname = _reader.readString();
+                    break;
+                case 18:
+                    _instance.receivedAt = new googleProtobuf002.Timestamp();
+                    _reader.readMessage(_instance.receivedAt, googleProtobuf002.Timestamp.deserializeBinaryFromReader);
+                    break;
+                case 19:
+                    _instance.acquiredAt = new googleProtobuf002.Timestamp();
+                    _reader.readMessage(_instance.acquiredAt, googleProtobuf002.Timestamp.deserializeBinaryFromReader);
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        TaskRaw.refineValues(_instance);
+    }
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance, _writer) {
+        if (_instance.id) {
+            _writer.writeString(1, _instance.id);
+        }
+        if (_instance.sessionId) {
+            _writer.writeString(2, _instance.sessionId);
+        }
+        if (_instance.ownerPodId) {
+            _writer.writeString(3, _instance.ownerPodId);
+        }
+        if (_instance.parentTaskIds && _instance.parentTaskIds.length) {
+            _writer.writeRepeatedString(4, _instance.parentTaskIds);
+        }
+        if (_instance.dataDependencies && _instance.dataDependencies.length) {
+            _writer.writeRepeatedString(5, _instance.dataDependencies);
+        }
+        if (_instance.expectedOutputIds && _instance.expectedOutputIds.length) {
+            _writer.writeRepeatedString(6, _instance.expectedOutputIds);
+        }
+        if (_instance.retryOfIds && _instance.retryOfIds.length) {
+            _writer.writeRepeatedString(7, _instance.retryOfIds);
+        }
+        if (_instance.status) {
+            _writer.writeEnum(8, _instance.status);
+        }
+        if (_instance.statusMessage) {
+            _writer.writeString(9, _instance.statusMessage);
+        }
+        if (_instance.options) {
+            _writer.writeMessage(10, _instance.options, armonikApiGrpcV1003.TaskOptions.serializeBinaryToWriter);
+        }
+        if (_instance.createdAt) {
+            _writer.writeMessage(11, _instance.createdAt, googleProtobuf002.Timestamp.serializeBinaryToWriter);
+        }
+        if (_instance.submittedAt) {
+            _writer.writeMessage(12, _instance.submittedAt, googleProtobuf002.Timestamp.serializeBinaryToWriter);
+        }
+        if (_instance.startedAt) {
+            _writer.writeMessage(13, _instance.startedAt, googleProtobuf002.Timestamp.serializeBinaryToWriter);
+        }
+        if (_instance.endedAt) {
+            _writer.writeMessage(14, _instance.endedAt, googleProtobuf002.Timestamp.serializeBinaryToWriter);
+        }
+        if (_instance.podTtl) {
+            _writer.writeMessage(15, _instance.podTtl, googleProtobuf002.Timestamp.serializeBinaryToWriter);
+        }
+        if (_instance.output) {
+            _writer.writeMessage(16, _instance.output, TaskRaw.Output.serializeBinaryToWriter);
+        }
+        if (_instance.podHostname) {
+            _writer.writeString(17, _instance.podHostname);
+        }
+        if (_instance.receivedAt) {
+            _writer.writeMessage(18, _instance.receivedAt, googleProtobuf002.Timestamp.serializeBinaryToWriter);
+        }
+        if (_instance.acquiredAt) {
+            _writer.writeMessage(19, _instance.acquiredAt, googleProtobuf002.Timestamp.serializeBinaryToWriter);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of TaskRaw to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.id = _value.id;
+        this.sessionId = _value.sessionId;
+        this.ownerPodId = _value.ownerPodId;
+        this.parentTaskIds = (_value.parentTaskIds || []).slice();
+        this.dataDependencies = (_value.dataDependencies || []).slice();
+        this.expectedOutputIds = (_value.expectedOutputIds || []).slice();
+        this.retryOfIds = (_value.retryOfIds || []).slice();
+        this.status = _value.status;
+        this.statusMessage = _value.statusMessage;
+        this.options = _value.options
+            ? new armonikApiGrpcV1003.TaskOptions(_value.options)
+            : undefined;
+        this.createdAt = _value.createdAt
+            ? new googleProtobuf002.Timestamp(_value.createdAt)
+            : undefined;
+        this.submittedAt = _value.submittedAt
+            ? new googleProtobuf002.Timestamp(_value.submittedAt)
+            : undefined;
+        this.startedAt = _value.startedAt
+            ? new googleProtobuf002.Timestamp(_value.startedAt)
+            : undefined;
+        this.endedAt = _value.endedAt
+            ? new googleProtobuf002.Timestamp(_value.endedAt)
+            : undefined;
+        this.podTtl = _value.podTtl
+            ? new googleProtobuf002.Timestamp(_value.podTtl)
+            : undefined;
+        this.output = _value.output ? new TaskRaw.Output(_value.output) : undefined;
+        this.podHostname = _value.podHostname;
+        this.receivedAt = _value.receivedAt
+            ? new googleProtobuf002.Timestamp(_value.receivedAt)
+            : undefined;
+        this.acquiredAt = _value.acquiredAt
+            ? new googleProtobuf002.Timestamp(_value.acquiredAt)
+            : undefined;
+        TaskRaw.refineValues(this);
+    }
+    get id() {
+        return this._id;
+    }
+    set id(value) {
+        this._id = value;
+    }
+    get sessionId() {
+        return this._sessionId;
+    }
+    set sessionId(value) {
+        this._sessionId = value;
+    }
+    get ownerPodId() {
+        return this._ownerPodId;
+    }
+    set ownerPodId(value) {
+        this._ownerPodId = value;
+    }
+    get parentTaskIds() {
+        return this._parentTaskIds;
+    }
+    set parentTaskIds(value) {
+        this._parentTaskIds = value;
+    }
+    get dataDependencies() {
+        return this._dataDependencies;
+    }
+    set dataDependencies(value) {
+        this._dataDependencies = value;
+    }
+    get expectedOutputIds() {
+        return this._expectedOutputIds;
+    }
+    set expectedOutputIds(value) {
+        this._expectedOutputIds = value;
+    }
+    get retryOfIds() {
+        return this._retryOfIds;
+    }
+    set retryOfIds(value) {
+        this._retryOfIds = value;
+    }
+    get status() {
+        return this._status;
+    }
+    set status(value) {
+        this._status = value;
+    }
+    get statusMessage() {
+        return this._statusMessage;
+    }
+    set statusMessage(value) {
+        this._statusMessage = value;
+    }
+    get options() {
+        return this._options;
+    }
+    set options(value) {
+        this._options = value;
+    }
+    get createdAt() {
+        return this._createdAt;
+    }
+    set createdAt(value) {
+        this._createdAt = value;
+    }
+    get submittedAt() {
+        return this._submittedAt;
+    }
+    set submittedAt(value) {
+        this._submittedAt = value;
+    }
+    get startedAt() {
+        return this._startedAt;
+    }
+    set startedAt(value) {
+        this._startedAt = value;
+    }
+    get endedAt() {
+        return this._endedAt;
+    }
+    set endedAt(value) {
+        this._endedAt = value;
+    }
+    get podTtl() {
+        return this._podTtl;
+    }
+    set podTtl(value) {
+        this._podTtl = value;
+    }
+    get output() {
+        return this._output;
+    }
+    set output(value) {
+        this._output = value;
+    }
+    get podHostname() {
+        return this._podHostname;
+    }
+    set podHostname(value) {
+        this._podHostname = value;
+    }
+    get receivedAt() {
+        return this._receivedAt;
+    }
+    set receivedAt(value) {
+        this._receivedAt = value;
+    }
+    get acquiredAt() {
+        return this._acquiredAt;
+    }
+    set acquiredAt(value) {
+        this._acquiredAt = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        TaskRaw.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            id: this.id,
+            sessionId: this.sessionId,
+            ownerPodId: this.ownerPodId,
+            parentTaskIds: (this.parentTaskIds || []).slice(),
+            dataDependencies: (this.dataDependencies || []).slice(),
+            expectedOutputIds: (this.expectedOutputIds || []).slice(),
+            retryOfIds: (this.retryOfIds || []).slice(),
+            status: this.status,
+            statusMessage: this.statusMessage,
+            options: this.options ? this.options.toObject() : undefined,
+            createdAt: this.createdAt ? this.createdAt.toObject() : undefined,
+            submittedAt: this.submittedAt ? this.submittedAt.toObject() : undefined,
+            startedAt: this.startedAt ? this.startedAt.toObject() : undefined,
+            endedAt: this.endedAt ? this.endedAt.toObject() : undefined,
+            podTtl: this.podTtl ? this.podTtl.toObject() : undefined,
+            output: this.output ? this.output.toObject() : undefined,
+            podHostname: this.podHostname,
+            receivedAt: this.receivedAt ? this.receivedAt.toObject() : undefined,
+            acquiredAt: this.acquiredAt ? this.acquiredAt.toObject() : undefined
+        };
+    }
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON() {
+        return this.toObject();
+    }
+    /**
+     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+     */
+    toProtobufJSON(
+    // @ts-ignore
+    options) {
+        return {
+            id: this.id,
+            sessionId: this.sessionId,
+            ownerPodId: this.ownerPodId,
+            parentTaskIds: (this.parentTaskIds || []).slice(),
+            dataDependencies: (this.dataDependencies || []).slice(),
+            expectedOutputIds: (this.expectedOutputIds || []).slice(),
+            retryOfIds: (this.retryOfIds || []).slice(),
+            status: armonikApiGrpcV1Task_status001.TaskStatus[this.status === null || this.status === undefined ? 0 : this.status],
+            statusMessage: this.statusMessage,
+            options: this.options ? this.options.toProtobufJSON(options) : null,
+            createdAt: this.createdAt ? this.createdAt.toProtobufJSON(options) : null,
+            submittedAt: this.submittedAt
+                ? this.submittedAt.toProtobufJSON(options)
+                : null,
+            startedAt: this.startedAt ? this.startedAt.toProtobufJSON(options) : null,
+            endedAt: this.endedAt ? this.endedAt.toProtobufJSON(options) : null,
+            podTtl: this.podTtl ? this.podTtl.toProtobufJSON(options) : null,
+            output: this.output ? this.output.toProtobufJSON(options) : null,
+            podHostname: this.podHostname,
+            receivedAt: this.receivedAt
+                ? this.receivedAt.toProtobufJSON(options)
+                : null,
+            acquiredAt: this.acquiredAt
+                ? this.acquiredAt.toProtobufJSON(options)
+                : null
+        };
+    }
+}
+TaskRaw.id = 'armonik.api.grpc.v1.tasks.TaskRaw';
+(function (TaskRaw) {
+    /**
+     * Message implementation for armonik.api.grpc.v1.tasks.TaskRaw.Output
+     */
+    class Output {
+        /**
+         * Deserialize binary data to message
+         * @param instance message instance
+         */
+        static deserializeBinary(bytes) {
+            const instance = new Output();
+            Output.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+            return instance;
+        }
+        /**
+         * Check all the properties and set default protobuf values if necessary
+         * @param _instance message instance
+         */
+        static refineValues(_instance) {
+            _instance.success = _instance.success || false;
+            _instance.error = _instance.error || '';
+        }
+        /**
+         * Deserializes / reads binary message into message instance using provided binary reader
+         * @param _instance message instance
+         * @param _reader binary reader instance
+         */
+        static deserializeBinaryFromReader(_instance, _reader) {
+            while (_reader.nextField()) {
+                if (_reader.isEndGroup())
+                    break;
+                switch (_reader.getFieldNumber()) {
+                    case 1:
+                        _instance.success = _reader.readBool();
+                        break;
+                    case 2:
+                        _instance.error = _reader.readString();
+                        break;
+                    default:
+                        _reader.skipField();
+                }
+            }
+            Output.refineValues(_instance);
+        }
+        /**
+         * Serializes a message to binary format using provided binary reader
+         * @param _instance message instance
+         * @param _writer binary writer instance
+         */
+        static serializeBinaryToWriter(_instance, _writer) {
+            if (_instance.success) {
+                _writer.writeBool(1, _instance.success);
+            }
+            if (_instance.error) {
+                _writer.writeString(2, _instance.error);
+            }
+        }
+        /**
+         * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+         * @param _value initial values object or instance of Output to deeply clone from
+         */
+        constructor(_value) {
+            _value = _value || {};
+            this.success = _value.success;
+            this.error = _value.error;
+            Output.refineValues(this);
+        }
+        get success() {
+            return this._success;
+        }
+        set success(value) {
+            this._success = value;
+        }
+        get error() {
+            return this._error;
+        }
+        set error(value) {
+            this._error = value;
+        }
+        /**
+         * Serialize message to binary data
+         * @param instance message instance
+         */
+        serializeBinary() {
+            const writer = new BinaryWriter();
+            Output.serializeBinaryToWriter(this, writer);
+            return writer.getResultBuffer();
+        }
+        /**
+         * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+         */
+        toObject() {
+            return {
+                success: this.success,
+                error: this.error
+            };
+        }
+        /**
+         * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+         */
+        toJSON() {
+            return this.toObject();
+        }
+        /**
+         * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+         * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+         * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+         */
+        toProtobufJSON(
+        // @ts-ignore
+        options) {
+            return {
+                success: this.success,
+                error: this.error
+            };
+        }
+    }
+    Output.id = 'armonik.api.grpc.v1.tasks.TaskRaw.Output';
+    TaskRaw.Output = Output;
+})(TaskRaw || (TaskRaw = {}));
+/**
+ * Message implementation for armonik.api.grpc.v1.tasks.TaskSummary
+ */
+export class TaskSummary {
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new TaskSummary();
+        TaskSummary.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+        return instance;
+    }
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance) {
+        _instance.id = _instance.id || '';
+        _instance.sessionId = _instance.sessionId || '';
+        _instance.options = _instance.options || undefined;
+        _instance.status = _instance.status || 0;
+        _instance.createdAt = _instance.createdAt || undefined;
+        _instance.startedAt = _instance.startedAt || undefined;
+        _instance.endedAt = _instance.endedAt || undefined;
+        _instance.error = _instance.error || '';
+    }
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance, _reader) {
+        while (_reader.nextField()) {
+            if (_reader.isEndGroup())
+                break;
+            switch (_reader.getFieldNumber()) {
+                case 1:
+                    _instance.id = _reader.readString();
+                    break;
+                case 2:
+                    _instance.sessionId = _reader.readString();
+                    break;
+                case 3:
+                    _instance.options = new armonikApiGrpcV1003.TaskOptions();
+                    _reader.readMessage(_instance.options, armonikApiGrpcV1003.TaskOptions.deserializeBinaryFromReader);
+                    break;
+                case 4:
+                    _instance.status = _reader.readEnum();
+                    break;
+                case 5:
+                    _instance.createdAt = new googleProtobuf002.Timestamp();
+                    _reader.readMessage(_instance.createdAt, googleProtobuf002.Timestamp.deserializeBinaryFromReader);
+                    break;
+                case 6:
+                    _instance.startedAt = new googleProtobuf002.Timestamp();
+                    _reader.readMessage(_instance.startedAt, googleProtobuf002.Timestamp.deserializeBinaryFromReader);
+                    break;
+                case 7:
+                    _instance.endedAt = new googleProtobuf002.Timestamp();
+                    _reader.readMessage(_instance.endedAt, googleProtobuf002.Timestamp.deserializeBinaryFromReader);
+                    break;
+                case 8:
+                    _instance.error = _reader.readString();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        TaskSummary.refineValues(_instance);
+    }
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance, _writer) {
+        if (_instance.id) {
+            _writer.writeString(1, _instance.id);
+        }
+        if (_instance.sessionId) {
+            _writer.writeString(2, _instance.sessionId);
+        }
+        if (_instance.options) {
+            _writer.writeMessage(3, _instance.options, armonikApiGrpcV1003.TaskOptions.serializeBinaryToWriter);
+        }
+        if (_instance.status) {
+            _writer.writeEnum(4, _instance.status);
+        }
+        if (_instance.createdAt) {
+            _writer.writeMessage(5, _instance.createdAt, googleProtobuf002.Timestamp.serializeBinaryToWriter);
+        }
+        if (_instance.startedAt) {
+            _writer.writeMessage(6, _instance.startedAt, googleProtobuf002.Timestamp.serializeBinaryToWriter);
+        }
+        if (_instance.endedAt) {
+            _writer.writeMessage(7, _instance.endedAt, googleProtobuf002.Timestamp.serializeBinaryToWriter);
+        }
+        if (_instance.error) {
+            _writer.writeString(8, _instance.error);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of TaskSummary to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.id = _value.id;
+        this.sessionId = _value.sessionId;
+        this.options = _value.options
+            ? new armonikApiGrpcV1003.TaskOptions(_value.options)
+            : undefined;
+        this.status = _value.status;
+        this.createdAt = _value.createdAt
+            ? new googleProtobuf002.Timestamp(_value.createdAt)
+            : undefined;
+        this.startedAt = _value.startedAt
+            ? new googleProtobuf002.Timestamp(_value.startedAt)
+            : undefined;
+        this.endedAt = _value.endedAt
+            ? new googleProtobuf002.Timestamp(_value.endedAt)
+            : undefined;
+        this.error = _value.error;
+        TaskSummary.refineValues(this);
+    }
+    get id() {
+        return this._id;
+    }
+    set id(value) {
+        this._id = value;
+    }
+    get sessionId() {
+        return this._sessionId;
+    }
+    set sessionId(value) {
+        this._sessionId = value;
+    }
+    get options() {
+        return this._options;
+    }
+    set options(value) {
+        this._options = value;
+    }
+    get status() {
+        return this._status;
+    }
+    set status(value) {
+        this._status = value;
+    }
+    get createdAt() {
+        return this._createdAt;
+    }
+    set createdAt(value) {
+        this._createdAt = value;
+    }
+    get startedAt() {
+        return this._startedAt;
+    }
+    set startedAt(value) {
+        this._startedAt = value;
+    }
+    get endedAt() {
+        return this._endedAt;
+    }
+    set endedAt(value) {
+        this._endedAt = value;
+    }
+    get error() {
+        return this._error;
+    }
+    set error(value) {
+        this._error = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        TaskSummary.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            id: this.id,
+            sessionId: this.sessionId,
+            options: this.options ? this.options.toObject() : undefined,
+            status: this.status,
+            createdAt: this.createdAt ? this.createdAt.toObject() : undefined,
+            startedAt: this.startedAt ? this.startedAt.toObject() : undefined,
+            endedAt: this.endedAt ? this.endedAt.toObject() : undefined,
+            error: this.error
+        };
+    }
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON() {
+        return this.toObject();
+    }
+    /**
+     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+     */
+    toProtobufJSON(
+    // @ts-ignore
+    options) {
+        return {
+            id: this.id,
+            sessionId: this.sessionId,
+            options: this.options ? this.options.toProtobufJSON(options) : null,
+            status: armonikApiGrpcV1Task_status001.TaskStatus[this.status === null || this.status === undefined ? 0 : this.status],
+            createdAt: this.createdAt ? this.createdAt.toProtobufJSON(options) : null,
+            startedAt: this.startedAt ? this.startedAt.toProtobufJSON(options) : null,
+            endedAt: this.endedAt ? this.endedAt.toProtobufJSON(options) : null,
+            error: this.error
+        };
+    }
+}
+TaskSummary.id = 'armonik.api.grpc.v1.tasks.TaskSummary';
+/**
+ * Message implementation for armonik.api.grpc.v1.tasks.ListTasksRequest
+ */
+export class ListTasksRequest {
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new ListTasksRequest();
+        ListTasksRequest.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+        return instance;
+    }
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance) {
+        _instance.page = _instance.page || 0;
+        _instance.pageSize = _instance.pageSize || 0;
+        _instance.filter = _instance.filter || undefined;
+        _instance.sort = _instance.sort || undefined;
+        _instance.withErrors = _instance.withErrors || false;
+    }
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance, _reader) {
+        while (_reader.nextField()) {
+            if (_reader.isEndGroup())
+                break;
+            switch (_reader.getFieldNumber()) {
+                case 1:
+                    _instance.page = _reader.readInt32();
+                    break;
+                case 2:
+                    _instance.pageSize = _reader.readInt32();
+                    break;
+                case 3:
+                    _instance.filter = new ListTasksRequest.Filter();
+                    _reader.readMessage(_instance.filter, ListTasksRequest.Filter.deserializeBinaryFromReader);
+                    break;
+                case 4:
+                    _instance.sort = new ListTasksRequest.Sort();
+                    _reader.readMessage(_instance.sort, ListTasksRequest.Sort.deserializeBinaryFromReader);
+                    break;
+                case 5:
+                    _instance.withErrors = _reader.readBool();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        ListTasksRequest.refineValues(_instance);
+    }
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance, _writer) {
+        if (_instance.page) {
+            _writer.writeInt32(1, _instance.page);
+        }
+        if (_instance.pageSize) {
+            _writer.writeInt32(2, _instance.pageSize);
+        }
+        if (_instance.filter) {
+            _writer.writeMessage(3, _instance.filter, ListTasksRequest.Filter.serializeBinaryToWriter);
+        }
+        if (_instance.sort) {
+            _writer.writeMessage(4, _instance.sort, ListTasksRequest.Sort.serializeBinaryToWriter);
+        }
+        if (_instance.withErrors) {
+            _writer.writeBool(5, _instance.withErrors);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of ListTasksRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.page = _value.page;
+        this.pageSize = _value.pageSize;
+        this.filter = _value.filter
+            ? new ListTasksRequest.Filter(_value.filter)
+            : undefined;
+        this.sort = _value.sort
+            ? new ListTasksRequest.Sort(_value.sort)
+            : undefined;
+        this.withErrors = _value.withErrors;
+        ListTasksRequest.refineValues(this);
+    }
+    get page() {
+        return this._page;
+    }
+    set page(value) {
+        this._page = value;
+    }
+    get pageSize() {
+        return this._pageSize;
+    }
+    set pageSize(value) {
+        this._pageSize = value;
+    }
+    get filter() {
+        return this._filter;
+    }
+    set filter(value) {
+        this._filter = value;
+    }
+    get sort() {
+        return this._sort;
+    }
+    set sort(value) {
+        this._sort = value;
+    }
+    get withErrors() {
+        return this._withErrors;
+    }
+    set withErrors(value) {
+        this._withErrors = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        ListTasksRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            page: this.page,
+            pageSize: this.pageSize,
+            filter: this.filter ? this.filter.toObject() : undefined,
+            sort: this.sort ? this.sort.toObject() : undefined,
+            withErrors: this.withErrors
+        };
+    }
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON() {
+        return this.toObject();
+    }
+    /**
+     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+     */
+    toProtobufJSON(
+    // @ts-ignore
+    options) {
+        return {
+            page: this.page,
+            pageSize: this.pageSize,
+            filter: this.filter ? this.filter.toProtobufJSON(options) : null,
+            sort: this.sort ? this.sort.toProtobufJSON(options) : null,
+            withErrors: this.withErrors
+        };
+    }
+}
+ListTasksRequest.id = 'armonik.api.grpc.v1.tasks.ListTasksRequest';
+(function (ListTasksRequest) {
+    let OrderByField;
+    (function (OrderByField) {
+        OrderByField[OrderByField["ORDER_BY_FIELD_UNSPECIFIED"] = 0] = "ORDER_BY_FIELD_UNSPECIFIED";
+        OrderByField[OrderByField["ORDER_BY_FIELD_TASK_ID"] = 1] = "ORDER_BY_FIELD_TASK_ID";
+        OrderByField[OrderByField["ORDER_BY_FIELD_SESSION_ID"] = 2] = "ORDER_BY_FIELD_SESSION_ID";
+        OrderByField[OrderByField["ORDER_BY_FIELD_STATUS"] = 3] = "ORDER_BY_FIELD_STATUS";
+        OrderByField[OrderByField["ORDER_BY_FIELD_CREATED_AT"] = 4] = "ORDER_BY_FIELD_CREATED_AT";
+        OrderByField[OrderByField["ORDER_BY_FIELD_STARTED_AT"] = 5] = "ORDER_BY_FIELD_STARTED_AT";
+        OrderByField[OrderByField["ORDER_BY_FIELD_ENDED_AT"] = 6] = "ORDER_BY_FIELD_ENDED_AT";
+    })(OrderByField = ListTasksRequest.OrderByField || (ListTasksRequest.OrderByField = {}));
+    let OrderDirection;
+    (function (OrderDirection) {
+        OrderDirection[OrderDirection["ORDER_DIRECTION_UNSPECIFIED"] = 0] = "ORDER_DIRECTION_UNSPECIFIED";
+        OrderDirection[OrderDirection["ORDER_DIRECTION_ASC"] = 1] = "ORDER_DIRECTION_ASC";
+        OrderDirection[OrderDirection["ORDER_DIRECTION_DESC"] = 2] = "ORDER_DIRECTION_DESC";
+    })(OrderDirection = ListTasksRequest.OrderDirection || (ListTasksRequest.OrderDirection = {}));
+    /**
+     * Message implementation for armonik.api.grpc.v1.tasks.ListTasksRequest.Filter
+     */
+    class Filter {
+        /**
+         * Deserialize binary data to message
+         * @param instance message instance
+         */
+        static deserializeBinary(bytes) {
+            const instance = new Filter();
+            Filter.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+            return instance;
+        }
+        /**
+         * Check all the properties and set default protobuf values if necessary
+         * @param _instance message instance
+         */
+        static refineValues(_instance) {
+            _instance.sessionId = _instance.sessionId || '';
+            _instance.status = _instance.status || [];
+            _instance.createdAfter = _instance.createdAfter || undefined;
+            _instance.createdBefore = _instance.createdBefore || undefined;
+            _instance.startedAfter = _instance.startedAfter || undefined;
+            _instance.startedBefore = _instance.startedBefore || undefined;
+            _instance.endedAfter = _instance.endedAfter || undefined;
+            _instance.endedBefore = _instance.endedBefore || undefined;
+        }
+        /**
+         * Deserializes / reads binary message into message instance using provided binary reader
+         * @param _instance message instance
+         * @param _reader binary reader instance
+         */
+        static deserializeBinaryFromReader(_instance, _reader) {
+            while (_reader.nextField()) {
+                if (_reader.isEndGroup())
+                    break;
+                switch (_reader.getFieldNumber()) {
+                    case 1:
+                        _instance.sessionId = _reader.readString();
+                        break;
+                    case 2:
+                        (_instance.status = _instance.status || []).push(...(_reader.readPackedEnum() || []));
+                        break;
+                    case 3:
+                        _instance.createdAfter = new googleProtobuf002.Timestamp();
+                        _reader.readMessage(_instance.createdAfter, googleProtobuf002.Timestamp.deserializeBinaryFromReader);
+                        break;
+                    case 4:
+                        _instance.createdBefore = new googleProtobuf002.Timestamp();
+                        _reader.readMessage(_instance.createdBefore, googleProtobuf002.Timestamp.deserializeBinaryFromReader);
+                        break;
+                    case 5:
+                        _instance.startedAfter = new googleProtobuf002.Timestamp();
+                        _reader.readMessage(_instance.startedAfter, googleProtobuf002.Timestamp.deserializeBinaryFromReader);
+                        break;
+                    case 6:
+                        _instance.startedBefore = new googleProtobuf002.Timestamp();
+                        _reader.readMessage(_instance.startedBefore, googleProtobuf002.Timestamp.deserializeBinaryFromReader);
+                        break;
+                    case 7:
+                        _instance.endedAfter = new googleProtobuf002.Timestamp();
+                        _reader.readMessage(_instance.endedAfter, googleProtobuf002.Timestamp.deserializeBinaryFromReader);
+                        break;
+                    case 8:
+                        _instance.endedBefore = new googleProtobuf002.Timestamp();
+                        _reader.readMessage(_instance.endedBefore, googleProtobuf002.Timestamp.deserializeBinaryFromReader);
+                        break;
+                    default:
+                        _reader.skipField();
+                }
+            }
+            Filter.refineValues(_instance);
+        }
+        /**
+         * Serializes a message to binary format using provided binary reader
+         * @param _instance message instance
+         * @param _writer binary writer instance
+         */
+        static serializeBinaryToWriter(_instance, _writer) {
+            if (_instance.sessionId) {
+                _writer.writeString(1, _instance.sessionId);
+            }
+            if (_instance.status && _instance.status.length) {
+                _writer.writePackedEnum(2, _instance.status);
+            }
+            if (_instance.createdAfter) {
+                _writer.writeMessage(3, _instance.createdAfter, googleProtobuf002.Timestamp.serializeBinaryToWriter);
+            }
+            if (_instance.createdBefore) {
+                _writer.writeMessage(4, _instance.createdBefore, googleProtobuf002.Timestamp.serializeBinaryToWriter);
+            }
+            if (_instance.startedAfter) {
+                _writer.writeMessage(5, _instance.startedAfter, googleProtobuf002.Timestamp.serializeBinaryToWriter);
+            }
+            if (_instance.startedBefore) {
+                _writer.writeMessage(6, _instance.startedBefore, googleProtobuf002.Timestamp.serializeBinaryToWriter);
+            }
+            if (_instance.endedAfter) {
+                _writer.writeMessage(7, _instance.endedAfter, googleProtobuf002.Timestamp.serializeBinaryToWriter);
+            }
+            if (_instance.endedBefore) {
+                _writer.writeMessage(8, _instance.endedBefore, googleProtobuf002.Timestamp.serializeBinaryToWriter);
+            }
+        }
+        /**
+         * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+         * @param _value initial values object or instance of Filter to deeply clone from
+         */
+        constructor(_value) {
+            _value = _value || {};
+            this.sessionId = _value.sessionId;
+            this.status = (_value.status || []).slice();
+            this.createdAfter = _value.createdAfter
+                ? new googleProtobuf002.Timestamp(_value.createdAfter)
+                : undefined;
+            this.createdBefore = _value.createdBefore
+                ? new googleProtobuf002.Timestamp(_value.createdBefore)
+                : undefined;
+            this.startedAfter = _value.startedAfter
+                ? new googleProtobuf002.Timestamp(_value.startedAfter)
+                : undefined;
+            this.startedBefore = _value.startedBefore
+                ? new googleProtobuf002.Timestamp(_value.startedBefore)
+                : undefined;
+            this.endedAfter = _value.endedAfter
+                ? new googleProtobuf002.Timestamp(_value.endedAfter)
+                : undefined;
+            this.endedBefore = _value.endedBefore
+                ? new googleProtobuf002.Timestamp(_value.endedBefore)
+                : undefined;
+            Filter.refineValues(this);
+        }
+        get sessionId() {
+            return this._sessionId;
+        }
+        set sessionId(value) {
+            this._sessionId = value;
+        }
+        get status() {
+            return this._status;
+        }
+        set status(value) {
+            this._status = value;
+        }
+        get createdAfter() {
+            return this._createdAfter;
+        }
+        set createdAfter(value) {
+            this._createdAfter = value;
+        }
+        get createdBefore() {
+            return this._createdBefore;
+        }
+        set createdBefore(value) {
+            this._createdBefore = value;
+        }
+        get startedAfter() {
+            return this._startedAfter;
+        }
+        set startedAfter(value) {
+            this._startedAfter = value;
+        }
+        get startedBefore() {
+            return this._startedBefore;
+        }
+        set startedBefore(value) {
+            this._startedBefore = value;
+        }
+        get endedAfter() {
+            return this._endedAfter;
+        }
+        set endedAfter(value) {
+            this._endedAfter = value;
+        }
+        get endedBefore() {
+            return this._endedBefore;
+        }
+        set endedBefore(value) {
+            this._endedBefore = value;
+        }
+        /**
+         * Serialize message to binary data
+         * @param instance message instance
+         */
+        serializeBinary() {
+            const writer = new BinaryWriter();
+            Filter.serializeBinaryToWriter(this, writer);
+            return writer.getResultBuffer();
+        }
+        /**
+         * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+         */
+        toObject() {
+            return {
+                sessionId: this.sessionId,
+                status: (this.status || []).slice(),
+                createdAfter: this.createdAfter
+                    ? this.createdAfter.toObject()
+                    : undefined,
+                createdBefore: this.createdBefore
+                    ? this.createdBefore.toObject()
+                    : undefined,
+                startedAfter: this.startedAfter
+                    ? this.startedAfter.toObject()
+                    : undefined,
+                startedBefore: this.startedBefore
+                    ? this.startedBefore.toObject()
+                    : undefined,
+                endedAfter: this.endedAfter ? this.endedAfter.toObject() : undefined,
+                endedBefore: this.endedBefore ? this.endedBefore.toObject() : undefined
+            };
+        }
+        /**
+         * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+         */
+        toJSON() {
+            return this.toObject();
+        }
+        /**
+         * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+         * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+         * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+         */
+        toProtobufJSON(
+        // @ts-ignore
+        options) {
+            return {
+                sessionId: this.sessionId,
+                status: (this.status || []).map(v => armonikApiGrpcV1Task_status001.TaskStatus[v]),
+                createdAfter: this.createdAfter
+                    ? this.createdAfter.toProtobufJSON(options)
+                    : null,
+                createdBefore: this.createdBefore
+                    ? this.createdBefore.toProtobufJSON(options)
+                    : null,
+                startedAfter: this.startedAfter
+                    ? this.startedAfter.toProtobufJSON(options)
+                    : null,
+                startedBefore: this.startedBefore
+                    ? this.startedBefore.toProtobufJSON(options)
+                    : null,
+                endedAfter: this.endedAfter
+                    ? this.endedAfter.toProtobufJSON(options)
+                    : null,
+                endedBefore: this.endedBefore
+                    ? this.endedBefore.toProtobufJSON(options)
+                    : null
+            };
+        }
+    }
+    Filter.id = 'armonik.api.grpc.v1.tasks.ListTasksRequest.Filter';
+    ListTasksRequest.Filter = Filter;
+    /**
+     * Message implementation for armonik.api.grpc.v1.tasks.ListTasksRequest.Sort
+     */
+    class Sort {
+        /**
+         * Deserialize binary data to message
+         * @param instance message instance
+         */
+        static deserializeBinary(bytes) {
+            const instance = new Sort();
+            Sort.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+            return instance;
+        }
+        /**
+         * Check all the properties and set default protobuf values if necessary
+         * @param _instance message instance
+         */
+        static refineValues(_instance) {
+            _instance.field = _instance.field || 0;
+            _instance.direction = _instance.direction || 0;
+        }
+        /**
+         * Deserializes / reads binary message into message instance using provided binary reader
+         * @param _instance message instance
+         * @param _reader binary reader instance
+         */
+        static deserializeBinaryFromReader(_instance, _reader) {
+            while (_reader.nextField()) {
+                if (_reader.isEndGroup())
+                    break;
+                switch (_reader.getFieldNumber()) {
+                    case 1:
+                        _instance.field = _reader.readEnum();
+                        break;
+                    case 2:
+                        _instance.direction = _reader.readEnum();
+                        break;
+                    default:
+                        _reader.skipField();
+                }
+            }
+            Sort.refineValues(_instance);
+        }
+        /**
+         * Serializes a message to binary format using provided binary reader
+         * @param _instance message instance
+         * @param _writer binary writer instance
+         */
+        static serializeBinaryToWriter(_instance, _writer) {
+            if (_instance.field) {
+                _writer.writeEnum(1, _instance.field);
+            }
+            if (_instance.direction) {
+                _writer.writeEnum(2, _instance.direction);
+            }
+        }
+        /**
+         * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+         * @param _value initial values object or instance of Sort to deeply clone from
+         */
+        constructor(_value) {
+            _value = _value || {};
+            this.field = _value.field;
+            this.direction = _value.direction;
+            Sort.refineValues(this);
+        }
+        get field() {
+            return this._field;
+        }
+        set field(value) {
+            this._field = value;
+        }
+        get direction() {
+            return this._direction;
+        }
+        set direction(value) {
+            this._direction = value;
+        }
+        /**
+         * Serialize message to binary data
+         * @param instance message instance
+         */
+        serializeBinary() {
+            const writer = new BinaryWriter();
+            Sort.serializeBinaryToWriter(this, writer);
+            return writer.getResultBuffer();
+        }
+        /**
+         * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+         */
+        toObject() {
+            return {
+                field: this.field,
+                direction: this.direction
+            };
+        }
+        /**
+         * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+         */
+        toJSON() {
+            return this.toObject();
+        }
+        /**
+         * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+         * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+         * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+         */
+        toProtobufJSON(
+        // @ts-ignore
+        options) {
+            return {
+                field: ListTasksRequest.OrderByField[this.field === null || this.field === undefined ? 0 : this.field],
+                direction: ListTasksRequest.OrderDirection[this.direction === null || this.direction === undefined
+                    ? 0
+                    : this.direction]
+            };
+        }
+    }
+    Sort.id = 'armonik.api.grpc.v1.tasks.ListTasksRequest.Sort';
+    ListTasksRequest.Sort = Sort;
+})(ListTasksRequest || (ListTasksRequest = {}));
+/**
+ * Message implementation for armonik.api.grpc.v1.tasks.ListTasksResponse
+ */
+export class ListTasksResponse {
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new ListTasksResponse();
+        ListTasksResponse.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+        return instance;
+    }
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance) {
+        _instance.tasks = _instance.tasks || [];
+        _instance.page = _instance.page || 0;
+        _instance.pageSize = _instance.pageSize || 0;
+        _instance.total = _instance.total || 0;
+    }
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance, _reader) {
+        while (_reader.nextField()) {
+            if (_reader.isEndGroup())
+                break;
+            switch (_reader.getFieldNumber()) {
+                case 1:
+                    const messageInitializer1 = new TaskSummary();
+                    _reader.readMessage(messageInitializer1, TaskSummary.deserializeBinaryFromReader);
+                    (_instance.tasks = _instance.tasks || []).push(messageInitializer1);
+                    break;
+                case 2:
+                    _instance.page = _reader.readInt32();
+                    break;
+                case 3:
+                    _instance.pageSize = _reader.readInt32();
+                    break;
+                case 4:
+                    _instance.total = _reader.readInt32();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        ListTasksResponse.refineValues(_instance);
+    }
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance, _writer) {
+        if (_instance.tasks && _instance.tasks.length) {
+            _writer.writeRepeatedMessage(1, _instance.tasks, TaskSummary.serializeBinaryToWriter);
+        }
+        if (_instance.page) {
+            _writer.writeInt32(2, _instance.page);
+        }
+        if (_instance.pageSize) {
+            _writer.writeInt32(3, _instance.pageSize);
+        }
+        if (_instance.total) {
+            _writer.writeInt32(4, _instance.total);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of ListTasksResponse to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.tasks = (_value.tasks || []).map(m => new TaskSummary(m));
+        this.page = _value.page;
+        this.pageSize = _value.pageSize;
+        this.total = _value.total;
+        ListTasksResponse.refineValues(this);
+    }
+    get tasks() {
+        return this._tasks;
+    }
+    set tasks(value) {
+        this._tasks = value;
+    }
+    get page() {
+        return this._page;
+    }
+    set page(value) {
+        this._page = value;
+    }
+    get pageSize() {
+        return this._pageSize;
+    }
+    set pageSize(value) {
+        this._pageSize = value;
+    }
+    get total() {
+        return this._total;
+    }
+    set total(value) {
+        this._total = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        ListTasksResponse.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            tasks: (this.tasks || []).map(m => m.toObject()),
+            page: this.page,
+            pageSize: this.pageSize,
+            total: this.total
+        };
+    }
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON() {
+        return this.toObject();
+    }
+    /**
+     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+     */
+    toProtobufJSON(
+    // @ts-ignore
+    options) {
+        return {
+            tasks: (this.tasks || []).map(m => m.toProtobufJSON(options)),
+            page: this.page,
+            pageSize: this.pageSize,
+            total: this.total
+        };
+    }
+}
+ListTasksResponse.id = 'armonik.api.grpc.v1.tasks.ListTasksResponse';
+/**
+ * Message implementation for armonik.api.grpc.v1.tasks.GetTaskRequest
+ */
+export class GetTaskRequest {
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new GetTaskRequest();
+        GetTaskRequest.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+        return instance;
+    }
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance) {
+        _instance.taskId = _instance.taskId || '';
+    }
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance, _reader) {
+        while (_reader.nextField()) {
+            if (_reader.isEndGroup())
+                break;
+            switch (_reader.getFieldNumber()) {
+                case 1:
+                    _instance.taskId = _reader.readString();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        GetTaskRequest.refineValues(_instance);
+    }
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance, _writer) {
+        if (_instance.taskId) {
+            _writer.writeString(1, _instance.taskId);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of GetTaskRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.taskId = _value.taskId;
+        GetTaskRequest.refineValues(this);
+    }
+    get taskId() {
+        return this._taskId;
+    }
+    set taskId(value) {
+        this._taskId = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        GetTaskRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            taskId: this.taskId
+        };
+    }
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON() {
+        return this.toObject();
+    }
+    /**
+     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+     */
+    toProtobufJSON(
+    // @ts-ignore
+    options) {
+        return {
+            taskId: this.taskId
+        };
+    }
+}
+GetTaskRequest.id = 'armonik.api.grpc.v1.tasks.GetTaskRequest';
+/**
+ * Message implementation for armonik.api.grpc.v1.tasks.GetTaskResponse
+ */
+export class GetTaskResponse {
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new GetTaskResponse();
+        GetTaskResponse.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+        return instance;
+    }
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance) {
+        _instance.task = _instance.task || undefined;
+    }
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance, _reader) {
+        while (_reader.nextField()) {
+            if (_reader.isEndGroup())
+                break;
+            switch (_reader.getFieldNumber()) {
+                case 1:
+                    _instance.task = new TaskRaw();
+                    _reader.readMessage(_instance.task, TaskRaw.deserializeBinaryFromReader);
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        GetTaskResponse.refineValues(_instance);
+    }
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance, _writer) {
+        if (_instance.task) {
+            _writer.writeMessage(1, _instance.task, TaskRaw.serializeBinaryToWriter);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of GetTaskResponse to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.task = _value.task ? new TaskRaw(_value.task) : undefined;
+        GetTaskResponse.refineValues(this);
+    }
+    get task() {
+        return this._task;
+    }
+    set task(value) {
+        this._task = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        GetTaskResponse.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            task: this.task ? this.task.toObject() : undefined
+        };
+    }
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON() {
+        return this.toObject();
+    }
+    /**
+     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+     */
+    toProtobufJSON(
+    // @ts-ignore
+    options) {
+        return {
+            task: this.task ? this.task.toProtobufJSON(options) : null
+        };
+    }
+}
+GetTaskResponse.id = 'armonik.api.grpc.v1.tasks.GetTaskResponse';
+/**
+ * Message implementation for armonik.api.grpc.v1.tasks.CancelTasksRequest
+ */
+export class CancelTasksRequest {
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new CancelTasksRequest();
+        CancelTasksRequest.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+        return instance;
+    }
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance) {
+        _instance.taskIds = _instance.taskIds || [];
+    }
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance, _reader) {
+        while (_reader.nextField()) {
+            if (_reader.isEndGroup())
+                break;
+            switch (_reader.getFieldNumber()) {
+                case 1:
+                    (_instance.taskIds = _instance.taskIds || []).push(_reader.readString());
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        CancelTasksRequest.refineValues(_instance);
+    }
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance, _writer) {
+        if (_instance.taskIds && _instance.taskIds.length) {
+            _writer.writeRepeatedString(1, _instance.taskIds);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of CancelTasksRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.taskIds = (_value.taskIds || []).slice();
+        CancelTasksRequest.refineValues(this);
+    }
+    get taskIds() {
+        return this._taskIds;
+    }
+    set taskIds(value) {
+        this._taskIds = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        CancelTasksRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            taskIds: (this.taskIds || []).slice()
+        };
+    }
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON() {
+        return this.toObject();
+    }
+    /**
+     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+     */
+    toProtobufJSON(
+    // @ts-ignore
+    options) {
+        return {
+            taskIds: (this.taskIds || []).slice()
+        };
+    }
+}
+CancelTasksRequest.id = 'armonik.api.grpc.v1.tasks.CancelTasksRequest';
+/**
+ * Message implementation for armonik.api.grpc.v1.tasks.CancelTasksResponse
+ */
+export class CancelTasksResponse {
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new CancelTasksResponse();
+        CancelTasksResponse.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+        return instance;
+    }
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance) {
+        _instance.tasks = _instance.tasks || [];
+    }
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance, _reader) {
+        while (_reader.nextField()) {
+            if (_reader.isEndGroup())
+                break;
+            switch (_reader.getFieldNumber()) {
+                case 1:
+                    const messageInitializer1 = new TaskSummary();
+                    _reader.readMessage(messageInitializer1, TaskSummary.deserializeBinaryFromReader);
+                    (_instance.tasks = _instance.tasks || []).push(messageInitializer1);
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        CancelTasksResponse.refineValues(_instance);
+    }
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance, _writer) {
+        if (_instance.tasks && _instance.tasks.length) {
+            _writer.writeRepeatedMessage(1, _instance.tasks, TaskSummary.serializeBinaryToWriter);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of CancelTasksResponse to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.tasks = (_value.tasks || []).map(m => new TaskSummary(m));
+        CancelTasksResponse.refineValues(this);
+    }
+    get tasks() {
+        return this._tasks;
+    }
+    set tasks(value) {
+        this._tasks = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        CancelTasksResponse.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            tasks: (this.tasks || []).map(m => m.toObject())
+        };
+    }
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON() {
+        return this.toObject();
+    }
+    /**
+     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+     */
+    toProtobufJSON(
+    // @ts-ignore
+    options) {
+        return {
+            tasks: (this.tasks || []).map(m => m.toProtobufJSON(options))
+        };
+    }
+}
+CancelTasksResponse.id = 'armonik.api.grpc.v1.tasks.CancelTasksResponse';
+/**
+ * Message implementation for armonik.api.grpc.v1.tasks.GetResultIdsRequest
+ */
+export class GetResultIdsRequest {
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new GetResultIdsRequest();
+        GetResultIdsRequest.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+        return instance;
+    }
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance) {
+        _instance.taskId = _instance.taskId || [];
+    }
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance, _reader) {
+        while (_reader.nextField()) {
+            if (_reader.isEndGroup())
+                break;
+            switch (_reader.getFieldNumber()) {
+                case 1:
+                    (_instance.taskId = _instance.taskId || []).push(_reader.readString());
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        GetResultIdsRequest.refineValues(_instance);
+    }
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance, _writer) {
+        if (_instance.taskId && _instance.taskId.length) {
+            _writer.writeRepeatedString(1, _instance.taskId);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of GetResultIdsRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.taskId = (_value.taskId || []).slice();
+        GetResultIdsRequest.refineValues(this);
+    }
+    get taskId() {
+        return this._taskId;
+    }
+    set taskId(value) {
+        this._taskId = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        GetResultIdsRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            taskId: (this.taskId || []).slice()
+        };
+    }
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON() {
+        return this.toObject();
+    }
+    /**
+     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+     */
+    toProtobufJSON(
+    // @ts-ignore
+    options) {
+        return {
+            taskId: (this.taskId || []).slice()
+        };
+    }
+}
+GetResultIdsRequest.id = 'armonik.api.grpc.v1.tasks.GetResultIdsRequest';
+/**
+ * Message implementation for armonik.api.grpc.v1.tasks.GetResultIdsResponse
+ */
+export class GetResultIdsResponse {
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new GetResultIdsResponse();
+        GetResultIdsResponse.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+        return instance;
+    }
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance) {
+        _instance.taskResults = _instance.taskResults || [];
+    }
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance, _reader) {
+        while (_reader.nextField()) {
+            if (_reader.isEndGroup())
+                break;
+            switch (_reader.getFieldNumber()) {
+                case 1:
+                    const messageInitializer1 = new GetResultIdsResponse.MapTaskResult();
+                    _reader.readMessage(messageInitializer1, GetResultIdsResponse.MapTaskResult.deserializeBinaryFromReader);
+                    (_instance.taskResults = _instance.taskResults || []).push(messageInitializer1);
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        GetResultIdsResponse.refineValues(_instance);
+    }
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance, _writer) {
+        if (_instance.taskResults && _instance.taskResults.length) {
+            _writer.writeRepeatedMessage(1, _instance.taskResults, GetResultIdsResponse.MapTaskResult.serializeBinaryToWriter);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of GetResultIdsResponse to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.taskResults = (_value.taskResults || []).map(m => new GetResultIdsResponse.MapTaskResult(m));
+        GetResultIdsResponse.refineValues(this);
+    }
+    get taskResults() {
+        return this._taskResults;
+    }
+    set taskResults(value) {
+        this._taskResults = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        GetResultIdsResponse.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            taskResults: (this.taskResults || []).map(m => m.toObject())
+        };
+    }
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON() {
+        return this.toObject();
+    }
+    /**
+     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+     */
+    toProtobufJSON(
+    // @ts-ignore
+    options) {
+        return {
+            taskResults: (this.taskResults || []).map(m => m.toProtobufJSON(options))
+        };
+    }
+}
+GetResultIdsResponse.id = 'armonik.api.grpc.v1.tasks.GetResultIdsResponse';
+(function (GetResultIdsResponse) {
+    /**
+     * Message implementation for armonik.api.grpc.v1.tasks.GetResultIdsResponse.MapTaskResult
+     */
+    class MapTaskResult {
+        /**
+         * Deserialize binary data to message
+         * @param instance message instance
+         */
+        static deserializeBinary(bytes) {
+            const instance = new MapTaskResult();
+            MapTaskResult.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+            return instance;
+        }
+        /**
+         * Check all the properties and set default protobuf values if necessary
+         * @param _instance message instance
+         */
+        static refineValues(_instance) {
+            _instance.taskId = _instance.taskId || '';
+            _instance.resultIds = _instance.resultIds || [];
+        }
+        /**
+         * Deserializes / reads binary message into message instance using provided binary reader
+         * @param _instance message instance
+         * @param _reader binary reader instance
+         */
+        static deserializeBinaryFromReader(_instance, _reader) {
+            while (_reader.nextField()) {
+                if (_reader.isEndGroup())
+                    break;
+                switch (_reader.getFieldNumber()) {
+                    case 1:
+                        _instance.taskId = _reader.readString();
+                        break;
+                    case 2:
+                        (_instance.resultIds = _instance.resultIds || []).push(_reader.readString());
+                        break;
+                    default:
+                        _reader.skipField();
+                }
+            }
+            MapTaskResult.refineValues(_instance);
+        }
+        /**
+         * Serializes a message to binary format using provided binary reader
+         * @param _instance message instance
+         * @param _writer binary writer instance
+         */
+        static serializeBinaryToWriter(_instance, _writer) {
+            if (_instance.taskId) {
+                _writer.writeString(1, _instance.taskId);
+            }
+            if (_instance.resultIds && _instance.resultIds.length) {
+                _writer.writeRepeatedString(2, _instance.resultIds);
+            }
+        }
+        /**
+         * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+         * @param _value initial values object or instance of MapTaskResult to deeply clone from
+         */
+        constructor(_value) {
+            _value = _value || {};
+            this.taskId = _value.taskId;
+            this.resultIds = (_value.resultIds || []).slice();
+            MapTaskResult.refineValues(this);
+        }
+        get taskId() {
+            return this._taskId;
+        }
+        set taskId(value) {
+            this._taskId = value;
+        }
+        get resultIds() {
+            return this._resultIds;
+        }
+        set resultIds(value) {
+            this._resultIds = value;
+        }
+        /**
+         * Serialize message to binary data
+         * @param instance message instance
+         */
+        serializeBinary() {
+            const writer = new BinaryWriter();
+            MapTaskResult.serializeBinaryToWriter(this, writer);
+            return writer.getResultBuffer();
+        }
+        /**
+         * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+         */
+        toObject() {
+            return {
+                taskId: this.taskId,
+                resultIds: (this.resultIds || []).slice()
+            };
+        }
+        /**
+         * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+         */
+        toJSON() {
+            return this.toObject();
+        }
+        /**
+         * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+         * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+         * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+         */
+        toProtobufJSON(
+        // @ts-ignore
+        options) {
+            return {
+                taskId: this.taskId,
+                resultIds: (this.resultIds || []).slice()
+            };
+        }
+    }
+    MapTaskResult.id = 'armonik.api.grpc.v1.tasks.GetResultIdsResponse.MapTaskResult';
+    GetResultIdsResponse.MapTaskResult = MapTaskResult;
+})(GetResultIdsResponse || (GetResultIdsResponse = {}));
+/**
+ * Message implementation for armonik.api.grpc.v1.tasks.CountTasksByStatusRequest
+ */
+export class CountTasksByStatusRequest {
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new CountTasksByStatusRequest();
+        CountTasksByStatusRequest.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+        return instance;
+    }
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance) { }
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance, _reader) {
+        while (_reader.nextField()) {
+            if (_reader.isEndGroup())
+                break;
+            switch (_reader.getFieldNumber()) {
+                default:
+                    _reader.skipField();
+            }
+        }
+        CountTasksByStatusRequest.refineValues(_instance);
+    }
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance, _writer) { }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of CountTasksByStatusRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        CountTasksByStatusRequest.refineValues(this);
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        CountTasksByStatusRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {};
+    }
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON() {
+        return this.toObject();
+    }
+    /**
+     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+     */
+    toProtobufJSON(
+    // @ts-ignore
+    options) {
+        return {};
+    }
+}
+CountTasksByStatusRequest.id = 'armonik.api.grpc.v1.tasks.CountTasksByStatusRequest';
+/**
+ * Message implementation for armonik.api.grpc.v1.tasks.CountTasksByStatusResponse
+ */
+export class CountTasksByStatusResponse {
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new CountTasksByStatusResponse();
+        CountTasksByStatusResponse.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+        return instance;
+    }
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance) {
+        _instance.status = _instance.status || [];
+    }
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance, _reader) {
+        while (_reader.nextField()) {
+            if (_reader.isEndGroup())
+                break;
+            switch (_reader.getFieldNumber()) {
+                case 1:
+                    const messageInitializer1 = new armonikApiGrpcV1003.StatusCount();
+                    _reader.readMessage(messageInitializer1, armonikApiGrpcV1003.StatusCount.deserializeBinaryFromReader);
+                    (_instance.status = _instance.status || []).push(messageInitializer1);
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        CountTasksByStatusResponse.refineValues(_instance);
+    }
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance, _writer) {
+        if (_instance.status && _instance.status.length) {
+            _writer.writeRepeatedMessage(1, _instance.status, armonikApiGrpcV1003.StatusCount.serializeBinaryToWriter);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of CountTasksByStatusResponse to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.status = (_value.status || []).map(m => new armonikApiGrpcV1003.StatusCount(m));
+        CountTasksByStatusResponse.refineValues(this);
+    }
+    get status() {
+        return this._status;
+    }
+    set status(value) {
+        this._status = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        CountTasksByStatusResponse.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            status: (this.status || []).map(m => m.toObject())
+        };
+    }
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON() {
+        return this.toObject();
+    }
+    /**
+     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+     */
+    toProtobufJSON(
+    // @ts-ignore
+    options) {
+        return {
+            status: (this.status || []).map(m => m.toProtobufJSON(options))
+        };
+    }
+}
+CountTasksByStatusResponse.id = 'armonik.api.grpc.v1.tasks.CountTasksByStatusResponse';
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tasks-common.pb.js","sourceRoot":"","sources":["../../../../../../projects/aneoconsultingfr/armonik.api.angular/src/lib/generated/tasks-common.pb.ts"],"names":[],"mappings":"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","sourcesContent":["/* tslint:disable */\n/* eslint-disable */\n// @ts-nocheck\n//\n// THIS IS A GENERATED FILE\n// DO NOT MODIFY IT! YOUR CHANGES WILL BE LOST\nimport {\n  GrpcMessage,\n  RecursivePartial,\n  ToProtobufJSONOptions\n} from '@ngx-grpc/common';\nimport { BinaryReader, BinaryWriter, ByteSource } from 'google-protobuf';\nimport * as googleProtobuf000 from '@ngx-grpc/well-known-types';\nimport * as armonikApiGrpcV1Task_status001 from './task-status.pb';\nimport * as googleProtobuf002 from '@ngx-grpc/well-known-types';\nimport * as armonikApiGrpcV1003 from './objects.pb';\n/**\n * Message implementation for armonik.api.grpc.v1.tasks.TaskRaw\n */\nexport class TaskRaw implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.tasks.TaskRaw';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new TaskRaw();\n    TaskRaw.deserializeBinaryFromReader(instance, new BinaryReader(bytes));\n    return instance;\n  }\n\n  /**\n   * Check all the properties and set default protobuf values if necessary\n   * @param _instance message instance\n   */\n  static refineValues(_instance: TaskRaw) {\n    _instance.id = _instance.id || '';\n    _instance.sessionId = _instance.sessionId || '';\n    _instance.ownerPodId = _instance.ownerPodId || '';\n    _instance.parentTaskIds = _instance.parentTaskIds || [];\n    _instance.dataDependencies = _instance.dataDependencies || [];\n    _instance.expectedOutputIds = _instance.expectedOutputIds || [];\n    _instance.retryOfIds = _instance.retryOfIds || [];\n    _instance.status = _instance.status || 0;\n    _instance.statusMessage = _instance.statusMessage || '';\n    _instance.options = _instance.options || undefined;\n    _instance.createdAt = _instance.createdAt || undefined;\n    _instance.submittedAt = _instance.submittedAt || undefined;\n    _instance.startedAt = _instance.startedAt || undefined;\n    _instance.endedAt = _instance.endedAt || undefined;\n    _instance.podTtl = _instance.podTtl || undefined;\n    _instance.output = _instance.output || undefined;\n    _instance.podHostname = _instance.podHostname || '';\n    _instance.receivedAt = _instance.receivedAt || undefined;\n    _instance.acquiredAt = _instance.acquiredAt || undefined;\n  }\n\n  /**\n   * Deserializes / reads binary message into message instance using provided binary reader\n   * @param _instance message instance\n   * @param _reader binary reader instance\n   */\n  static deserializeBinaryFromReader(\n    _instance: TaskRaw,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.id = _reader.readString();\n          break;\n        case 2:\n          _instance.sessionId = _reader.readString();\n          break;\n        case 3:\n          _instance.ownerPodId = _reader.readString();\n          break;\n        case 4:\n          (_instance.parentTaskIds = _instance.parentTaskIds || []).push(\n            _reader.readString()\n          );\n          break;\n        case 5:\n          (_instance.dataDependencies = _instance.dataDependencies || []).push(\n            _reader.readString()\n          );\n          break;\n        case 6:\n          (_instance.expectedOutputIds =\n            _instance.expectedOutputIds || []).push(_reader.readString());\n          break;\n        case 7:\n          (_instance.retryOfIds = _instance.retryOfIds || []).push(\n            _reader.readString()\n          );\n          break;\n        case 8:\n          _instance.status = _reader.readEnum();\n          break;\n        case 9:\n          _instance.statusMessage = _reader.readString();\n          break;\n        case 10:\n          _instance.options = new armonikApiGrpcV1003.TaskOptions();\n          _reader.readMessage(\n            _instance.options,\n            armonikApiGrpcV1003.TaskOptions.deserializeBinaryFromReader\n          );\n          break;\n        case 11:\n          _instance.createdAt = new googleProtobuf002.Timestamp();\n          _reader.readMessage(\n            _instance.createdAt,\n            googleProtobuf002.Timestamp.deserializeBinaryFromReader\n          );\n          break;\n        case 12:\n          _instance.submittedAt = new googleProtobuf002.Timestamp();\n          _reader.readMessage(\n            _instance.submittedAt,\n            googleProtobuf002.Timestamp.deserializeBinaryFromReader\n          );\n          break;\n        case 13:\n          _instance.startedAt = new googleProtobuf002.Timestamp();\n          _reader.readMessage(\n            _instance.startedAt,\n            googleProtobuf002.Timestamp.deserializeBinaryFromReader\n          );\n          break;\n        case 14:\n          _instance.endedAt = new googleProtobuf002.Timestamp();\n          _reader.readMessage(\n            _instance.endedAt,\n            googleProtobuf002.Timestamp.deserializeBinaryFromReader\n          );\n          break;\n        case 15:\n          _instance.podTtl = new googleProtobuf002.Timestamp();\n          _reader.readMessage(\n            _instance.podTtl,\n            googleProtobuf002.Timestamp.deserializeBinaryFromReader\n          );\n          break;\n        case 16:\n          _instance.output = new TaskRaw.Output();\n          _reader.readMessage(\n            _instance.output,\n            TaskRaw.Output.deserializeBinaryFromReader\n          );\n          break;\n        case 17:\n          _instance.podHostname = _reader.readString();\n          break;\n        case 18:\n          _instance.receivedAt = new googleProtobuf002.Timestamp();\n          _reader.readMessage(\n            _instance.receivedAt,\n            googleProtobuf002.Timestamp.deserializeBinaryFromReader\n          );\n          break;\n        case 19:\n          _instance.acquiredAt = new googleProtobuf002.Timestamp();\n          _reader.readMessage(\n            _instance.acquiredAt,\n            googleProtobuf002.Timestamp.deserializeBinaryFromReader\n          );\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    TaskRaw.refineValues(_instance);\n  }\n\n  /**\n   * Serializes a message to binary format using provided binary reader\n   * @param _instance message instance\n   * @param _writer binary writer instance\n   */\n  static serializeBinaryToWriter(_instance: TaskRaw, _writer: BinaryWriter) {\n    if (_instance.id) {\n      _writer.writeString(1, _instance.id);\n    }\n    if (_instance.sessionId) {\n      _writer.writeString(2, _instance.sessionId);\n    }\n    if (_instance.ownerPodId) {\n      _writer.writeString(3, _instance.ownerPodId);\n    }\n    if (_instance.parentTaskIds && _instance.parentTaskIds.length) {\n      _writer.writeRepeatedString(4, _instance.parentTaskIds);\n    }\n    if (_instance.dataDependencies && _instance.dataDependencies.length) {\n      _writer.writeRepeatedString(5, _instance.dataDependencies);\n    }\n    if (_instance.expectedOutputIds && _instance.expectedOutputIds.length) {\n      _writer.writeRepeatedString(6, _instance.expectedOutputIds);\n    }\n    if (_instance.retryOfIds && _instance.retryOfIds.length) {\n      _writer.writeRepeatedString(7, _instance.retryOfIds);\n    }\n    if (_instance.status) {\n      _writer.writeEnum(8, _instance.status);\n    }\n    if (_instance.statusMessage) {\n      _writer.writeString(9, _instance.statusMessage);\n    }\n    if (_instance.options) {\n      _writer.writeMessage(\n        10,\n        _instance.options as any,\n        armonikApiGrpcV1003.TaskOptions.serializeBinaryToWriter\n      );\n    }\n    if (_instance.createdAt) {\n      _writer.writeMessage(\n        11,\n        _instance.createdAt as any,\n        googleProtobuf002.Timestamp.serializeBinaryToWriter\n      );\n    }\n    if (_instance.submittedAt) {\n      _writer.writeMessage(\n        12,\n        _instance.submittedAt as any,\n        googleProtobuf002.Timestamp.serializeBinaryToWriter\n      );\n    }\n    if (_instance.startedAt) {\n      _writer.writeMessage(\n        13,\n        _instance.startedAt as any,\n        googleProtobuf002.Timestamp.serializeBinaryToWriter\n      );\n    }\n    if (_instance.endedAt) {\n      _writer.writeMessage(\n        14,\n        _instance.endedAt as any,\n        googleProtobuf002.Timestamp.serializeBinaryToWriter\n      );\n    }\n    if (_instance.podTtl) {\n      _writer.writeMessage(\n        15,\n        _instance.podTtl as any,\n        googleProtobuf002.Timestamp.serializeBinaryToWriter\n      );\n    }\n    if (_instance.output) {\n      _writer.writeMessage(\n        16,\n        _instance.output as any,\n        TaskRaw.Output.serializeBinaryToWriter\n      );\n    }\n    if (_instance.podHostname) {\n      _writer.writeString(17, _instance.podHostname);\n    }\n    if (_instance.receivedAt) {\n      _writer.writeMessage(\n        18,\n        _instance.receivedAt as any,\n        googleProtobuf002.Timestamp.serializeBinaryToWriter\n      );\n    }\n    if (_instance.acquiredAt) {\n      _writer.writeMessage(\n        19,\n        _instance.acquiredAt as any,\n        googleProtobuf002.Timestamp.serializeBinaryToWriter\n      );\n    }\n  }\n\n  private _id: string;\n  private _sessionId: string;\n  private _ownerPodId: string;\n  private _parentTaskIds: string[];\n  private _dataDependencies: string[];\n  private _expectedOutputIds: string[];\n  private _retryOfIds: string[];\n  private _status: armonikApiGrpcV1Task_status001.TaskStatus;\n  private _statusMessage: string;\n  private _options?: armonikApiGrpcV1003.TaskOptions;\n  private _createdAt?: googleProtobuf002.Timestamp;\n  private _submittedAt?: googleProtobuf002.Timestamp;\n  private _startedAt?: googleProtobuf002.Timestamp;\n  private _endedAt?: googleProtobuf002.Timestamp;\n  private _podTtl?: googleProtobuf002.Timestamp;\n  private _output?: TaskRaw.Output;\n  private _podHostname: string;\n  private _receivedAt?: googleProtobuf002.Timestamp;\n  private _acquiredAt?: googleProtobuf002.Timestamp;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of TaskRaw to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<TaskRaw.AsObject>) {\n    _value = _value || {};\n    this.id = _value.id;\n    this.sessionId = _value.sessionId;\n    this.ownerPodId = _value.ownerPodId;\n    this.parentTaskIds = (_value.parentTaskIds || []).slice();\n    this.dataDependencies = (_value.dataDependencies || []).slice();\n    this.expectedOutputIds = (_value.expectedOutputIds || []).slice();\n    this.retryOfIds = (_value.retryOfIds || []).slice();\n    this.status = _value.status;\n    this.statusMessage = _value.statusMessage;\n    this.options = _value.options\n      ? new armonikApiGrpcV1003.TaskOptions(_value.options)\n      : undefined;\n    this.createdAt = _value.createdAt\n      ? new googleProtobuf002.Timestamp(_value.createdAt)\n      : undefined;\n    this.submittedAt = _value.submittedAt\n      ? new googleProtobuf002.Timestamp(_value.submittedAt)\n      : undefined;\n    this.startedAt = _value.startedAt\n      ? new googleProtobuf002.Timestamp(_value.startedAt)\n      : undefined;\n    this.endedAt = _value.endedAt\n      ? new googleProtobuf002.Timestamp(_value.endedAt)\n      : undefined;\n    this.podTtl = _value.podTtl\n      ? new googleProtobuf002.Timestamp(_value.podTtl)\n      : undefined;\n    this.output = _value.output ? new TaskRaw.Output(_value.output) : undefined;\n    this.podHostname = _value.podHostname;\n    this.receivedAt = _value.receivedAt\n      ? new googleProtobuf002.Timestamp(_value.receivedAt)\n      : undefined;\n    this.acquiredAt = _value.acquiredAt\n      ? new googleProtobuf002.Timestamp(_value.acquiredAt)\n      : undefined;\n    TaskRaw.refineValues(this);\n  }\n  get id(): string {\n    return this._id;\n  }\n  set id(value: string) {\n    this._id = value;\n  }\n  get sessionId(): string {\n    return this._sessionId;\n  }\n  set sessionId(value: string) {\n    this._sessionId = value;\n  }\n  get ownerPodId(): string {\n    return this._ownerPodId;\n  }\n  set ownerPodId(value: string) {\n    this._ownerPodId = value;\n  }\n  get parentTaskIds(): string[] {\n    return this._parentTaskIds;\n  }\n  set parentTaskIds(value: string[]) {\n    this._parentTaskIds = value;\n  }\n  get dataDependencies(): string[] {\n    return this._dataDependencies;\n  }\n  set dataDependencies(value: string[]) {\n    this._dataDependencies = value;\n  }\n  get expectedOutputIds(): string[] {\n    return this._expectedOutputIds;\n  }\n  set expectedOutputIds(value: string[]) {\n    this._expectedOutputIds = value;\n  }\n  get retryOfIds(): string[] {\n    return this._retryOfIds;\n  }\n  set retryOfIds(value: string[]) {\n    this._retryOfIds = value;\n  }\n  get status(): armonikApiGrpcV1Task_status001.TaskStatus {\n    return this._status;\n  }\n  set status(value: armonikApiGrpcV1Task_status001.TaskStatus) {\n    this._status = value;\n  }\n  get statusMessage(): string {\n    return this._statusMessage;\n  }\n  set statusMessage(value: string) {\n    this._statusMessage = value;\n  }\n  get options(): armonikApiGrpcV1003.TaskOptions | undefined {\n    return this._options;\n  }\n  set options(value: armonikApiGrpcV1003.TaskOptions | undefined) {\n    this._options = value;\n  }\n  get createdAt(): googleProtobuf002.Timestamp | undefined {\n    return this._createdAt;\n  }\n  set createdAt(value: googleProtobuf002.Timestamp | undefined) {\n    this._createdAt = value;\n  }\n  get submittedAt(): googleProtobuf002.Timestamp | undefined {\n    return this._submittedAt;\n  }\n  set submittedAt(value: googleProtobuf002.Timestamp | undefined) {\n    this._submittedAt = value;\n  }\n  get startedAt(): googleProtobuf002.Timestamp | undefined {\n    return this._startedAt;\n  }\n  set startedAt(value: googleProtobuf002.Timestamp | undefined) {\n    this._startedAt = value;\n  }\n  get endedAt(): googleProtobuf002.Timestamp | undefined {\n    return this._endedAt;\n  }\n  set endedAt(value: googleProtobuf002.Timestamp | undefined) {\n    this._endedAt = value;\n  }\n  get podTtl(): googleProtobuf002.Timestamp | undefined {\n    return this._podTtl;\n  }\n  set podTtl(value: googleProtobuf002.Timestamp | undefined) {\n    this._podTtl = value;\n  }\n  get output(): TaskRaw.Output | undefined {\n    return this._output;\n  }\n  set output(value: TaskRaw.Output | undefined) {\n    this._output = value;\n  }\n  get podHostname(): string {\n    return this._podHostname;\n  }\n  set podHostname(value: string) {\n    this._podHostname = value;\n  }\n  get receivedAt(): googleProtobuf002.Timestamp | undefined {\n    return this._receivedAt;\n  }\n  set receivedAt(value: googleProtobuf002.Timestamp | undefined) {\n    this._receivedAt = value;\n  }\n  get acquiredAt(): googleProtobuf002.Timestamp | undefined {\n    return this._acquiredAt;\n  }\n  set acquiredAt(value: googleProtobuf002.Timestamp | undefined) {\n    this._acquiredAt = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    TaskRaw.serializeBinaryToWriter(this, writer);\n    return writer.getResultBuffer();\n  }\n\n  /**\n   * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)\n   */\n  toObject(): TaskRaw.AsObject {\n    return {\n      id: this.id,\n      sessionId: this.sessionId,\n      ownerPodId: this.ownerPodId,\n      parentTaskIds: (this.parentTaskIds || []).slice(),\n      dataDependencies: (this.dataDependencies || []).slice(),\n      expectedOutputIds: (this.expectedOutputIds || []).slice(),\n      retryOfIds: (this.retryOfIds || []).slice(),\n      status: this.status,\n      statusMessage: this.statusMessage,\n      options: this.options ? this.options.toObject() : undefined,\n      createdAt: this.createdAt ? this.createdAt.toObject() : undefined,\n      submittedAt: this.submittedAt ? this.submittedAt.toObject() : undefined,\n      startedAt: this.startedAt ? this.startedAt.toObject() : undefined,\n      endedAt: this.endedAt ? this.endedAt.toObject() : undefined,\n      podTtl: this.podTtl ? this.podTtl.toObject() : undefined,\n      output: this.output ? this.output.toObject() : undefined,\n      podHostname: this.podHostname,\n      receivedAt: this.receivedAt ? this.receivedAt.toObject() : undefined,\n      acquiredAt: this.acquiredAt ? this.acquiredAt.toObject() : undefined\n    };\n  }\n\n  /**\n   * Convenience method to support JSON.stringify(message), replicates the structure of toObject()\n   */\n  toJSON() {\n    return this.toObject();\n  }\n\n  /**\n   * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json\n   * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.\n   * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required\n   */\n  toProtobufJSON(\n    // @ts-ignore\n    options?: ToProtobufJSONOptions\n  ): TaskRaw.AsProtobufJSON {\n    return {\n      id: this.id,\n      sessionId: this.sessionId,\n      ownerPodId: this.ownerPodId,\n      parentTaskIds: (this.parentTaskIds || []).slice(),\n      dataDependencies: (this.dataDependencies || []).slice(),\n      expectedOutputIds: (this.expectedOutputIds || []).slice(),\n      retryOfIds: (this.retryOfIds || []).slice(),\n      status:\n        armonikApiGrpcV1Task_status001.TaskStatus[\n          this.status === null || this.status === undefined ? 0 : this.status\n        ],\n      statusMessage: this.statusMessage,\n      options: this.options ? this.options.toProtobufJSON(options) : null,\n      createdAt: this.createdAt ? this.createdAt.toProtobufJSON(options) : null,\n      submittedAt: this.submittedAt\n        ? this.submittedAt.toProtobufJSON(options)\n        : null,\n      startedAt: this.startedAt ? this.startedAt.toProtobufJSON(options) : null,\n      endedAt: this.endedAt ? this.endedAt.toProtobufJSON(options) : null,\n      podTtl: this.podTtl ? this.podTtl.toProtobufJSON(options) : null,\n      output: this.output ? this.output.toProtobufJSON(options) : null,\n      podHostname: this.podHostname,\n      receivedAt: this.receivedAt\n        ? this.receivedAt.toProtobufJSON(options)\n        : null,\n      acquiredAt: this.acquiredAt\n        ? this.acquiredAt.toProtobufJSON(options)\n        : null\n    };\n  }\n}\nexport module TaskRaw {\n  /**\n   * Standard JavaScript object representation for TaskRaw\n   */\n  export interface AsObject {\n    id: string;\n    sessionId: string;\n    ownerPodId: string;\n    parentTaskIds: string[];\n    dataDependencies: string[];\n    expectedOutputIds: string[];\n    retryOfIds: string[];\n    status: armonikApiGrpcV1Task_status001.TaskStatus;\n    statusMessage: string;\n    options?: armonikApiGrpcV1003.TaskOptions.AsObject;\n    createdAt?: googleProtobuf002.Timestamp.AsObject;\n    submittedAt?: googleProtobuf002.Timestamp.AsObject;\n    startedAt?: googleProtobuf002.Timestamp.AsObject;\n    endedAt?: googleProtobuf002.Timestamp.AsObject;\n    podTtl?: googleProtobuf002.Timestamp.AsObject;\n    output?: TaskRaw.Output.AsObject;\n    podHostname: string;\n    receivedAt?: googleProtobuf002.Timestamp.AsObject;\n    acquiredAt?: googleProtobuf002.Timestamp.AsObject;\n  }\n\n  /**\n   * Protobuf JSON representation for TaskRaw\n   */\n  export interface AsProtobufJSON {\n    id: string;\n    sessionId: string;\n    ownerPodId: string;\n    parentTaskIds: string[];\n    dataDependencies: string[];\n    expectedOutputIds: string[];\n    retryOfIds: string[];\n    status: string;\n    statusMessage: string;\n    options: armonikApiGrpcV1003.TaskOptions.AsProtobufJSON | null;\n    createdAt: googleProtobuf002.Timestamp.AsProtobufJSON | null;\n    submittedAt: googleProtobuf002.Timestamp.AsProtobufJSON | null;\n    startedAt: googleProtobuf002.Timestamp.AsProtobufJSON | null;\n    endedAt: googleProtobuf002.Timestamp.AsProtobufJSON | null;\n    podTtl: googleProtobuf002.Timestamp.AsProtobufJSON | null;\n    output: TaskRaw.Output.AsProtobufJSON | null;\n    podHostname: string;\n    receivedAt: googleProtobuf002.Timestamp.AsProtobufJSON | null;\n    acquiredAt: googleProtobuf002.Timestamp.AsProtobufJSON | null;\n  }\n\n  /**\n   * Message implementation for armonik.api.grpc.v1.tasks.TaskRaw.Output\n   */\n  export class Output implements GrpcMessage {\n    static id = 'armonik.api.grpc.v1.tasks.TaskRaw.Output';\n\n    /**\n     * Deserialize binary data to message\n     * @param instance message instance\n     */\n    static deserializeBinary(bytes: ByteSource) {\n      const instance = new Output();\n      Output.deserializeBinaryFromReader(instance, new BinaryReader(bytes));\n      return instance;\n    }\n\n    /**\n     * Check all the properties and set default protobuf values if necessary\n     * @param _instance message instance\n     */\n    static refineValues(_instance: Output) {\n      _instance.success = _instance.success || false;\n      _instance.error = _instance.error || '';\n    }\n\n    /**\n     * Deserializes / reads binary message into message instance using provided binary reader\n     * @param _instance message instance\n     * @param _reader binary reader instance\n     */\n    static deserializeBinaryFromReader(\n      _instance: Output,\n      _reader: BinaryReader\n    ) {\n      while (_reader.nextField()) {\n        if (_reader.isEndGroup()) break;\n\n        switch (_reader.getFieldNumber()) {\n          case 1:\n            _instance.success = _reader.readBool();\n            break;\n          case 2:\n            _instance.error = _reader.readString();\n            break;\n          default:\n            _reader.skipField();\n        }\n      }\n\n      Output.refineValues(_instance);\n    }\n\n    /**\n     * Serializes a message to binary format using provided binary reader\n     * @param _instance message instance\n     * @param _writer binary writer instance\n     */\n    static serializeBinaryToWriter(_instance: Output, _writer: BinaryWriter) {\n      if (_instance.success) {\n        _writer.writeBool(1, _instance.success);\n      }\n      if (_instance.error) {\n        _writer.writeString(2, _instance.error);\n      }\n    }\n\n    private _success: boolean;\n    private _error: string;\n\n    /**\n     * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n     * @param _value initial values object or instance of Output to deeply clone from\n     */\n    constructor(_value?: RecursivePartial<Output.AsObject>) {\n      _value = _value || {};\n      this.success = _value.success;\n      this.error = _value.error;\n      Output.refineValues(this);\n    }\n    get success(): boolean {\n      return this._success;\n    }\n    set success(value: boolean) {\n      this._success = value;\n    }\n    get error(): string {\n      return this._error;\n    }\n    set error(value: string) {\n      this._error = value;\n    }\n\n    /**\n     * Serialize message to binary data\n     * @param instance message instance\n     */\n    serializeBinary() {\n      const writer = new BinaryWriter();\n      Output.serializeBinaryToWriter(this, writer);\n      return writer.getResultBuffer();\n    }\n\n    /**\n     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)\n     */\n    toObject(): Output.AsObject {\n      return {\n        success: this.success,\n        error: this.error\n      };\n    }\n\n    /**\n     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()\n     */\n    toJSON() {\n      return this.toObject();\n    }\n\n    /**\n     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json\n     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.\n     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required\n     */\n    toProtobufJSON(\n      // @ts-ignore\n      options?: ToProtobufJSONOptions\n    ): Output.AsProtobufJSON {\n      return {\n        success: this.success,\n        error: this.error\n      };\n    }\n  }\n  export module Output {\n    /**\n     * Standard JavaScript object representation for Output\n     */\n    export interface AsObject {\n      success: boolean;\n      error: string;\n    }\n\n    /**\n     * Protobuf JSON representation for Output\n     */\n    export interface AsProtobufJSON {\n      success: boolean;\n      error: string;\n    }\n  }\n}\n\n/**\n * Message implementation for armonik.api.grpc.v1.tasks.TaskSummary\n */\nexport class TaskSummary implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.tasks.TaskSummary';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new TaskSummary();\n    TaskSummary.deserializeBinaryFromReader(instance, new BinaryReader(bytes));\n    return instance;\n  }\n\n  /**\n   * Check all the properties and set default protobuf values if necessary\n   * @param _instance message instance\n   */\n  static refineValues(_instance: TaskSummary) {\n    _instance.id = _instance.id || '';\n    _instance.sessionId = _instance.sessionId || '';\n    _instance.options = _instance.options || undefined;\n    _instance.status = _instance.status || 0;\n    _instance.createdAt = _instance.createdAt || undefined;\n    _instance.startedAt = _instance.startedAt || undefined;\n    _instance.endedAt = _instance.endedAt || undefined;\n    _instance.error = _instance.error || '';\n  }\n\n  /**\n   * Deserializes / reads binary message into message instance using provided binary reader\n   * @param _instance message instance\n   * @param _reader binary reader instance\n   */\n  static deserializeBinaryFromReader(\n    _instance: TaskSummary,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.id = _reader.readString();\n          break;\n        case 2:\n          _instance.sessionId = _reader.readString();\n          break;\n        case 3:\n          _instance.options = new armonikApiGrpcV1003.TaskOptions();\n          _reader.readMessage(\n            _instance.options,\n            armonikApiGrpcV1003.TaskOptions.deserializeBinaryFromReader\n          );\n          break;\n        case 4:\n          _instance.status = _reader.readEnum();\n          break;\n        case 5:\n          _instance.createdAt = new googleProtobuf002.Timestamp();\n          _reader.readMessage(\n            _instance.createdAt,\n            googleProtobuf002.Timestamp.deserializeBinaryFromReader\n          );\n          break;\n        case 6:\n          _instance.startedAt = new googleProtobuf002.Timestamp();\n          _reader.readMessage(\n            _instance.startedAt,\n            googleProtobuf002.Timestamp.deserializeBinaryFromReader\n          );\n          break;\n        case 7:\n          _instance.endedAt = new googleProtobuf002.Timestamp();\n          _reader.readMessage(\n            _instance.endedAt,\n            googleProtobuf002.Timestamp.deserializeBinaryFromReader\n          );\n          break;\n        case 8:\n          _instance.error = _reader.readString();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    TaskSummary.refineValues(_instance);\n  }\n\n  /**\n   * Serializes a message to binary format using provided binary reader\n   * @param _instance message instance\n   * @param _writer binary writer instance\n   */\n  static serializeBinaryToWriter(\n    _instance: TaskSummary,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.id) {\n      _writer.writeString(1, _instance.id);\n    }\n    if (_instance.sessionId) {\n      _writer.writeString(2, _instance.sessionId);\n    }\n    if (_instance.options) {\n      _writer.writeMessage(\n        3,\n        _instance.options as any,\n        armonikApiGrpcV1003.TaskOptions.serializeBinaryToWriter\n      );\n    }\n    if (_instance.status) {\n      _writer.writeEnum(4, _instance.status);\n    }\n    if (_instance.createdAt) {\n      _writer.writeMessage(\n        5,\n        _instance.createdAt as any,\n        googleProtobuf002.Timestamp.serializeBinaryToWriter\n      );\n    }\n    if (_instance.startedAt) {\n      _writer.writeMessage(\n        6,\n        _instance.startedAt as any,\n        googleProtobuf002.Timestamp.serializeBinaryToWriter\n      );\n    }\n    if (_instance.endedAt) {\n      _writer.writeMessage(\n        7,\n        _instance.endedAt as any,\n        googleProtobuf002.Timestamp.serializeBinaryToWriter\n      );\n    }\n    if (_instance.error) {\n      _writer.writeString(8, _instance.error);\n    }\n  }\n\n  private _id: string;\n  private _sessionId: string;\n  private _options?: armonikApiGrpcV1003.TaskOptions;\n  private _status: armonikApiGrpcV1Task_status001.TaskStatus;\n  private _createdAt?: googleProtobuf002.Timestamp;\n  private _startedAt?: googleProtobuf002.Timestamp;\n  private _endedAt?: googleProtobuf002.Timestamp;\n  private _error: string;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of TaskSummary to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<TaskSummary.AsObject>) {\n    _value = _value || {};\n    this.id = _value.id;\n    this.sessionId = _value.sessionId;\n    this.options = _value.options\n      ? new armonikApiGrpcV1003.TaskOptions(_value.options)\n      : undefined;\n    this.status = _value.status;\n    this.createdAt = _value.createdAt\n      ? new googleProtobuf002.Timestamp(_value.createdAt)\n      : undefined;\n    this.startedAt = _value.startedAt\n      ? new googleProtobuf002.Timestamp(_value.startedAt)\n      : undefined;\n    this.endedAt = _value.endedAt\n      ? new googleProtobuf002.Timestamp(_value.endedAt)\n      : undefined;\n    this.error = _value.error;\n    TaskSummary.refineValues(this);\n  }\n  get id(): string {\n    return this._id;\n  }\n  set id(value: string) {\n    this._id = value;\n  }\n  get sessionId(): string {\n    return this._sessionId;\n  }\n  set sessionId(value: string) {\n    this._sessionId = value;\n  }\n  get options(): armonikApiGrpcV1003.TaskOptions | undefined {\n    return this._options;\n  }\n  set options(value: armonikApiGrpcV1003.TaskOptions | undefined) {\n    this._options = value;\n  }\n  get status(): armonikApiGrpcV1Task_status001.TaskStatus {\n    return this._status;\n  }\n  set status(value: armonikApiGrpcV1Task_status001.TaskStatus) {\n    this._status = value;\n  }\n  get createdAt(): googleProtobuf002.Timestamp | undefined {\n    return this._createdAt;\n  }\n  set createdAt(value: googleProtobuf002.Timestamp | undefined) {\n    this._createdAt = value;\n  }\n  get startedAt(): googleProtobuf002.Timestamp | undefined {\n    return this._startedAt;\n  }\n  set startedAt(value: googleProtobuf002.Timestamp | undefined) {\n    this._startedAt = value;\n  }\n  get endedAt(): googleProtobuf002.Timestamp | undefined {\n    return this._endedAt;\n  }\n  set endedAt(value: googleProtobuf002.Timestamp | undefined) {\n    this._endedAt = value;\n  }\n  get error(): string {\n    return this._error;\n  }\n  set error(value: string) {\n    this._error = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    TaskSummary.serializeBinaryToWriter(this, writer);\n    return writer.getResultBuffer();\n  }\n\n  /**\n   * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)\n   */\n  toObject(): TaskSummary.AsObject {\n    return {\n      id: this.id,\n      sessionId: this.sessionId,\n      options: this.options ? this.options.toObject() : undefined,\n      status: this.status,\n      createdAt: this.createdAt ? this.createdAt.toObject() : undefined,\n      startedAt: this.startedAt ? this.startedAt.toObject() : undefined,\n      endedAt: this.endedAt ? this.endedAt.toObject() : undefined,\n      error: this.error\n    };\n  }\n\n  /**\n   * Convenience method to support JSON.stringify(message), replicates the structure of toObject()\n   */\n  toJSON() {\n    return this.toObject();\n  }\n\n  /**\n   * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json\n   * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.\n   * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required\n   */\n  toProtobufJSON(\n    // @ts-ignore\n    options?: ToProtobufJSONOptions\n  ): TaskSummary.AsProtobufJSON {\n    return {\n      id: this.id,\n      sessionId: this.sessionId,\n      options: this.options ? this.options.toProtobufJSON(options) : null,\n      status:\n        armonikApiGrpcV1Task_status001.TaskStatus[\n          this.status === null || this.status === undefined ? 0 : this.status\n        ],\n      createdAt: this.createdAt ? this.createdAt.toProtobufJSON(options) : null,\n      startedAt: this.startedAt ? this.startedAt.toProtobufJSON(options) : null,\n      endedAt: this.endedAt ? this.endedAt.toProtobufJSON(options) : null,\n      error: this.error\n    };\n  }\n}\nexport module TaskSummary {\n  /**\n   * Standard JavaScript object representation for TaskSummary\n   */\n  export interface AsObject {\n    id: string;\n    sessionId: string;\n    options?: armonikApiGrpcV1003.TaskOptions.AsObject;\n    status: armonikApiGrpcV1Task_status001.TaskStatus;\n    createdAt?: googleProtobuf002.Timestamp.AsObject;\n    startedAt?: googleProtobuf002.Timestamp.AsObject;\n    endedAt?: googleProtobuf002.Timestamp.AsObject;\n    error: string;\n  }\n\n  /**\n   * Protobuf JSON representation for TaskSummary\n   */\n  export interface AsProtobufJSON {\n    id: string;\n    sessionId: string;\n    options: armonikApiGrpcV1003.TaskOptions.AsProtobufJSON | null;\n    status: string;\n    createdAt: googleProtobuf002.Timestamp.AsProtobufJSON | null;\n    startedAt: googleProtobuf002.Timestamp.AsProtobufJSON | null;\n    endedAt: googleProtobuf002.Timestamp.AsProtobufJSON | null;\n    error: string;\n  }\n}\n\n/**\n * Message implementation for armonik.api.grpc.v1.tasks.ListTasksRequest\n */\nexport class ListTasksRequest implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.tasks.ListTasksRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new ListTasksRequest();\n    ListTasksRequest.deserializeBinaryFromReader(\n      instance,\n      new BinaryReader(bytes)\n    );\n    return instance;\n  }\n\n  /**\n   * Check all the properties and set default protobuf values if necessary\n   * @param _instance message instance\n   */\n  static refineValues(_instance: ListTasksRequest) {\n    _instance.page = _instance.page || 0;\n    _instance.pageSize = _instance.pageSize || 0;\n    _instance.filter = _instance.filter || undefined;\n    _instance.sort = _instance.sort || undefined;\n    _instance.withErrors = _instance.withErrors || false;\n  }\n\n  /**\n   * Deserializes / reads binary message into message instance using provided binary reader\n   * @param _instance message instance\n   * @param _reader binary reader instance\n   */\n  static deserializeBinaryFromReader(\n    _instance: ListTasksRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.page = _reader.readInt32();\n          break;\n        case 2:\n          _instance.pageSize = _reader.readInt32();\n          break;\n        case 3:\n          _instance.filter = new ListTasksRequest.Filter();\n          _reader.readMessage(\n            _instance.filter,\n            ListTasksRequest.Filter.deserializeBinaryFromReader\n          );\n          break;\n        case 4:\n          _instance.sort = new ListTasksRequest.Sort();\n          _reader.readMessage(\n            _instance.sort,\n            ListTasksRequest.Sort.deserializeBinaryFromReader\n          );\n          break;\n        case 5:\n          _instance.withErrors = _reader.readBool();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    ListTasksRequest.refineValues(_instance);\n  }\n\n  /**\n   * Serializes a message to binary format using provided binary reader\n   * @param _instance message instance\n   * @param _writer binary writer instance\n   */\n  static serializeBinaryToWriter(\n    _instance: ListTasksRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.page) {\n      _writer.writeInt32(1, _instance.page);\n    }\n    if (_instance.pageSize) {\n      _writer.writeInt32(2, _instance.pageSize);\n    }\n    if (_instance.filter) {\n      _writer.writeMessage(\n        3,\n        _instance.filter as any,\n        ListTasksRequest.Filter.serializeBinaryToWriter\n      );\n    }\n    if (_instance.sort) {\n      _writer.writeMessage(\n        4,\n        _instance.sort as any,\n        ListTasksRequest.Sort.serializeBinaryToWriter\n      );\n    }\n    if (_instance.withErrors) {\n      _writer.writeBool(5, _instance.withErrors);\n    }\n  }\n\n  private _page: number;\n  private _pageSize: number;\n  private _filter?: ListTasksRequest.Filter;\n  private _sort?: ListTasksRequest.Sort;\n  private _withErrors: boolean;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of ListTasksRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<ListTasksRequest.AsObject>) {\n    _value = _value || {};\n    this.page = _value.page;\n    this.pageSize = _value.pageSize;\n    this.filter = _value.filter\n      ? new ListTasksRequest.Filter(_value.filter)\n      : undefined;\n    this.sort = _value.sort\n      ? new ListTasksRequest.Sort(_value.sort)\n      : undefined;\n    this.withErrors = _value.withErrors;\n    ListTasksRequest.refineValues(this);\n  }\n  get page(): number {\n    return this._page;\n  }\n  set page(value: number) {\n    this._page = value;\n  }\n  get pageSize(): number {\n    return this._pageSize;\n  }\n  set pageSize(value: number) {\n    this._pageSize = value;\n  }\n  get filter(): ListTasksRequest.Filter | undefined {\n    return this._filter;\n  }\n  set filter(value: ListTasksRequest.Filter | undefined) {\n    this._filter = value;\n  }\n  get sort(): ListTasksRequest.Sort | undefined {\n    return this._sort;\n  }\n  set sort(value: ListTasksRequest.Sort | undefined) {\n    this._sort = value;\n  }\n  get withErrors(): boolean {\n    return this._withErrors;\n  }\n  set withErrors(value: boolean) {\n    this._withErrors = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    ListTasksRequest.serializeBinaryToWriter(this, writer);\n    return writer.getResultBuffer();\n  }\n\n  /**\n   * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)\n   */\n  toObject(): ListTasksRequest.AsObject {\n    return {\n      page: this.page,\n      pageSize: this.pageSize,\n      filter: this.filter ? this.filter.toObject() : undefined,\n      sort: this.sort ? this.sort.toObject() : undefined,\n      withErrors: this.withErrors\n    };\n  }\n\n  /**\n   * Convenience method to support JSON.stringify(message), replicates the structure of toObject()\n   */\n  toJSON() {\n    return this.toObject();\n  }\n\n  /**\n   * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json\n   * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.\n   * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required\n   */\n  toProtobufJSON(\n    // @ts-ignore\n    options?: ToProtobufJSONOptions\n  ): ListTasksRequest.AsProtobufJSON {\n    return {\n      page: this.page,\n      pageSize: this.pageSize,\n      filter: this.filter ? this.filter.toProtobufJSON(options) : null,\n      sort: this.sort ? this.sort.toProtobufJSON(options) : null,\n      withErrors: this.withErrors\n    };\n  }\n}\nexport module ListTasksRequest {\n  /**\n   * Standard JavaScript object representation for ListTasksRequest\n   */\n  export interface AsObject {\n    page: number;\n    pageSize: number;\n    filter?: ListTasksRequest.Filter.AsObject;\n    sort?: ListTasksRequest.Sort.AsObject;\n    withErrors: boolean;\n  }\n\n  /**\n   * Protobuf JSON representation for ListTasksRequest\n   */\n  export interface AsProtobufJSON {\n    page: number;\n    pageSize: number;\n    filter: ListTasksRequest.Filter.AsProtobufJSON | null;\n    sort: ListTasksRequest.Sort.AsProtobufJSON | null;\n    withErrors: boolean;\n  }\n  export enum OrderByField {\n    ORDER_BY_FIELD_UNSPECIFIED = 0,\n    ORDER_BY_FIELD_TASK_ID = 1,\n    ORDER_BY_FIELD_SESSION_ID = 2,\n    ORDER_BY_FIELD_STATUS = 3,\n    ORDER_BY_FIELD_CREATED_AT = 4,\n    ORDER_BY_FIELD_STARTED_AT = 5,\n    ORDER_BY_FIELD_ENDED_AT = 6\n  }\n  export enum OrderDirection {\n    ORDER_DIRECTION_UNSPECIFIED = 0,\n    ORDER_DIRECTION_ASC = 1,\n    ORDER_DIRECTION_DESC = 2\n  }\n  /**\n   * Message implementation for armonik.api.grpc.v1.tasks.ListTasksRequest.Filter\n   */\n  export class Filter implements GrpcMessage {\n    static id = 'armonik.api.grpc.v1.tasks.ListTasksRequest.Filter';\n\n    /**\n     * Deserialize binary data to message\n     * @param instance message instance\n     */\n    static deserializeBinary(bytes: ByteSource) {\n      const instance = new Filter();\n      Filter.deserializeBinaryFromReader(instance, new BinaryReader(bytes));\n      return instance;\n    }\n\n    /**\n     * Check all the properties and set default protobuf values if necessary\n     * @param _instance message instance\n     */\n    static refineValues(_instance: Filter) {\n      _instance.sessionId = _instance.sessionId || '';\n      _instance.status = _instance.status || [];\n      _instance.createdAfter = _instance.createdAfter || undefined;\n      _instance.createdBefore = _instance.createdBefore || undefined;\n      _instance.startedAfter = _instance.startedAfter || undefined;\n      _instance.startedBefore = _instance.startedBefore || undefined;\n      _instance.endedAfter = _instance.endedAfter || undefined;\n      _instance.endedBefore = _instance.endedBefore || undefined;\n    }\n\n    /**\n     * Deserializes / reads binary message into message instance using provided binary reader\n     * @param _instance message instance\n     * @param _reader binary reader instance\n     */\n    static deserializeBinaryFromReader(\n      _instance: Filter,\n      _reader: BinaryReader\n    ) {\n      while (_reader.nextField()) {\n        if (_reader.isEndGroup()) break;\n\n        switch (_reader.getFieldNumber()) {\n          case 1:\n            _instance.sessionId = _reader.readString();\n            break;\n          case 2:\n            (_instance.status = _instance.status || []).push(\n              ...(_reader.readPackedEnum() || [])\n            );\n            break;\n          case 3:\n            _instance.createdAfter = new googleProtobuf002.Timestamp();\n            _reader.readMessage(\n              _instance.createdAfter,\n              googleProtobuf002.Timestamp.deserializeBinaryFromReader\n            );\n            break;\n          case 4:\n            _instance.createdBefore = new googleProtobuf002.Timestamp();\n            _reader.readMessage(\n              _instance.createdBefore,\n              googleProtobuf002.Timestamp.deserializeBinaryFromReader\n            );\n            break;\n          case 5:\n            _instance.startedAfter = new googleProtobuf002.Timestamp();\n            _reader.readMessage(\n              _instance.startedAfter,\n              googleProtobuf002.Timestamp.deserializeBinaryFromReader\n            );\n            break;\n          case 6:\n            _instance.startedBefore = new googleProtobuf002.Timestamp();\n            _reader.readMessage(\n              _instance.startedBefore,\n              googleProtobuf002.Timestamp.deserializeBinaryFromReader\n            );\n            break;\n          case 7:\n            _instance.endedAfter = new googleProtobuf002.Timestamp();\n            _reader.readMessage(\n              _instance.endedAfter,\n              googleProtobuf002.Timestamp.deserializeBinaryFromReader\n            );\n            break;\n          case 8:\n            _instance.endedBefore = new googleProtobuf002.Timestamp();\n            _reader.readMessage(\n              _instance.endedBefore,\n              googleProtobuf002.Timestamp.deserializeBinaryFromReader\n            );\n            break;\n          default:\n            _reader.skipField();\n        }\n      }\n\n      Filter.refineValues(_instance);\n    }\n\n    /**\n     * Serializes a message to binary format using provided binary reader\n     * @param _instance message instance\n     * @param _writer binary writer instance\n     */\n    static serializeBinaryToWriter(_instance: Filter, _writer: BinaryWriter) {\n      if (_instance.sessionId) {\n        _writer.writeString(1, _instance.sessionId);\n      }\n      if (_instance.status && _instance.status.length) {\n        _writer.writePackedEnum(2, _instance.status);\n      }\n      if (_instance.createdAfter) {\n        _writer.writeMessage(\n          3,\n          _instance.createdAfter as any,\n          googleProtobuf002.Timestamp.serializeBinaryToWriter\n        );\n      }\n      if (_instance.createdBefore) {\n        _writer.writeMessage(\n          4,\n          _instance.createdBefore as any,\n          googleProtobuf002.Timestamp.serializeBinaryToWriter\n        );\n      }\n      if (_instance.startedAfter) {\n        _writer.writeMessage(\n          5,\n          _instance.startedAfter as any,\n          googleProtobuf002.Timestamp.serializeBinaryToWriter\n        );\n      }\n      if (_instance.startedBefore) {\n        _writer.writeMessage(\n          6,\n          _instance.startedBefore as any,\n          googleProtobuf002.Timestamp.serializeBinaryToWriter\n        );\n      }\n      if (_instance.endedAfter) {\n        _writer.writeMessage(\n          7,\n          _instance.endedAfter as any,\n          googleProtobuf002.Timestamp.serializeBinaryToWriter\n        );\n      }\n      if (_instance.endedBefore) {\n        _writer.writeMessage(\n          8,\n          _instance.endedBefore as any,\n          googleProtobuf002.Timestamp.serializeBinaryToWriter\n        );\n      }\n    }\n\n    private _sessionId: string;\n    private _status: armonikApiGrpcV1Task_status001.TaskStatus[];\n    private _createdAfter?: googleProtobuf002.Timestamp;\n    private _createdBefore?: googleProtobuf002.Timestamp;\n    private _startedAfter?: googleProtobuf002.Timestamp;\n    private _startedBefore?: googleProtobuf002.Timestamp;\n    private _endedAfter?: googleProtobuf002.Timestamp;\n    private _endedBefore?: googleProtobuf002.Timestamp;\n\n    /**\n     * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n     * @param _value initial values object or instance of Filter to deeply clone from\n     */\n    constructor(_value?: RecursivePartial<Filter.AsObject>) {\n      _value = _value || {};\n      this.sessionId = _value.sessionId;\n      this.status = (_value.status || []).slice();\n      this.createdAfter = _value.createdAfter\n        ? new googleProtobuf002.Timestamp(_value.createdAfter)\n        : undefined;\n      this.createdBefore = _value.createdBefore\n        ? new googleProtobuf002.Timestamp(_value.createdBefore)\n        : undefined;\n      this.startedAfter = _value.startedAfter\n        ? new googleProtobuf002.Timestamp(_value.startedAfter)\n        : undefined;\n      this.startedBefore = _value.startedBefore\n        ? new googleProtobuf002.Timestamp(_value.startedBefore)\n        : undefined;\n      this.endedAfter = _value.endedAfter\n        ? new googleProtobuf002.Timestamp(_value.endedAfter)\n        : undefined;\n      this.endedBefore = _value.endedBefore\n        ? new googleProtobuf002.Timestamp(_value.endedBefore)\n        : undefined;\n      Filter.refineValues(this);\n    }\n    get sessionId(): string {\n      return this._sessionId;\n    }\n    set sessionId(value: string) {\n      this._sessionId = value;\n    }\n    get status(): armonikApiGrpcV1Task_status001.TaskStatus[] {\n      return this._status;\n    }\n    set status(value: armonikApiGrpcV1Task_status001.TaskStatus[]) {\n      this._status = value;\n    }\n    get createdAfter(): googleProtobuf002.Timestamp | undefined {\n      return this._createdAfter;\n    }\n    set createdAfter(value: googleProtobuf002.Timestamp | undefined) {\n      this._createdAfter = value;\n    }\n    get createdBefore(): googleProtobuf002.Timestamp | undefined {\n      return this._createdBefore;\n    }\n    set createdBefore(value: googleProtobuf002.Timestamp | undefined) {\n      this._createdBefore = value;\n    }\n    get startedAfter(): googleProtobuf002.Timestamp | undefined {\n      return this._startedAfter;\n    }\n    set startedAfter(value: googleProtobuf002.Timestamp | undefined) {\n      this._startedAfter = value;\n    }\n    get startedBefore(): googleProtobuf002.Timestamp | undefined {\n      return this._startedBefore;\n    }\n    set startedBefore(value: googleProtobuf002.Timestamp | undefined) {\n      this._startedBefore = value;\n    }\n    get endedAfter(): googleProtobuf002.Timestamp | undefined {\n      return this._endedAfter;\n    }\n    set endedAfter(value: googleProtobuf002.Timestamp | undefined) {\n      this._endedAfter = value;\n    }\n    get endedBefore(): googleProtobuf002.Timestamp | undefined {\n      return this._endedBefore;\n    }\n    set endedBefore(value: googleProtobuf002.Timestamp | undefined) {\n      this._endedBefore = value;\n    }\n\n    /**\n     * Serialize message to binary data\n     * @param instance message instance\n     */\n    serializeBinary() {\n      const writer = new BinaryWriter();\n      Filter.serializeBinaryToWriter(this, writer);\n      return writer.getResultBuffer();\n    }\n\n    /**\n     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)\n     */\n    toObject(): Filter.AsObject {\n      return {\n        sessionId: this.sessionId,\n        status: (this.status || []).slice(),\n        createdAfter: this.createdAfter\n          ? this.createdAfter.toObject()\n          : undefined,\n        createdBefore: this.createdBefore\n          ? this.createdBefore.toObject()\n          : undefined,\n        startedAfter: this.startedAfter\n          ? this.startedAfter.toObject()\n          : undefined,\n        startedBefore: this.startedBefore\n          ? this.startedBefore.toObject()\n          : undefined,\n        endedAfter: this.endedAfter ? this.endedAfter.toObject() : undefined,\n        endedBefore: this.endedBefore ? this.endedBefore.toObject() : undefined\n      };\n    }\n\n    /**\n     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()\n     */\n    toJSON() {\n      return this.toObject();\n    }\n\n    /**\n     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json\n     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.\n     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required\n     */\n    toProtobufJSON(\n      // @ts-ignore\n      options?: ToProtobufJSONOptions\n    ): Filter.AsProtobufJSON {\n      return {\n        sessionId: this.sessionId,\n        status: (this.status || []).map(\n          v => armonikApiGrpcV1Task_status001.TaskStatus[v]\n        ),\n        createdAfter: this.createdAfter\n          ? this.createdAfter.toProtobufJSON(options)\n          : null,\n        createdBefore: this.createdBefore\n          ? this.createdBefore.toProtobufJSON(options)\n          : null,\n        startedAfter: this.startedAfter\n          ? this.startedAfter.toProtobufJSON(options)\n          : null,\n        startedBefore: this.startedBefore\n          ? this.startedBefore.toProtobufJSON(options)\n          : null,\n        endedAfter: this.endedAfter\n          ? this.endedAfter.toProtobufJSON(options)\n          : null,\n        endedBefore: this.endedBefore\n          ? this.endedBefore.toProtobufJSON(options)\n          : null\n      };\n    }\n  }\n  export module Filter {\n    /**\n     * Standard JavaScript object representation for Filter\n     */\n    export interface AsObject {\n      sessionId: string;\n      status: armonikApiGrpcV1Task_status001.TaskStatus[];\n      createdAfter?: googleProtobuf002.Timestamp.AsObject;\n      createdBefore?: googleProtobuf002.Timestamp.AsObject;\n      startedAfter?: googleProtobuf002.Timestamp.AsObject;\n      startedBefore?: googleProtobuf002.Timestamp.AsObject;\n      endedAfter?: googleProtobuf002.Timestamp.AsObject;\n      endedBefore?: googleProtobuf002.Timestamp.AsObject;\n    }\n\n    /**\n     * Protobuf JSON representation for Filter\n     */\n    export interface AsProtobufJSON {\n      sessionId: string;\n      status: string[];\n      createdAfter: googleProtobuf002.Timestamp.AsProtobufJSON | null;\n      createdBefore: googleProtobuf002.Timestamp.AsProtobufJSON | null;\n      startedAfter: googleProtobuf002.Timestamp.AsProtobufJSON | null;\n      startedBefore: googleProtobuf002.Timestamp.AsProtobufJSON | null;\n      endedAfter: googleProtobuf002.Timestamp.AsProtobufJSON | null;\n      endedBefore: googleProtobuf002.Timestamp.AsProtobufJSON | null;\n    }\n  }\n\n  /**\n   * Message implementation for armonik.api.grpc.v1.tasks.ListTasksRequest.Sort\n   */\n  export class Sort implements GrpcMessage {\n    static id = 'armonik.api.grpc.v1.tasks.ListTasksRequest.Sort';\n\n    /**\n     * Deserialize binary data to message\n     * @param instance message instance\n     */\n    static deserializeBinary(bytes: ByteSource) {\n      const instance = new Sort();\n      Sort.deserializeBinaryFromReader(instance, new BinaryReader(bytes));\n      return instance;\n    }\n\n    /**\n     * Check all the properties and set default protobuf values if necessary\n     * @param _instance message instance\n     */\n    static refineValues(_instance: Sort) {\n      _instance.field = _instance.field || 0;\n      _instance.direction = _instance.direction || 0;\n    }\n\n    /**\n     * Deserializes / reads binary message into message instance using provided binary reader\n     * @param _instance message instance\n     * @param _reader binary reader instance\n     */\n    static deserializeBinaryFromReader(_instance: Sort, _reader: BinaryReader) {\n      while (_reader.nextField()) {\n        if (_reader.isEndGroup()) break;\n\n        switch (_reader.getFieldNumber()) {\n          case 1:\n            _instance.field = _reader.readEnum();\n            break;\n          case 2:\n            _instance.direction = _reader.readEnum();\n            break;\n          default:\n            _reader.skipField();\n        }\n      }\n\n      Sort.refineValues(_instance);\n    }\n\n    /**\n     * Serializes a message to binary format using provided binary reader\n     * @param _instance message instance\n     * @param _writer binary writer instance\n     */\n    static serializeBinaryToWriter(_instance: Sort, _writer: BinaryWriter) {\n      if (_instance.field) {\n        _writer.writeEnum(1, _instance.field);\n      }\n      if (_instance.direction) {\n        _writer.writeEnum(2, _instance.direction);\n      }\n    }\n\n    private _field: ListTasksRequest.OrderByField;\n    private _direction: ListTasksRequest.OrderDirection;\n\n    /**\n     * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n     * @param _value initial values object or instance of Sort to deeply clone from\n     */\n    constructor(_value?: RecursivePartial<Sort.AsObject>) {\n      _value = _value || {};\n      this.field = _value.field;\n      this.direction = _value.direction;\n      Sort.refineValues(this);\n    }\n    get field(): ListTasksRequest.OrderByField {\n      return this._field;\n    }\n    set field(value: ListTasksRequest.OrderByField) {\n      this._field = value;\n    }\n    get direction(): ListTasksRequest.OrderDirection {\n      return this._direction;\n    }\n    set direction(value: ListTasksRequest.OrderDirection) {\n      this._direction = value;\n    }\n\n    /**\n     * Serialize message to binary data\n     * @param instance message instance\n     */\n    serializeBinary() {\n      const writer = new BinaryWriter();\n      Sort.serializeBinaryToWriter(this, writer);\n      return writer.getResultBuffer();\n    }\n\n    /**\n     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)\n     */\n    toObject(): Sort.AsObject {\n      return {\n        field: this.field,\n        direction: this.direction\n      };\n    }\n\n    /**\n     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()\n     */\n    toJSON() {\n      return this.toObject();\n    }\n\n    /**\n     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json\n     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.\n     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required\n     */\n    toProtobufJSON(\n      // @ts-ignore\n      options?: ToProtobufJSONOptions\n    ): Sort.AsProtobufJSON {\n      return {\n        field:\n          ListTasksRequest.OrderByField[\n            this.field === null || this.field === undefined ? 0 : this.field\n          ],\n        direction:\n          ListTasksRequest.OrderDirection[\n            this.direction === null || this.direction === undefined\n              ? 0\n              : this.direction\n          ]\n      };\n    }\n  }\n  export module Sort {\n    /**\n     * Standard JavaScript object representation for Sort\n     */\n    export interface AsObject {\n      field: ListTasksRequest.OrderByField;\n      direction: ListTasksRequest.OrderDirection;\n    }\n\n    /**\n     * Protobuf JSON representation for Sort\n     */\n    export interface AsProtobufJSON {\n      field: string;\n      direction: string;\n    }\n  }\n}\n\n/**\n * Message implementation for armonik.api.grpc.v1.tasks.ListTasksResponse\n */\nexport class ListTasksResponse implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.tasks.ListTasksResponse';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new ListTasksResponse();\n    ListTasksResponse.deserializeBinaryFromReader(\n      instance,\n      new BinaryReader(bytes)\n    );\n    return instance;\n  }\n\n  /**\n   * Check all the properties and set default protobuf values if necessary\n   * @param _instance message instance\n   */\n  static refineValues(_instance: ListTasksResponse) {\n    _instance.tasks = _instance.tasks || [];\n    _instance.page = _instance.page || 0;\n    _instance.pageSize = _instance.pageSize || 0;\n    _instance.total = _instance.total || 0;\n  }\n\n  /**\n   * Deserializes / reads binary message into message instance using provided binary reader\n   * @param _instance message instance\n   * @param _reader binary reader instance\n   */\n  static deserializeBinaryFromReader(\n    _instance: ListTasksResponse,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          const messageInitializer1 = new TaskSummary();\n          _reader.readMessage(\n            messageInitializer1,\n            TaskSummary.deserializeBinaryFromReader\n          );\n          (_instance.tasks = _instance.tasks || []).push(messageInitializer1);\n          break;\n        case 2:\n          _instance.page = _reader.readInt32();\n          break;\n        case 3:\n          _instance.pageSize = _reader.readInt32();\n          break;\n        case 4:\n          _instance.total = _reader.readInt32();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    ListTasksResponse.refineValues(_instance);\n  }\n\n  /**\n   * Serializes a message to binary format using provided binary reader\n   * @param _instance message instance\n   * @param _writer binary writer instance\n   */\n  static serializeBinaryToWriter(\n    _instance: ListTasksResponse,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.tasks && _instance.tasks.length) {\n      _writer.writeRepeatedMessage(\n        1,\n        _instance.tasks as any,\n        TaskSummary.serializeBinaryToWriter\n      );\n    }\n    if (_instance.page) {\n      _writer.writeInt32(2, _instance.page);\n    }\n    if (_instance.pageSize) {\n      _writer.writeInt32(3, _instance.pageSize);\n    }\n    if (_instance.total) {\n      _writer.writeInt32(4, _instance.total);\n    }\n  }\n\n  private _tasks?: TaskSummary[];\n  private _page: number;\n  private _pageSize: number;\n  private _total: number;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of ListTasksResponse to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<ListTasksResponse.AsObject>) {\n    _value = _value || {};\n    this.tasks = (_value.tasks || []).map(m => new TaskSummary(m));\n    this.page = _value.page;\n    this.pageSize = _value.pageSize;\n    this.total = _value.total;\n    ListTasksResponse.refineValues(this);\n  }\n  get tasks(): TaskSummary[] | undefined {\n    return this._tasks;\n  }\n  set tasks(value: TaskSummary[] | undefined) {\n    this._tasks = value;\n  }\n  get page(): number {\n    return this._page;\n  }\n  set page(value: number) {\n    this._page = value;\n  }\n  get pageSize(): number {\n    return this._pageSize;\n  }\n  set pageSize(value: number) {\n    this._pageSize = value;\n  }\n  get total(): number {\n    return this._total;\n  }\n  set total(value: number) {\n    this._total = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    ListTasksResponse.serializeBinaryToWriter(this, writer);\n    return writer.getResultBuffer();\n  }\n\n  /**\n   * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)\n   */\n  toObject(): ListTasksResponse.AsObject {\n    return {\n      tasks: (this.tasks || []).map(m => m.toObject()),\n      page: this.page,\n      pageSize: this.pageSize,\n      total: this.total\n    };\n  }\n\n  /**\n   * Convenience method to support JSON.stringify(message), replicates the structure of toObject()\n   */\n  toJSON() {\n    return this.toObject();\n  }\n\n  /**\n   * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json\n   * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.\n   * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required\n   */\n  toProtobufJSON(\n    // @ts-ignore\n    options?: ToProtobufJSONOptions\n  ): ListTasksResponse.AsProtobufJSON {\n    return {\n      tasks: (this.tasks || []).map(m => m.toProtobufJSON(options)),\n      page: this.page,\n      pageSize: this.pageSize,\n      total: this.total\n    };\n  }\n}\nexport module ListTasksResponse {\n  /**\n   * Standard JavaScript object representation for ListTasksResponse\n   */\n  export interface AsObject {\n    tasks?: TaskSummary.AsObject[];\n    page: number;\n    pageSize: number;\n    total: number;\n  }\n\n  /**\n   * Protobuf JSON representation for ListTasksResponse\n   */\n  export interface AsProtobufJSON {\n    tasks: TaskSummary.AsProtobufJSON[] | null;\n    page: number;\n    pageSize: number;\n    total: number;\n  }\n}\n\n/**\n * Message implementation for armonik.api.grpc.v1.tasks.GetTaskRequest\n */\nexport class GetTaskRequest implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.tasks.GetTaskRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new GetTaskRequest();\n    GetTaskRequest.deserializeBinaryFromReader(\n      instance,\n      new BinaryReader(bytes)\n    );\n    return instance;\n  }\n\n  /**\n   * Check all the properties and set default protobuf values if necessary\n   * @param _instance message instance\n   */\n  static refineValues(_instance: GetTaskRequest) {\n    _instance.taskId = _instance.taskId || '';\n  }\n\n  /**\n   * Deserializes / reads binary message into message instance using provided binary reader\n   * @param _instance message instance\n   * @param _reader binary reader instance\n   */\n  static deserializeBinaryFromReader(\n    _instance: GetTaskRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.taskId = _reader.readString();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    GetTaskRequest.refineValues(_instance);\n  }\n\n  /**\n   * Serializes a message to binary format using provided binary reader\n   * @param _instance message instance\n   * @param _writer binary writer instance\n   */\n  static serializeBinaryToWriter(\n    _instance: GetTaskRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.taskId) {\n      _writer.writeString(1, _instance.taskId);\n    }\n  }\n\n  private _taskId: string;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of GetTaskRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<GetTaskRequest.AsObject>) {\n    _value = _value || {};\n    this.taskId = _value.taskId;\n    GetTaskRequest.refineValues(this);\n  }\n  get taskId(): string {\n    return this._taskId;\n  }\n  set taskId(value: string) {\n    this._taskId = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    GetTaskRequest.serializeBinaryToWriter(this, writer);\n    return writer.getResultBuffer();\n  }\n\n  /**\n   * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)\n   */\n  toObject(): GetTaskRequest.AsObject {\n    return {\n      taskId: this.taskId\n    };\n  }\n\n  /**\n   * Convenience method to support JSON.stringify(message), replicates the structure of toObject()\n   */\n  toJSON() {\n    return this.toObject();\n  }\n\n  /**\n   * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json\n   * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.\n   * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required\n   */\n  toProtobufJSON(\n    // @ts-ignore\n    options?: ToProtobufJSONOptions\n  ): GetTaskRequest.AsProtobufJSON {\n    return {\n      taskId: this.taskId\n    };\n  }\n}\nexport module GetTaskRequest {\n  /**\n   * Standard JavaScript object representation for GetTaskRequest\n   */\n  export interface AsObject {\n    taskId: string;\n  }\n\n  /**\n   * Protobuf JSON representation for GetTaskRequest\n   */\n  export interface AsProtobufJSON {\n    taskId: string;\n  }\n}\n\n/**\n * Message implementation for armonik.api.grpc.v1.tasks.GetTaskResponse\n */\nexport class GetTaskResponse implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.tasks.GetTaskResponse';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new GetTaskResponse();\n    GetTaskResponse.deserializeBinaryFromReader(\n      instance,\n      new BinaryReader(bytes)\n    );\n    return instance;\n  }\n\n  /**\n   * Check all the properties and set default protobuf values if necessary\n   * @param _instance message instance\n   */\n  static refineValues(_instance: GetTaskResponse) {\n    _instance.task = _instance.task || undefined;\n  }\n\n  /**\n   * Deserializes / reads binary message into message instance using provided binary reader\n   * @param _instance message instance\n   * @param _reader binary reader instance\n   */\n  static deserializeBinaryFromReader(\n    _instance: GetTaskResponse,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.task = new TaskRaw();\n          _reader.readMessage(\n            _instance.task,\n            TaskRaw.deserializeBinaryFromReader\n          );\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    GetTaskResponse.refineValues(_instance);\n  }\n\n  /**\n   * Serializes a message to binary format using provided binary reader\n   * @param _instance message instance\n   * @param _writer binary writer instance\n   */\n  static serializeBinaryToWriter(\n    _instance: GetTaskResponse,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.task) {\n      _writer.writeMessage(\n        1,\n        _instance.task as any,\n        TaskRaw.serializeBinaryToWriter\n      );\n    }\n  }\n\n  private _task?: TaskRaw;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of GetTaskResponse to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<GetTaskResponse.AsObject>) {\n    _value = _value || {};\n    this.task = _value.task ? new TaskRaw(_value.task) : undefined;\n    GetTaskResponse.refineValues(this);\n  }\n  get task(): TaskRaw | undefined {\n    return this._task;\n  }\n  set task(value: TaskRaw | undefined) {\n    this._task = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    GetTaskResponse.serializeBinaryToWriter(this, writer);\n    return writer.getResultBuffer();\n  }\n\n  /**\n   * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)\n   */\n  toObject(): GetTaskResponse.AsObject {\n    return {\n      task: this.task ? this.task.toObject() : undefined\n    };\n  }\n\n  /**\n   * Convenience method to support JSON.stringify(message), replicates the structure of toObject()\n   */\n  toJSON() {\n    return this.toObject();\n  }\n\n  /**\n   * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json\n   * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.\n   * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required\n   */\n  toProtobufJSON(\n    // @ts-ignore\n    options?: ToProtobufJSONOptions\n  ): GetTaskResponse.AsProtobufJSON {\n    return {\n      task: this.task ? this.task.toProtobufJSON(options) : null\n    };\n  }\n}\nexport module GetTaskResponse {\n  /**\n   * Standard JavaScript object representation for GetTaskResponse\n   */\n  export interface AsObject {\n    task?: TaskRaw.AsObject;\n  }\n\n  /**\n   * Protobuf JSON representation for GetTaskResponse\n   */\n  export interface AsProtobufJSON {\n    task: TaskRaw.AsProtobufJSON | null;\n  }\n}\n\n/**\n * Message implementation for armonik.api.grpc.v1.tasks.CancelTasksRequest\n */\nexport class CancelTasksRequest implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.tasks.CancelTasksRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new CancelTasksRequest();\n    CancelTasksRequest.deserializeBinaryFromReader(\n      instance,\n      new BinaryReader(bytes)\n    );\n    return instance;\n  }\n\n  /**\n   * Check all the properties and set default protobuf values if necessary\n   * @param _instance message instance\n   */\n  static refineValues(_instance: CancelTasksRequest) {\n    _instance.taskIds = _instance.taskIds || [];\n  }\n\n  /**\n   * Deserializes / reads binary message into message instance using provided binary reader\n   * @param _instance message instance\n   * @param _reader binary reader instance\n   */\n  static deserializeBinaryFromReader(\n    _instance: CancelTasksRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          (_instance.taskIds = _instance.taskIds || []).push(\n            _reader.readString()\n          );\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    CancelTasksRequest.refineValues(_instance);\n  }\n\n  /**\n   * Serializes a message to binary format using provided binary reader\n   * @param _instance message instance\n   * @param _writer binary writer instance\n   */\n  static serializeBinaryToWriter(\n    _instance: CancelTasksRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.taskIds && _instance.taskIds.length) {\n      _writer.writeRepeatedString(1, _instance.taskIds);\n    }\n  }\n\n  private _taskIds: string[];\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of CancelTasksRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<CancelTasksRequest.AsObject>) {\n    _value = _value || {};\n    this.taskIds = (_value.taskIds || []).slice();\n    CancelTasksRequest.refineValues(this);\n  }\n  get taskIds(): string[] {\n    return this._taskIds;\n  }\n  set taskIds(value: string[]) {\n    this._taskIds = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    CancelTasksRequest.serializeBinaryToWriter(this, writer);\n    return writer.getResultBuffer();\n  }\n\n  /**\n   * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)\n   */\n  toObject(): CancelTasksRequest.AsObject {\n    return {\n      taskIds: (this.taskIds || []).slice()\n    };\n  }\n\n  /**\n   * Convenience method to support JSON.stringify(message), replicates the structure of toObject()\n   */\n  toJSON() {\n    return this.toObject();\n  }\n\n  /**\n   * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json\n   * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.\n   * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required\n   */\n  toProtobufJSON(\n    // @ts-ignore\n    options?: ToProtobufJSONOptions\n  ): CancelTasksRequest.AsProtobufJSON {\n    return {\n      taskIds: (this.taskIds || []).slice()\n    };\n  }\n}\nexport module CancelTasksRequest {\n  /**\n   * Standard JavaScript object representation for CancelTasksRequest\n   */\n  export interface AsObject {\n    taskIds: string[];\n  }\n\n  /**\n   * Protobuf JSON representation for CancelTasksRequest\n   */\n  export interface AsProtobufJSON {\n    taskIds: string[];\n  }\n}\n\n/**\n * Message implementation for armonik.api.grpc.v1.tasks.CancelTasksResponse\n */\nexport class CancelTasksResponse implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.tasks.CancelTasksResponse';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new CancelTasksResponse();\n    CancelTasksResponse.deserializeBinaryFromReader(\n      instance,\n      new BinaryReader(bytes)\n    );\n    return instance;\n  }\n\n  /**\n   * Check all the properties and set default protobuf values if necessary\n   * @param _instance message instance\n   */\n  static refineValues(_instance: CancelTasksResponse) {\n    _instance.tasks = _instance.tasks || [];\n  }\n\n  /**\n   * Deserializes / reads binary message into message instance using provided binary reader\n   * @param _instance message instance\n   * @param _reader binary reader instance\n   */\n  static deserializeBinaryFromReader(\n    _instance: CancelTasksResponse,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          const messageInitializer1 = new TaskSummary();\n          _reader.readMessage(\n            messageInitializer1,\n            TaskSummary.deserializeBinaryFromReader\n          );\n          (_instance.tasks = _instance.tasks || []).push(messageInitializer1);\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    CancelTasksResponse.refineValues(_instance);\n  }\n\n  /**\n   * Serializes a message to binary format using provided binary reader\n   * @param _instance message instance\n   * @param _writer binary writer instance\n   */\n  static serializeBinaryToWriter(\n    _instance: CancelTasksResponse,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.tasks && _instance.tasks.length) {\n      _writer.writeRepeatedMessage(\n        1,\n        _instance.tasks as any,\n        TaskSummary.serializeBinaryToWriter\n      );\n    }\n  }\n\n  private _tasks?: TaskSummary[];\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of CancelTasksResponse to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<CancelTasksResponse.AsObject>) {\n    _value = _value || {};\n    this.tasks = (_value.tasks || []).map(m => new TaskSummary(m));\n    CancelTasksResponse.refineValues(this);\n  }\n  get tasks(): TaskSummary[] | undefined {\n    return this._tasks;\n  }\n  set tasks(value: TaskSummary[] | undefined) {\n    this._tasks = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    CancelTasksResponse.serializeBinaryToWriter(this, writer);\n    return writer.getResultBuffer();\n  }\n\n  /**\n   * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)\n   */\n  toObject(): CancelTasksResponse.AsObject {\n    return {\n      tasks: (this.tasks || []).map(m => m.toObject())\n    };\n  }\n\n  /**\n   * Convenience method to support JSON.stringify(message), replicates the structure of toObject()\n   */\n  toJSON() {\n    return this.toObject();\n  }\n\n  /**\n   * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json\n   * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.\n   * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required\n   */\n  toProtobufJSON(\n    // @ts-ignore\n    options?: ToProtobufJSONOptions\n  ): CancelTasksResponse.AsProtobufJSON {\n    return {\n      tasks: (this.tasks || []).map(m => m.toProtobufJSON(options))\n    };\n  }\n}\nexport module CancelTasksResponse {\n  /**\n   * Standard JavaScript object representation for CancelTasksResponse\n   */\n  export interface AsObject {\n    tasks?: TaskSummary.AsObject[];\n  }\n\n  /**\n   * Protobuf JSON representation for CancelTasksResponse\n   */\n  export interface AsProtobufJSON {\n    tasks: TaskSummary.AsProtobufJSON[] | null;\n  }\n}\n\n/**\n * Message implementation for armonik.api.grpc.v1.tasks.GetResultIdsRequest\n */\nexport class GetResultIdsRequest implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.tasks.GetResultIdsRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new GetResultIdsRequest();\n    GetResultIdsRequest.deserializeBinaryFromReader(\n      instance,\n      new BinaryReader(bytes)\n    );\n    return instance;\n  }\n\n  /**\n   * Check all the properties and set default protobuf values if necessary\n   * @param _instance message instance\n   */\n  static refineValues(_instance: GetResultIdsRequest) {\n    _instance.taskId = _instance.taskId || [];\n  }\n\n  /**\n   * Deserializes / reads binary message into message instance using provided binary reader\n   * @param _instance message instance\n   * @param _reader binary reader instance\n   */\n  static deserializeBinaryFromReader(\n    _instance: GetResultIdsRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          (_instance.taskId = _instance.taskId || []).push(\n            _reader.readString()\n          );\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    GetResultIdsRequest.refineValues(_instance);\n  }\n\n  /**\n   * Serializes a message to binary format using provided binary reader\n   * @param _instance message instance\n   * @param _writer binary writer instance\n   */\n  static serializeBinaryToWriter(\n    _instance: GetResultIdsRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.taskId && _instance.taskId.length) {\n      _writer.writeRepeatedString(1, _instance.taskId);\n    }\n  }\n\n  private _taskId: string[];\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of GetResultIdsRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<GetResultIdsRequest.AsObject>) {\n    _value = _value || {};\n    this.taskId = (_value.taskId || []).slice();\n    GetResultIdsRequest.refineValues(this);\n  }\n  get taskId(): string[] {\n    return this._taskId;\n  }\n  set taskId(value: string[]) {\n    this._taskId = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    GetResultIdsRequest.serializeBinaryToWriter(this, writer);\n    return writer.getResultBuffer();\n  }\n\n  /**\n   * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)\n   */\n  toObject(): GetResultIdsRequest.AsObject {\n    return {\n      taskId: (this.taskId || []).slice()\n    };\n  }\n\n  /**\n   * Convenience method to support JSON.stringify(message), replicates the structure of toObject()\n   */\n  toJSON() {\n    return this.toObject();\n  }\n\n  /**\n   * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json\n   * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.\n   * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required\n   */\n  toProtobufJSON(\n    // @ts-ignore\n    options?: ToProtobufJSONOptions\n  ): GetResultIdsRequest.AsProtobufJSON {\n    return {\n      taskId: (this.taskId || []).slice()\n    };\n  }\n}\nexport module GetResultIdsRequest {\n  /**\n   * Standard JavaScript object representation for GetResultIdsRequest\n   */\n  export interface AsObject {\n    taskId: string[];\n  }\n\n  /**\n   * Protobuf JSON representation for GetResultIdsRequest\n   */\n  export interface AsProtobufJSON {\n    taskId: string[];\n  }\n}\n\n/**\n * Message implementation for armonik.api.grpc.v1.tasks.GetResultIdsResponse\n */\nexport class GetResultIdsResponse implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.tasks.GetResultIdsResponse';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new GetResultIdsResponse();\n    GetResultIdsResponse.deserializeBinaryFromReader(\n      instance,\n      new BinaryReader(bytes)\n    );\n    return instance;\n  }\n\n  /**\n   * Check all the properties and set default protobuf values if necessary\n   * @param _instance message instance\n   */\n  static refineValues(_instance: GetResultIdsResponse) {\n    _instance.taskResults = _instance.taskResults || [];\n  }\n\n  /**\n   * Deserializes / reads binary message into message instance using provided binary reader\n   * @param _instance message instance\n   * @param _reader binary reader instance\n   */\n  static deserializeBinaryFromReader(\n    _instance: GetResultIdsResponse,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          const messageInitializer1 = new GetResultIdsResponse.MapTaskResult();\n          _reader.readMessage(\n            messageInitializer1,\n            GetResultIdsResponse.MapTaskResult.deserializeBinaryFromReader\n          );\n          (_instance.taskResults = _instance.taskResults || []).push(\n            messageInitializer1\n          );\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    GetResultIdsResponse.refineValues(_instance);\n  }\n\n  /**\n   * Serializes a message to binary format using provided binary reader\n   * @param _instance message instance\n   * @param _writer binary writer instance\n   */\n  static serializeBinaryToWriter(\n    _instance: GetResultIdsResponse,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.taskResults && _instance.taskResults.length) {\n      _writer.writeRepeatedMessage(\n        1,\n        _instance.taskResults as any,\n        GetResultIdsResponse.MapTaskResult.serializeBinaryToWriter\n      );\n    }\n  }\n\n  private _taskResults?: GetResultIdsResponse.MapTaskResult[];\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of GetResultIdsResponse to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<GetResultIdsResponse.AsObject>) {\n    _value = _value || {};\n    this.taskResults = (_value.taskResults || []).map(\n      m => new GetResultIdsResponse.MapTaskResult(m)\n    );\n    GetResultIdsResponse.refineValues(this);\n  }\n  get taskResults(): GetResultIdsResponse.MapTaskResult[] | undefined {\n    return this._taskResults;\n  }\n  set taskResults(value: GetResultIdsResponse.MapTaskResult[] | undefined) {\n    this._taskResults = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    GetResultIdsResponse.serializeBinaryToWriter(this, writer);\n    return writer.getResultBuffer();\n  }\n\n  /**\n   * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)\n   */\n  toObject(): GetResultIdsResponse.AsObject {\n    return {\n      taskResults: (this.taskResults || []).map(m => m.toObject())\n    };\n  }\n\n  /**\n   * Convenience method to support JSON.stringify(message), replicates the structure of toObject()\n   */\n  toJSON() {\n    return this.toObject();\n  }\n\n  /**\n   * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json\n   * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.\n   * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required\n   */\n  toProtobufJSON(\n    // @ts-ignore\n    options?: ToProtobufJSONOptions\n  ): GetResultIdsResponse.AsProtobufJSON {\n    return {\n      taskResults: (this.taskResults || []).map(m => m.toProtobufJSON(options))\n    };\n  }\n}\nexport module GetResultIdsResponse {\n  /**\n   * Standard JavaScript object representation for GetResultIdsResponse\n   */\n  export interface AsObject {\n    taskResults?: GetResultIdsResponse.MapTaskResult.AsObject[];\n  }\n\n  /**\n   * Protobuf JSON representation for GetResultIdsResponse\n   */\n  export interface AsProtobufJSON {\n    taskResults: GetResultIdsResponse.MapTaskResult.AsProtobufJSON[] | null;\n  }\n\n  /**\n   * Message implementation for armonik.api.grpc.v1.tasks.GetResultIdsResponse.MapTaskResult\n   */\n  export class MapTaskResult implements GrpcMessage {\n    static id = 'armonik.api.grpc.v1.tasks.GetResultIdsResponse.MapTaskResult';\n\n    /**\n     * Deserialize binary data to message\n     * @param instance message instance\n     */\n    static deserializeBinary(bytes: ByteSource) {\n      const instance = new MapTaskResult();\n      MapTaskResult.deserializeBinaryFromReader(\n        instance,\n        new BinaryReader(bytes)\n      );\n      return instance;\n    }\n\n    /**\n     * Check all the properties and set default protobuf values if necessary\n     * @param _instance message instance\n     */\n    static refineValues(_instance: MapTaskResult) {\n      _instance.taskId = _instance.taskId || '';\n      _instance.resultIds = _instance.resultIds || [];\n    }\n\n    /**\n     * Deserializes / reads binary message into message instance using provided binary reader\n     * @param _instance message instance\n     * @param _reader binary reader instance\n     */\n    static deserializeBinaryFromReader(\n      _instance: MapTaskResult,\n      _reader: BinaryReader\n    ) {\n      while (_reader.nextField()) {\n        if (_reader.isEndGroup()) break;\n\n        switch (_reader.getFieldNumber()) {\n          case 1:\n            _instance.taskId = _reader.readString();\n            break;\n          case 2:\n            (_instance.resultIds = _instance.resultIds || []).push(\n              _reader.readString()\n            );\n            break;\n          default:\n            _reader.skipField();\n        }\n      }\n\n      MapTaskResult.refineValues(_instance);\n    }\n\n    /**\n     * Serializes a message to binary format using provided binary reader\n     * @param _instance message instance\n     * @param _writer binary writer instance\n     */\n    static serializeBinaryToWriter(\n      _instance: MapTaskResult,\n      _writer: BinaryWriter\n    ) {\n      if (_instance.taskId) {\n        _writer.writeString(1, _instance.taskId);\n      }\n      if (_instance.resultIds && _instance.resultIds.length) {\n        _writer.writeRepeatedString(2, _instance.resultIds);\n      }\n    }\n\n    private _taskId: string;\n    private _resultIds: string[];\n\n    /**\n     * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n     * @param _value initial values object or instance of MapTaskResult to deeply clone from\n     */\n    constructor(_value?: RecursivePartial<MapTaskResult.AsObject>) {\n      _value = _value || {};\n      this.taskId = _value.taskId;\n      this.resultIds = (_value.resultIds || []).slice();\n      MapTaskResult.refineValues(this);\n    }\n    get taskId(): string {\n      return this._taskId;\n    }\n    set taskId(value: string) {\n      this._taskId = value;\n    }\n    get resultIds(): string[] {\n      return this._resultIds;\n    }\n    set resultIds(value: string[]) {\n      this._resultIds = value;\n    }\n\n    /**\n     * Serialize message to binary data\n     * @param instance message instance\n     */\n    serializeBinary() {\n      const writer = new BinaryWriter();\n      MapTaskResult.serializeBinaryToWriter(this, writer);\n      return writer.getResultBuffer();\n    }\n\n    /**\n     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)\n     */\n    toObject(): MapTaskResult.AsObject {\n      return {\n        taskId: this.taskId,\n        resultIds: (this.resultIds || []).slice()\n      };\n    }\n\n    /**\n     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()\n     */\n    toJSON() {\n      return this.toObject();\n    }\n\n    /**\n     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json\n     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.\n     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required\n     */\n    toProtobufJSON(\n      // @ts-ignore\n      options?: ToProtobufJSONOptions\n    ): MapTaskResult.AsProtobufJSON {\n      return {\n        taskId: this.taskId,\n        resultIds: (this.resultIds || []).slice()\n      };\n    }\n  }\n  export module MapTaskResult {\n    /**\n     * Standard JavaScript object representation for MapTaskResult\n     */\n    export interface AsObject {\n      taskId: string;\n      resultIds: string[];\n    }\n\n    /**\n     * Protobuf JSON representation for MapTaskResult\n     */\n    export interface AsProtobufJSON {\n      taskId: string;\n      resultIds: string[];\n    }\n  }\n}\n\n/**\n * Message implementation for armonik.api.grpc.v1.tasks.CountTasksByStatusRequest\n */\nexport class CountTasksByStatusRequest implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.tasks.CountTasksByStatusRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new CountTasksByStatusRequest();\n    CountTasksByStatusRequest.deserializeBinaryFromReader(\n      instance,\n      new BinaryReader(bytes)\n    );\n    return instance;\n  }\n\n  /**\n   * Check all the properties and set default protobuf values if necessary\n   * @param _instance message instance\n   */\n  static refineValues(_instance: CountTasksByStatusRequest) {}\n\n  /**\n   * Deserializes / reads binary message into message instance using provided binary reader\n   * @param _instance message instance\n   * @param _reader binary reader instance\n   */\n  static deserializeBinaryFromReader(\n    _instance: CountTasksByStatusRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        default:\n          _reader.skipField();\n      }\n    }\n\n    CountTasksByStatusRequest.refineValues(_instance);\n  }\n\n  /**\n   * Serializes a message to binary format using provided binary reader\n   * @param _instance message instance\n   * @param _writer binary writer instance\n   */\n  static serializeBinaryToWriter(\n    _instance: CountTasksByStatusRequest,\n    _writer: BinaryWriter\n  ) {}\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of CountTasksByStatusRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<CountTasksByStatusRequest.AsObject>) {\n    _value = _value || {};\n    CountTasksByStatusRequest.refineValues(this);\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    CountTasksByStatusRequest.serializeBinaryToWriter(this, writer);\n    return writer.getResultBuffer();\n  }\n\n  /**\n   * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)\n   */\n  toObject(): CountTasksByStatusRequest.AsObject {\n    return {};\n  }\n\n  /**\n   * Convenience method to support JSON.stringify(message), replicates the structure of toObject()\n   */\n  toJSON() {\n    return this.toObject();\n  }\n\n  /**\n   * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json\n   * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.\n   * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required\n   */\n  toProtobufJSON(\n    // @ts-ignore\n    options?: ToProtobufJSONOptions\n  ): CountTasksByStatusRequest.AsProtobufJSON {\n    return {};\n  }\n}\nexport module CountTasksByStatusRequest {\n  /**\n   * Standard JavaScript object representation for CountTasksByStatusRequest\n   */\n  export interface AsObject {}\n\n  /**\n   * Protobuf JSON representation for CountTasksByStatusRequest\n   */\n  export interface AsProtobufJSON {}\n}\n\n/**\n * Message implementation for armonik.api.grpc.v1.tasks.CountTasksByStatusResponse\n */\nexport class CountTasksByStatusResponse implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.tasks.CountTasksByStatusResponse';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new CountTasksByStatusResponse();\n    CountTasksByStatusResponse.deserializeBinaryFromReader(\n      instance,\n      new BinaryReader(bytes)\n    );\n    return instance;\n  }\n\n  /**\n   * Check all the properties and set default protobuf values if necessary\n   * @param _instance message instance\n   */\n  static refineValues(_instance: CountTasksByStatusResponse) {\n    _instance.status = _instance.status || [];\n  }\n\n  /**\n   * Deserializes / reads binary message into message instance using provided binary reader\n   * @param _instance message instance\n   * @param _reader binary reader instance\n   */\n  static deserializeBinaryFromReader(\n    _instance: CountTasksByStatusResponse,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          const messageInitializer1 = new armonikApiGrpcV1003.StatusCount();\n          _reader.readMessage(\n            messageInitializer1,\n            armonikApiGrpcV1003.StatusCount.deserializeBinaryFromReader\n          );\n          (_instance.status = _instance.status || []).push(messageInitializer1);\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    CountTasksByStatusResponse.refineValues(_instance);\n  }\n\n  /**\n   * Serializes a message to binary format using provided binary reader\n   * @param _instance message instance\n   * @param _writer binary writer instance\n   */\n  static serializeBinaryToWriter(\n    _instance: CountTasksByStatusResponse,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.status && _instance.status.length) {\n      _writer.writeRepeatedMessage(\n        1,\n        _instance.status as any,\n        armonikApiGrpcV1003.StatusCount.serializeBinaryToWriter\n      );\n    }\n  }\n\n  private _status?: armonikApiGrpcV1003.StatusCount[];\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of CountTasksByStatusResponse to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<CountTasksByStatusResponse.AsObject>) {\n    _value = _value || {};\n    this.status = (_value.status || []).map(\n      m => new armonikApiGrpcV1003.StatusCount(m)\n    );\n    CountTasksByStatusResponse.refineValues(this);\n  }\n  get status(): armonikApiGrpcV1003.StatusCount[] | undefined {\n    return this._status;\n  }\n  set status(value: armonikApiGrpcV1003.StatusCount[] | undefined) {\n    this._status = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    CountTasksByStatusResponse.serializeBinaryToWriter(this, writer);\n    return writer.getResultBuffer();\n  }\n\n  /**\n   * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)\n   */\n  toObject(): CountTasksByStatusResponse.AsObject {\n    return {\n      status: (this.status || []).map(m => m.toObject())\n    };\n  }\n\n  /**\n   * Convenience method to support JSON.stringify(message), replicates the structure of toObject()\n   */\n  toJSON() {\n    return this.toObject();\n  }\n\n  /**\n   * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json\n   * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.\n   * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required\n   */\n  toProtobufJSON(\n    // @ts-ignore\n    options?: ToProtobufJSONOptions\n  ): CountTasksByStatusResponse.AsProtobufJSON {\n    return {\n      status: (this.status || []).map(m => m.toProtobufJSON(options))\n    };\n  }\n}\nexport module CountTasksByStatusResponse {\n  /**\n   * Standard JavaScript object representation for CountTasksByStatusResponse\n   */\n  export interface AsObject {\n    status?: armonikApiGrpcV1003.StatusCount.AsObject[];\n  }\n\n  /**\n   * Protobuf JSON representation for CountTasksByStatusResponse\n   */\n  export interface AsProtobufJSON {\n    status: armonikApiGrpcV1003.StatusCount.AsProtobufJSON[] | null;\n  }\n}\n"]}