@aneoconsultingfr/armonik.api.angular 3.4.0

package/esm2020/lib/generated/objects.pb.mjs

@@ -0,0 +1,2705 @@
+/* tslint:disable */
+/* eslint-disable */
+// @ts-nocheck
+//
+// THIS IS A GENERATED FILE
+// DO NOT MODIFY IT! YOUR CHANGES WILL BE LOST
+import { uint8ArrayToBase64 } from '@ngx-grpc/common';
+import { BinaryReader, BinaryWriter } from 'google-protobuf';
+import * as googleProtobuf000 from '@ngx-grpc/well-known-types';
+import * as armonikApiGrpcV1Task_status001 from './task-status.pb';
+/**
+ * Message implementation for armonik.api.grpc.v1.Empty
+ */
+export class Empty {
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new Empty();
+        Empty.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();
+            }
+        }
+        Empty.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 Empty to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        Empty.refineValues(this);
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        Empty.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 {};
+    }
+}
+Empty.id = 'armonik.api.grpc.v1.Empty';
+/**
+ * Message implementation for armonik.api.grpc.v1.TaskOptions
+ */
+export class TaskOptions {
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new TaskOptions();
+        TaskOptions.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.options = _instance.options || {};
+        _instance.maxDuration = _instance.maxDuration || undefined;
+        _instance.maxRetries = _instance.maxRetries || 0;
+        _instance.priority = _instance.priority || 0;
+        _instance.partitionId = _instance.partitionId || '';
+        _instance.applicationName = _instance.applicationName || '';
+        _instance.applicationVersion = _instance.applicationVersion || '';
+        _instance.applicationNamespace = _instance.applicationNamespace || '';
+        _instance.applicationService = _instance.applicationService || '';
+        _instance.engineType = _instance.engineType || '';
+    }
+    /**
+     * 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 msg_1 = {};
+                    _reader.readMessage(msg_1, TaskOptions.OptionsEntry.deserializeBinaryFromReader);
+                    _instance.options = _instance.options || {};
+                    _instance.options[msg_1.key] = msg_1.value;
+                    break;
+                case 2:
+                    _instance.maxDuration = new googleProtobuf000.Duration();
+                    _reader.readMessage(_instance.maxDuration, googleProtobuf000.Duration.deserializeBinaryFromReader);
+                    break;
+                case 3:
+                    _instance.maxRetries = _reader.readInt32();
+                    break;
+                case 4:
+                    _instance.priority = _reader.readInt32();
+                    break;
+                case 5:
+                    _instance.partitionId = _reader.readString();
+                    break;
+                case 6:
+                    _instance.applicationName = _reader.readString();
+                    break;
+                case 7:
+                    _instance.applicationVersion = _reader.readString();
+                    break;
+                case 8:
+                    _instance.applicationNamespace = _reader.readString();
+                    break;
+                case 9:
+                    _instance.applicationService = _reader.readString();
+                    break;
+                case 10:
+                    _instance.engineType = _reader.readString();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        TaskOptions.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.options) {
+            const keys_1 = Object.keys(_instance.options);
+            if (keys_1.length) {
+                const repeated_1 = keys_1
+                    .map(key => ({ key: key, value: _instance.options[key] }))
+                    .reduce((r, v) => [...r, v], []);
+                _writer.writeRepeatedMessage(1, repeated_1, TaskOptions.OptionsEntry.serializeBinaryToWriter);
+            }
+        }
+        if (_instance.maxDuration) {
+            _writer.writeMessage(2, _instance.maxDuration, googleProtobuf000.Duration.serializeBinaryToWriter);
+        }
+        if (_instance.maxRetries) {
+            _writer.writeInt32(3, _instance.maxRetries);
+        }
+        if (_instance.priority) {
+            _writer.writeInt32(4, _instance.priority);
+        }
+        if (_instance.partitionId) {
+            _writer.writeString(5, _instance.partitionId);
+        }
+        if (_instance.applicationName) {
+            _writer.writeString(6, _instance.applicationName);
+        }
+        if (_instance.applicationVersion) {
+            _writer.writeString(7, _instance.applicationVersion);
+        }
+        if (_instance.applicationNamespace) {
+            _writer.writeString(8, _instance.applicationNamespace);
+        }
+        if (_instance.applicationService) {
+            _writer.writeString(9, _instance.applicationService);
+        }
+        if (_instance.engineType) {
+            _writer.writeString(10, _instance.engineType);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of TaskOptions to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        (this.options = _value.options
+            ? Object.keys(_value.options).reduce((r, k) => ({ ...r, [k]: _value.options[k] }), {})
+            : {}),
+            (this.maxDuration = _value.maxDuration
+                ? new googleProtobuf000.Duration(_value.maxDuration)
+                : undefined);
+        this.maxRetries = _value.maxRetries;
+        this.priority = _value.priority;
+        this.partitionId = _value.partitionId;
+        this.applicationName = _value.applicationName;
+        this.applicationVersion = _value.applicationVersion;
+        this.applicationNamespace = _value.applicationNamespace;
+        this.applicationService = _value.applicationService;
+        this.engineType = _value.engineType;
+        TaskOptions.refineValues(this);
+    }
+    get options() {
+        return this._options;
+    }
+    set options(value) {
+        this._options = value;
+    }
+    get maxDuration() {
+        return this._maxDuration;
+    }
+    set maxDuration(value) {
+        this._maxDuration = value;
+    }
+    get maxRetries() {
+        return this._maxRetries;
+    }
+    set maxRetries(value) {
+        this._maxRetries = value;
+    }
+    get priority() {
+        return this._priority;
+    }
+    set priority(value) {
+        this._priority = value;
+    }
+    get partitionId() {
+        return this._partitionId;
+    }
+    set partitionId(value) {
+        this._partitionId = value;
+    }
+    get applicationName() {
+        return this._applicationName;
+    }
+    set applicationName(value) {
+        this._applicationName = value;
+    }
+    get applicationVersion() {
+        return this._applicationVersion;
+    }
+    set applicationVersion(value) {
+        this._applicationVersion = value;
+    }
+    get applicationNamespace() {
+        return this._applicationNamespace;
+    }
+    set applicationNamespace(value) {
+        this._applicationNamespace = value;
+    }
+    get applicationService() {
+        return this._applicationService;
+    }
+    set applicationService(value) {
+        this._applicationService = value;
+    }
+    get engineType() {
+        return this._engineType;
+    }
+    set engineType(value) {
+        this._engineType = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        TaskOptions.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            options: this.options
+                ? Object.keys(this.options).reduce((r, k) => ({ ...r, [k]: this.options[k] }), {})
+                : {},
+            maxDuration: this.maxDuration ? this.maxDuration.toObject() : undefined,
+            maxRetries: this.maxRetries,
+            priority: this.priority,
+            partitionId: this.partitionId,
+            applicationName: this.applicationName,
+            applicationVersion: this.applicationVersion,
+            applicationNamespace: this.applicationNamespace,
+            applicationService: this.applicationService,
+            engineType: this.engineType
+        };
+    }
+    /**
+     * 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 {
+            options: this.options
+                ? Object.keys(this.options).reduce((r, k) => ({ ...r, [k]: this.options[k] }), {})
+                : {},
+            maxDuration: this.maxDuration
+                ? this.maxDuration.toProtobufJSON(options)
+                : null,
+            maxRetries: this.maxRetries,
+            priority: this.priority,
+            partitionId: this.partitionId,
+            applicationName: this.applicationName,
+            applicationVersion: this.applicationVersion,
+            applicationNamespace: this.applicationNamespace,
+            applicationService: this.applicationService,
+            engineType: this.engineType
+        };
+    }
+}
+TaskOptions.id = 'armonik.api.grpc.v1.TaskOptions';
+(function (TaskOptions) {
+    /**
+     * Message implementation for armonik.api.grpc.v1.TaskOptions.OptionsEntry
+     */
+    class OptionsEntry {
+        /**
+         * Deserialize binary data to message
+         * @param instance message instance
+         */
+        static deserializeBinary(bytes) {
+            const instance = new OptionsEntry();
+            OptionsEntry.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.key = _instance.key || '';
+            _instance.value = _instance.value || '';
+        }
+        /**
+         * 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.key = _reader.readString();
+                        break;
+                    case 2:
+                        _instance.value = _reader.readString();
+                        break;
+                    default:
+                        _reader.skipField();
+                }
+            }
+            OptionsEntry.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.key) {
+                _writer.writeString(1, _instance.key);
+            }
+            if (_instance.value) {
+                _writer.writeString(2, _instance.value);
+            }
+        }
+        /**
+         * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+         * @param _value initial values object or instance of OptionsEntry to deeply clone from
+         */
+        constructor(_value) {
+            _value = _value || {};
+            this.key = _value.key;
+            this.value = _value.value;
+            OptionsEntry.refineValues(this);
+        }
+        get key() {
+            return this._key;
+        }
+        set key(value) {
+            this._key = value;
+        }
+        get value() {
+            return this._value;
+        }
+        set value(value) {
+            this._value = value;
+        }
+        /**
+         * Serialize message to binary data
+         * @param instance message instance
+         */
+        serializeBinary() {
+            const writer = new BinaryWriter();
+            OptionsEntry.serializeBinaryToWriter(this, writer);
+            return writer.getResultBuffer();
+        }
+        /**
+         * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+         */
+        toObject() {
+            return {
+                key: this.key,
+                value: this.value
+            };
+        }
+        /**
+         * 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 {
+                key: this.key,
+                value: this.value
+            };
+        }
+    }
+    OptionsEntry.id = 'armonik.api.grpc.v1.TaskOptions.OptionsEntry';
+    TaskOptions.OptionsEntry = OptionsEntry;
+})(TaskOptions || (TaskOptions = {}));
+/**
+ * Message implementation for armonik.api.grpc.v1.Session
+ */
+export class Session {
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new Session();
+        Session.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 || '';
+    }
+    /**
+     * 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;
+                default:
+                    _reader.skipField();
+            }
+        }
+        Session.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);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of Session to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.id = _value.id;
+        Session.refineValues(this);
+    }
+    get id() {
+        return this._id;
+    }
+    set id(value) {
+        this._id = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        Session.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            id: this.id
+        };
+    }
+    /**
+     * 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
+        };
+    }
+}
+Session.id = 'armonik.api.grpc.v1.Session';
+/**
+ * Message implementation for armonik.api.grpc.v1.Configuration
+ */
+export class Configuration {
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new Configuration();
+        Configuration.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.dataChunkMaxSize = _instance.dataChunkMaxSize || 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.dataChunkMaxSize = _reader.readInt32();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        Configuration.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.dataChunkMaxSize) {
+            _writer.writeInt32(1, _instance.dataChunkMaxSize);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of Configuration to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.dataChunkMaxSize = _value.dataChunkMaxSize;
+        Configuration.refineValues(this);
+    }
+    get dataChunkMaxSize() {
+        return this._dataChunkMaxSize;
+    }
+    set dataChunkMaxSize(value) {
+        this._dataChunkMaxSize = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        Configuration.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            dataChunkMaxSize: this.dataChunkMaxSize
+        };
+    }
+    /**
+     * 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 {
+            dataChunkMaxSize: this.dataChunkMaxSize
+        };
+    }
+}
+Configuration.id = 'armonik.api.grpc.v1.Configuration';
+/**
+ * Message implementation for armonik.api.grpc.v1.Output
+ */
+export 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) { }
+    /**
+     * 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 2:
+                    _instance.ok = new Empty();
+                    _reader.readMessage(_instance.ok, Empty.deserializeBinaryFromReader);
+                    break;
+                case 3:
+                    _instance.error = new Output.Error();
+                    _reader.readMessage(_instance.error, Output.Error.deserializeBinaryFromReader);
+                    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.ok) {
+            _writer.writeMessage(2, _instance.ok, Empty.serializeBinaryToWriter);
+        }
+        if (_instance.error) {
+            _writer.writeMessage(3, _instance.error, Output.Error.serializeBinaryToWriter);
+        }
+    }
+    /**
+     * 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) {
+        this._type = Output.TypeCase.none;
+        _value = _value || {};
+        this.ok = _value.ok ? new Empty(_value.ok) : undefined;
+        this.error = _value.error ? new Output.Error(_value.error) : undefined;
+        Output.refineValues(this);
+    }
+    get ok() {
+        return this._ok;
+    }
+    set ok(value) {
+        if (value !== undefined && value !== null) {
+            this._error = undefined;
+            this._type = Output.TypeCase.ok;
+        }
+        this._ok = value;
+    }
+    get error() {
+        return this._error;
+    }
+    set error(value) {
+        if (value !== undefined && value !== null) {
+            this._ok = undefined;
+            this._type = Output.TypeCase.error;
+        }
+        this._error = value;
+    }
+    get type() {
+        return this._type;
+    }
+    /**
+     * 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 {
+            ok: this.ok ? this.ok.toObject() : undefined,
+            error: this.error ? this.error.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 {
+            ok: this.ok ? this.ok.toProtobufJSON(options) : null,
+            error: this.error ? this.error.toProtobufJSON(options) : null
+        };
+    }
+}
+Output.id = 'armonik.api.grpc.v1.Output';
+(function (Output) {
+    let TypeCase;
+    (function (TypeCase) {
+        TypeCase[TypeCase["none"] = 0] = "none";
+        TypeCase[TypeCase["ok"] = 1] = "ok";
+        TypeCase[TypeCase["error"] = 2] = "error";
+    })(TypeCase = Output.TypeCase || (Output.TypeCase = {}));
+    /**
+     * Message implementation for armonik.api.grpc.v1.Output.Error
+     */
+    class Error {
+        /**
+         * Deserialize binary data to message
+         * @param instance message instance
+         */
+        static deserializeBinary(bytes) {
+            const instance = new Error();
+            Error.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.details = _instance.details || '';
+        }
+        /**
+         * 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.details = _reader.readString();
+                        break;
+                    default:
+                        _reader.skipField();
+                }
+            }
+            Error.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.details) {
+                _writer.writeString(1, _instance.details);
+            }
+        }
+        /**
+         * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+         * @param _value initial values object or instance of Error to deeply clone from
+         */
+        constructor(_value) {
+            _value = _value || {};
+            this.details = _value.details;
+            Error.refineValues(this);
+        }
+        get details() {
+            return this._details;
+        }
+        set details(value) {
+            this._details = value;
+        }
+        /**
+         * Serialize message to binary data
+         * @param instance message instance
+         */
+        serializeBinary() {
+            const writer = new BinaryWriter();
+            Error.serializeBinaryToWriter(this, writer);
+            return writer.getResultBuffer();
+        }
+        /**
+         * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+         */
+        toObject() {
+            return {
+                details: this.details
+            };
+        }
+        /**
+         * 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 {
+                details: this.details
+            };
+        }
+    }
+    Error.id = 'armonik.api.grpc.v1.Output.Error';
+    Output.Error = Error;
+})(Output || (Output = {}));
+/**
+ * Message implementation for armonik.api.grpc.v1.TaskRequest
+ */
+export class TaskRequest {
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new TaskRequest();
+        TaskRequest.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.expectedOutputKeys = _instance.expectedOutputKeys || [];
+        _instance.dataDependencies = _instance.dataDependencies || [];
+        _instance.payload = _instance.payload || new Uint8Array();
+    }
+    /**
+     * 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.expectedOutputKeys =
+                        _instance.expectedOutputKeys || []).push(_reader.readString());
+                    break;
+                case 2:
+                    (_instance.dataDependencies = _instance.dataDependencies || []).push(_reader.readString());
+                    break;
+                case 3:
+                    _instance.payload = _reader.readBytes();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        TaskRequest.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.expectedOutputKeys && _instance.expectedOutputKeys.length) {
+            _writer.writeRepeatedString(1, _instance.expectedOutputKeys);
+        }
+        if (_instance.dataDependencies && _instance.dataDependencies.length) {
+            _writer.writeRepeatedString(2, _instance.dataDependencies);
+        }
+        if (_instance.payload && _instance.payload.length) {
+            _writer.writeBytes(3, _instance.payload);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of TaskRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.expectedOutputKeys = (_value.expectedOutputKeys || []).slice();
+        this.dataDependencies = (_value.dataDependencies || []).slice();
+        this.payload = _value.payload;
+        TaskRequest.refineValues(this);
+    }
+    get expectedOutputKeys() {
+        return this._expectedOutputKeys;
+    }
+    set expectedOutputKeys(value) {
+        this._expectedOutputKeys = value;
+    }
+    get dataDependencies() {
+        return this._dataDependencies;
+    }
+    set dataDependencies(value) {
+        this._dataDependencies = value;
+    }
+    get payload() {
+        return this._payload;
+    }
+    set payload(value) {
+        this._payload = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        TaskRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            expectedOutputKeys: (this.expectedOutputKeys || []).slice(),
+            dataDependencies: (this.dataDependencies || []).slice(),
+            payload: this.payload ? this.payload.subarray(0) : new Uint8Array()
+        };
+    }
+    /**
+     * 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 {
+            expectedOutputKeys: (this.expectedOutputKeys || []).slice(),
+            dataDependencies: (this.dataDependencies || []).slice(),
+            payload: this.payload ? uint8ArrayToBase64(this.payload) : ''
+        };
+    }
+}
+TaskRequest.id = 'armonik.api.grpc.v1.TaskRequest';
+/**
+ * Message implementation for armonik.api.grpc.v1.InitKeyedDataStream
+ */
+export class InitKeyedDataStream {
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new InitKeyedDataStream();
+        InitKeyedDataStream.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()) {
+                case 1:
+                    _instance.key = _reader.readString();
+                    break;
+                case 2:
+                    _instance.lastResult = _reader.readBool();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        InitKeyedDataStream.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.key || _instance.key === '') {
+            _writer.writeString(1, _instance.key);
+        }
+        if (_instance.lastResult || _instance.lastResult === false) {
+            _writer.writeBool(2, _instance.lastResult);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of InitKeyedDataStream to deeply clone from
+     */
+    constructor(_value) {
+        this._type = InitKeyedDataStream.TypeCase.none;
+        _value = _value || {};
+        this.key = _value.key;
+        this.lastResult = _value.lastResult;
+        InitKeyedDataStream.refineValues(this);
+    }
+    get key() {
+        return this._key;
+    }
+    set key(value) {
+        if (value !== undefined && value !== null) {
+            this._lastResult = undefined;
+            this._type = InitKeyedDataStream.TypeCase.key;
+        }
+        this._key = value;
+    }
+    get lastResult() {
+        return this._lastResult;
+    }
+    set lastResult(value) {
+        if (value !== undefined && value !== null) {
+            this._key = undefined;
+            this._type = InitKeyedDataStream.TypeCase.lastResult;
+        }
+        this._lastResult = value;
+    }
+    get type() {
+        return this._type;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        InitKeyedDataStream.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            key: this.key,
+            lastResult: this.lastResult
+        };
+    }
+    /**
+     * 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 {
+            key: this.key === null || this.key === undefined ? null : this.key,
+            lastResult: this.lastResult
+        };
+    }
+}
+InitKeyedDataStream.id = 'armonik.api.grpc.v1.InitKeyedDataStream';
+(function (InitKeyedDataStream) {
+    let TypeCase;
+    (function (TypeCase) {
+        TypeCase[TypeCase["none"] = 0] = "none";
+        TypeCase[TypeCase["key"] = 1] = "key";
+        TypeCase[TypeCase["lastResult"] = 2] = "lastResult";
+    })(TypeCase = InitKeyedDataStream.TypeCase || (InitKeyedDataStream.TypeCase = {}));
+})(InitKeyedDataStream || (InitKeyedDataStream = {}));
+/**
+ * Message implementation for armonik.api.grpc.v1.DataChunk
+ */
+export class DataChunk {
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new DataChunk();
+        DataChunk.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()) {
+                case 1:
+                    _instance.data = _reader.readBytes();
+                    break;
+                case 2:
+                    _instance.dataComplete = _reader.readBool();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        DataChunk.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.data && _instance.data.length) {
+            _writer.writeBytes(1, _instance.data);
+        }
+        if (_instance.dataComplete || _instance.dataComplete === false) {
+            _writer.writeBool(2, _instance.dataComplete);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of DataChunk to deeply clone from
+     */
+    constructor(_value) {
+        this._type = DataChunk.TypeCase.none;
+        _value = _value || {};
+        this.data = _value.data;
+        this.dataComplete = _value.dataComplete;
+        DataChunk.refineValues(this);
+    }
+    get data() {
+        return this._data;
+    }
+    set data(value) {
+        if (value !== undefined && value !== null) {
+            this._dataComplete = undefined;
+            this._type = DataChunk.TypeCase.data;
+        }
+        this._data = value;
+    }
+    get dataComplete() {
+        return this._dataComplete;
+    }
+    set dataComplete(value) {
+        if (value !== undefined && value !== null) {
+            this._data = undefined;
+            this._type = DataChunk.TypeCase.dataComplete;
+        }
+        this._dataComplete = value;
+    }
+    get type() {
+        return this._type;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        DataChunk.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            data: this.data ? this.data.subarray(0) : new Uint8Array(),
+            dataComplete: this.dataComplete
+        };
+    }
+    /**
+     * 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 {
+            data: this.data ? uint8ArrayToBase64(this.data) : '',
+            dataComplete: this.dataComplete
+        };
+    }
+}
+DataChunk.id = 'armonik.api.grpc.v1.DataChunk';
+(function (DataChunk) {
+    let TypeCase;
+    (function (TypeCase) {
+        TypeCase[TypeCase["none"] = 0] = "none";
+        TypeCase[TypeCase["data"] = 1] = "data";
+        TypeCase[TypeCase["dataComplete"] = 2] = "dataComplete";
+    })(TypeCase = DataChunk.TypeCase || (DataChunk.TypeCase = {}));
+})(DataChunk || (DataChunk = {}));
+/**
+ * Message implementation for armonik.api.grpc.v1.TaskRequestHeader
+ */
+export class TaskRequestHeader {
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new TaskRequestHeader();
+        TaskRequestHeader.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.expectedOutputKeys = _instance.expectedOutputKeys || [];
+        _instance.dataDependencies = _instance.dataDependencies || [];
+    }
+    /**
+     * 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.expectedOutputKeys =
+                        _instance.expectedOutputKeys || []).push(_reader.readString());
+                    break;
+                case 2:
+                    (_instance.dataDependencies = _instance.dataDependencies || []).push(_reader.readString());
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        TaskRequestHeader.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.expectedOutputKeys && _instance.expectedOutputKeys.length) {
+            _writer.writeRepeatedString(1, _instance.expectedOutputKeys);
+        }
+        if (_instance.dataDependencies && _instance.dataDependencies.length) {
+            _writer.writeRepeatedString(2, _instance.dataDependencies);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of TaskRequestHeader to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.expectedOutputKeys = (_value.expectedOutputKeys || []).slice();
+        this.dataDependencies = (_value.dataDependencies || []).slice();
+        TaskRequestHeader.refineValues(this);
+    }
+    get expectedOutputKeys() {
+        return this._expectedOutputKeys;
+    }
+    set expectedOutputKeys(value) {
+        this._expectedOutputKeys = value;
+    }
+    get dataDependencies() {
+        return this._dataDependencies;
+    }
+    set dataDependencies(value) {
+        this._dataDependencies = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        TaskRequestHeader.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            expectedOutputKeys: (this.expectedOutputKeys || []).slice(),
+            dataDependencies: (this.dataDependencies || []).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 {
+            expectedOutputKeys: (this.expectedOutputKeys || []).slice(),
+            dataDependencies: (this.dataDependencies || []).slice()
+        };
+    }
+}
+TaskRequestHeader.id = 'armonik.api.grpc.v1.TaskRequestHeader';
+/**
+ * Message implementation for armonik.api.grpc.v1.InitTaskRequest
+ */
+export class InitTaskRequest {
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new InitTaskRequest();
+        InitTaskRequest.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()) {
+                case 1:
+                    _instance.header = new TaskRequestHeader();
+                    _reader.readMessage(_instance.header, TaskRequestHeader.deserializeBinaryFromReader);
+                    break;
+                case 2:
+                    _instance.lastTask = _reader.readBool();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        InitTaskRequest.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.header) {
+            _writer.writeMessage(1, _instance.header, TaskRequestHeader.serializeBinaryToWriter);
+        }
+        if (_instance.lastTask || _instance.lastTask === false) {
+            _writer.writeBool(2, _instance.lastTask);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of InitTaskRequest to deeply clone from
+     */
+    constructor(_value) {
+        this._type = InitTaskRequest.TypeCase.none;
+        _value = _value || {};
+        this.header = _value.header
+            ? new TaskRequestHeader(_value.header)
+            : undefined;
+        this.lastTask = _value.lastTask;
+        InitTaskRequest.refineValues(this);
+    }
+    get header() {
+        return this._header;
+    }
+    set header(value) {
+        if (value !== undefined && value !== null) {
+            this._lastTask = undefined;
+            this._type = InitTaskRequest.TypeCase.header;
+        }
+        this._header = value;
+    }
+    get lastTask() {
+        return this._lastTask;
+    }
+    set lastTask(value) {
+        if (value !== undefined && value !== null) {
+            this._header = undefined;
+            this._type = InitTaskRequest.TypeCase.lastTask;
+        }
+        this._lastTask = value;
+    }
+    get type() {
+        return this._type;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        InitTaskRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            header: this.header ? this.header.toObject() : undefined,
+            lastTask: this.lastTask
+        };
+    }
+    /**
+     * 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 {
+            header: this.header ? this.header.toProtobufJSON(options) : null,
+            lastTask: this.lastTask
+        };
+    }
+}
+InitTaskRequest.id = 'armonik.api.grpc.v1.InitTaskRequest';
+(function (InitTaskRequest) {
+    let TypeCase;
+    (function (TypeCase) {
+        TypeCase[TypeCase["none"] = 0] = "none";
+        TypeCase[TypeCase["header"] = 1] = "header";
+        TypeCase[TypeCase["lastTask"] = 2] = "lastTask";
+    })(TypeCase = InitTaskRequest.TypeCase || (InitTaskRequest.TypeCase = {}));
+})(InitTaskRequest || (InitTaskRequest = {}));
+/**
+ * Message implementation for armonik.api.grpc.v1.TaskId
+ */
+export class TaskId {
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new TaskId();
+        TaskId.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.session = _instance.session || '';
+        _instance.task = _instance.task || '';
+    }
+    /**
+     * 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.session = _reader.readString();
+                    break;
+                case 2:
+                    _instance.task = _reader.readString();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        TaskId.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.session) {
+            _writer.writeString(1, _instance.session);
+        }
+        if (_instance.task) {
+            _writer.writeString(2, _instance.task);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of TaskId to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.session = _value.session;
+        this.task = _value.task;
+        TaskId.refineValues(this);
+    }
+    get session() {
+        return this._session;
+    }
+    set session(value) {
+        this._session = value;
+    }
+    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();
+        TaskId.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            session: this.session,
+            task: this.task
+        };
+    }
+    /**
+     * 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 {
+            session: this.session,
+            task: this.task
+        };
+    }
+}
+TaskId.id = 'armonik.api.grpc.v1.TaskId';
+/**
+ * Message implementation for armonik.api.grpc.v1.TaskIdList
+ */
+export class TaskIdList {
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new TaskIdList();
+        TaskIdList.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();
+            }
+        }
+        TaskIdList.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 TaskIdList to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.taskIds = (_value.taskIds || []).slice();
+        TaskIdList.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();
+        TaskIdList.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()
+        };
+    }
+}
+TaskIdList.id = 'armonik.api.grpc.v1.TaskIdList';
+/**
+ * Message implementation for armonik.api.grpc.v1.StatusCount
+ */
+export class StatusCount {
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new StatusCount();
+        StatusCount.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 || 0;
+        _instance.count = _instance.count || 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.status = _reader.readEnum();
+                    break;
+                case 2:
+                    _instance.count = _reader.readInt32();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        StatusCount.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) {
+            _writer.writeEnum(1, _instance.status);
+        }
+        if (_instance.count) {
+            _writer.writeInt32(2, _instance.count);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of StatusCount to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.status = _value.status;
+        this.count = _value.count;
+        StatusCount.refineValues(this);
+    }
+    get status() {
+        return this._status;
+    }
+    set status(value) {
+        this._status = value;
+    }
+    get count() {
+        return this._count;
+    }
+    set count(value) {
+        this._count = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        StatusCount.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            status: this.status,
+            count: this.count
+        };
+    }
+    /**
+     * 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: armonikApiGrpcV1Task_status001.TaskStatus[this.status === null || this.status === undefined ? 0 : this.status],
+            count: this.count
+        };
+    }
+}
+StatusCount.id = 'armonik.api.grpc.v1.StatusCount';
+/**
+ * Message implementation for armonik.api.grpc.v1.Count
+ */
+export class Count {
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new Count();
+        Count.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.values = _instance.values || [];
+    }
+    /**
+     * 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 StatusCount();
+                    _reader.readMessage(messageInitializer1, StatusCount.deserializeBinaryFromReader);
+                    (_instance.values = _instance.values || []).push(messageInitializer1);
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        Count.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.values && _instance.values.length) {
+            _writer.writeRepeatedMessage(1, _instance.values, StatusCount.serializeBinaryToWriter);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of Count to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.values = (_value.values || []).map(m => new StatusCount(m));
+        Count.refineValues(this);
+    }
+    get values() {
+        return this._values;
+    }
+    set values(value) {
+        this._values = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        Count.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            values: (this.values || []).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 {
+            values: (this.values || []).map(m => m.toProtobufJSON(options))
+        };
+    }
+}
+Count.id = 'armonik.api.grpc.v1.Count';
+/**
+ * Message implementation for armonik.api.grpc.v1.ResultRequest
+ */
+export class ResultRequest {
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new ResultRequest();
+        ResultRequest.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.session = _instance.session || '';
+        _instance.resultId = _instance.resultId || '';
+    }
+    /**
+     * 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.session = _reader.readString();
+                    break;
+                case 2:
+                    _instance.resultId = _reader.readString();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        ResultRequest.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.session) {
+            _writer.writeString(1, _instance.session);
+        }
+        if (_instance.resultId) {
+            _writer.writeString(2, _instance.resultId);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of ResultRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.session = _value.session;
+        this.resultId = _value.resultId;
+        ResultRequest.refineValues(this);
+    }
+    get session() {
+        return this._session;
+    }
+    set session(value) {
+        this._session = value;
+    }
+    get resultId() {
+        return this._resultId;
+    }
+    set resultId(value) {
+        this._resultId = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        ResultRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            session: this.session,
+            resultId: this.resultId
+        };
+    }
+    /**
+     * 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 {
+            session: this.session,
+            resultId: this.resultId
+        };
+    }
+}
+ResultRequest.id = 'armonik.api.grpc.v1.ResultRequest';
+/**
+ * Message implementation for armonik.api.grpc.v1.TaskOutputRequest
+ */
+export class TaskOutputRequest {
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new TaskOutputRequest();
+        TaskOutputRequest.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.session = _instance.session || '';
+        _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.session = _reader.readString();
+                    break;
+                case 2:
+                    _instance.taskId = _reader.readString();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        TaskOutputRequest.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.session) {
+            _writer.writeString(1, _instance.session);
+        }
+        if (_instance.taskId) {
+            _writer.writeString(2, _instance.taskId);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of TaskOutputRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.session = _value.session;
+        this.taskId = _value.taskId;
+        TaskOutputRequest.refineValues(this);
+    }
+    get session() {
+        return this._session;
+    }
+    set session(value) {
+        this._session = value;
+    }
+    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();
+        TaskOutputRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            session: this.session,
+            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 {
+            session: this.session,
+            taskId: this.taskId
+        };
+    }
+}
+TaskOutputRequest.id = 'armonik.api.grpc.v1.TaskOutputRequest';
+/**
+ * Message implementation for armonik.api.grpc.v1.Error
+ */
+export class Error {
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new Error();
+        Error.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.taskStatus = _instance.taskStatus || 0;
+        _instance.detail = _instance.detail || '';
+    }
+    /**
+     * 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.taskStatus = _reader.readEnum();
+                    break;
+                case 2:
+                    _instance.detail = _reader.readString();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        Error.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.taskStatus) {
+            _writer.writeEnum(1, _instance.taskStatus);
+        }
+        if (_instance.detail) {
+            _writer.writeString(2, _instance.detail);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of Error to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.taskStatus = _value.taskStatus;
+        this.detail = _value.detail;
+        Error.refineValues(this);
+    }
+    get taskStatus() {
+        return this._taskStatus;
+    }
+    set taskStatus(value) {
+        this._taskStatus = value;
+    }
+    get detail() {
+        return this._detail;
+    }
+    set detail(value) {
+        this._detail = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        Error.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            taskStatus: this.taskStatus,
+            detail: this.detail
+        };
+    }
+    /**
+     * 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 {
+            taskStatus: armonikApiGrpcV1Task_status001.TaskStatus[this.taskStatus === null || this.taskStatus === undefined
+                ? 0
+                : this.taskStatus],
+            detail: this.detail
+        };
+    }
+}
+Error.id = 'armonik.api.grpc.v1.Error';
+/**
+ * Message implementation for armonik.api.grpc.v1.TaskError
+ */
+export class TaskError {
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new TaskError();
+        TaskError.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.errors = _instance.errors || [];
+    }
+    /**
+     * 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:
+                    const messageInitializer2 = new Error();
+                    _reader.readMessage(messageInitializer2, Error.deserializeBinaryFromReader);
+                    (_instance.errors = _instance.errors || []).push(messageInitializer2);
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        TaskError.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.errors && _instance.errors.length) {
+            _writer.writeRepeatedMessage(2, _instance.errors, Error.serializeBinaryToWriter);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of TaskError to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.taskId = _value.taskId;
+        this.errors = (_value.errors || []).map(m => new Error(m));
+        TaskError.refineValues(this);
+    }
+    get taskId() {
+        return this._taskId;
+    }
+    set taskId(value) {
+        this._taskId = value;
+    }
+    get errors() {
+        return this._errors;
+    }
+    set errors(value) {
+        this._errors = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        TaskError.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            taskId: this.taskId,
+            errors: (this.errors || []).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 {
+            taskId: this.taskId,
+            errors: (this.errors || []).map(m => m.toProtobufJSON(options))
+        };
+    }
+}
+TaskError.id = 'armonik.api.grpc.v1.TaskError';
+/**
+ * Message implementation for armonik.api.grpc.v1.TaskList
+ */
+export class TaskList {
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new TaskList();
+        TaskList.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:
+                    const messageInitializer1 = new TaskId();
+                    _reader.readMessage(messageInitializer1, TaskId.deserializeBinaryFromReader);
+                    (_instance.taskIds = _instance.taskIds || []).push(messageInitializer1);
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        TaskList.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.writeRepeatedMessage(1, _instance.taskIds, TaskId.serializeBinaryToWriter);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of TaskList to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.taskIds = (_value.taskIds || []).map(m => new TaskId(m));
+        TaskList.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();
+        TaskList.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            taskIds: (this.taskIds || []).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 {
+            taskIds: (this.taskIds || []).map(m => m.toProtobufJSON(options))
+        };
+    }
+}
+TaskList.id = 'armonik.api.grpc.v1.TaskList';
+/**
+ * Message implementation for armonik.api.grpc.v1.TaskIdWithStatus
+ */
+export class TaskIdWithStatus {
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new TaskIdWithStatus();
+        TaskIdWithStatus.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 || undefined;
+        _instance.status = _instance.status || 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.taskId = new TaskId();
+                    _reader.readMessage(_instance.taskId, TaskId.deserializeBinaryFromReader);
+                    break;
+                case 2:
+                    _instance.status = _reader.readEnum();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        TaskIdWithStatus.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.writeMessage(1, _instance.taskId, TaskId.serializeBinaryToWriter);
+        }
+        if (_instance.status) {
+            _writer.writeEnum(2, _instance.status);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of TaskIdWithStatus to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.taskId = _value.taskId ? new TaskId(_value.taskId) : undefined;
+        this.status = _value.status;
+        TaskIdWithStatus.refineValues(this);
+    }
+    get taskId() {
+        return this._taskId;
+    }
+    set taskId(value) {
+        this._taskId = value;
+    }
+    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();
+        TaskIdWithStatus.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            taskId: this.taskId ? this.taskId.toObject() : undefined,
+            status: this.status
+        };
+    }
+    /**
+     * 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 ? this.taskId.toProtobufJSON(options) : null,
+            status: armonikApiGrpcV1Task_status001.TaskStatus[this.status === null || this.status === undefined ? 0 : this.status]
+        };
+    }
+}
+TaskIdWithStatus.id = 'armonik.api.grpc.v1.TaskIdWithStatus';
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"objects.pb.js","sourceRoot":"","sources":["../../../../../../projects/aneoconsultingfr/armonik.api.angular/src/lib/generated/objects.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  uint8ArrayToBase64\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';\n/**\n * Message implementation for armonik.api.grpc.v1.Empty\n */\nexport class Empty implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.Empty';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new Empty();\n    Empty.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: Empty) {}\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: Empty, _reader: BinaryReader) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        default:\n          _reader.skipField();\n      }\n    }\n\n    Empty.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: Empty, _writer: BinaryWriter) {}\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of Empty to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<Empty.AsObject>) {\n    _value = _value || {};\n    Empty.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    Empty.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(): Empty.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  ): Empty.AsProtobufJSON {\n    return {};\n  }\n}\nexport module Empty {\n  /**\n   * Standard JavaScript object representation for Empty\n   */\n  export interface AsObject {}\n\n  /**\n   * Protobuf JSON representation for Empty\n   */\n  export interface AsProtobufJSON {}\n}\n\n/**\n * Message implementation for armonik.api.grpc.v1.TaskOptions\n */\nexport class TaskOptions implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.TaskOptions';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new TaskOptions();\n    TaskOptions.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: TaskOptions) {\n    _instance.options = _instance.options || {};\n    _instance.maxDuration = _instance.maxDuration || undefined;\n    _instance.maxRetries = _instance.maxRetries || 0;\n    _instance.priority = _instance.priority || 0;\n    _instance.partitionId = _instance.partitionId || '';\n    _instance.applicationName = _instance.applicationName || '';\n    _instance.applicationVersion = _instance.applicationVersion || '';\n    _instance.applicationNamespace = _instance.applicationNamespace || '';\n    _instance.applicationService = _instance.applicationService || '';\n    _instance.engineType = _instance.engineType || '';\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: TaskOptions,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          const msg_1 = {} as any;\n          _reader.readMessage(\n            msg_1,\n            TaskOptions.OptionsEntry.deserializeBinaryFromReader\n          );\n          _instance.options = _instance.options || {};\n          _instance.options[msg_1.key] = msg_1.value;\n          break;\n        case 2:\n          _instance.maxDuration = new googleProtobuf000.Duration();\n          _reader.readMessage(\n            _instance.maxDuration,\n            googleProtobuf000.Duration.deserializeBinaryFromReader\n          );\n          break;\n        case 3:\n          _instance.maxRetries = _reader.readInt32();\n          break;\n        case 4:\n          _instance.priority = _reader.readInt32();\n          break;\n        case 5:\n          _instance.partitionId = _reader.readString();\n          break;\n        case 6:\n          _instance.applicationName = _reader.readString();\n          break;\n        case 7:\n          _instance.applicationVersion = _reader.readString();\n          break;\n        case 8:\n          _instance.applicationNamespace = _reader.readString();\n          break;\n        case 9:\n          _instance.applicationService = _reader.readString();\n          break;\n        case 10:\n          _instance.engineType = _reader.readString();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    TaskOptions.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: TaskOptions,\n    _writer: BinaryWriter\n  ) {\n    if (!!_instance.options) {\n      const keys_1 = Object.keys(_instance.options as any);\n\n      if (keys_1.length) {\n        const repeated_1 = keys_1\n          .map(key => ({ key: key, value: (_instance.options as any)[key] }))\n          .reduce((r, v) => [...r, v], [] as any[]);\n\n        _writer.writeRepeatedMessage(\n          1,\n          repeated_1,\n          TaskOptions.OptionsEntry.serializeBinaryToWriter\n        );\n      }\n    }\n    if (_instance.maxDuration) {\n      _writer.writeMessage(\n        2,\n        _instance.maxDuration as any,\n        googleProtobuf000.Duration.serializeBinaryToWriter\n      );\n    }\n    if (_instance.maxRetries) {\n      _writer.writeInt32(3, _instance.maxRetries);\n    }\n    if (_instance.priority) {\n      _writer.writeInt32(4, _instance.priority);\n    }\n    if (_instance.partitionId) {\n      _writer.writeString(5, _instance.partitionId);\n    }\n    if (_instance.applicationName) {\n      _writer.writeString(6, _instance.applicationName);\n    }\n    if (_instance.applicationVersion) {\n      _writer.writeString(7, _instance.applicationVersion);\n    }\n    if (_instance.applicationNamespace) {\n      _writer.writeString(8, _instance.applicationNamespace);\n    }\n    if (_instance.applicationService) {\n      _writer.writeString(9, _instance.applicationService);\n    }\n    if (_instance.engineType) {\n      _writer.writeString(10, _instance.engineType);\n    }\n  }\n\n  private _options: { [prop: string]: string };\n  private _maxDuration?: googleProtobuf000.Duration;\n  private _maxRetries: number;\n  private _priority: number;\n  private _partitionId: string;\n  private _applicationName: string;\n  private _applicationVersion: string;\n  private _applicationNamespace: string;\n  private _applicationService: string;\n  private _engineType: 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 TaskOptions to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<TaskOptions.AsObject>) {\n    _value = _value || {};\n    (this.options = _value!.options\n      ? Object.keys(_value!.options).reduce(\n          (r, k) => ({ ...r, [k]: _value!.options![k] }),\n          {}\n        )\n      : {}),\n      (this.maxDuration = _value.maxDuration\n        ? new googleProtobuf000.Duration(_value.maxDuration)\n        : undefined);\n    this.maxRetries = _value.maxRetries;\n    this.priority = _value.priority;\n    this.partitionId = _value.partitionId;\n    this.applicationName = _value.applicationName;\n    this.applicationVersion = _value.applicationVersion;\n    this.applicationNamespace = _value.applicationNamespace;\n    this.applicationService = _value.applicationService;\n    this.engineType = _value.engineType;\n    TaskOptions.refineValues(this);\n  }\n  get options(): { [prop: string]: string } {\n    return this._options;\n  }\n  set options(value: { [prop: string]: string }) {\n    this._options = value;\n  }\n  get maxDuration(): googleProtobuf000.Duration | undefined {\n    return this._maxDuration;\n  }\n  set maxDuration(value: googleProtobuf000.Duration | undefined) {\n    this._maxDuration = value;\n  }\n  get maxRetries(): number {\n    return this._maxRetries;\n  }\n  set maxRetries(value: number) {\n    this._maxRetries = value;\n  }\n  get priority(): number {\n    return this._priority;\n  }\n  set priority(value: number) {\n    this._priority = value;\n  }\n  get partitionId(): string {\n    return this._partitionId;\n  }\n  set partitionId(value: string) {\n    this._partitionId = value;\n  }\n  get applicationName(): string {\n    return this._applicationName;\n  }\n  set applicationName(value: string) {\n    this._applicationName = value;\n  }\n  get applicationVersion(): string {\n    return this._applicationVersion;\n  }\n  set applicationVersion(value: string) {\n    this._applicationVersion = value;\n  }\n  get applicationNamespace(): string {\n    return this._applicationNamespace;\n  }\n  set applicationNamespace(value: string) {\n    this._applicationNamespace = value;\n  }\n  get applicationService(): string {\n    return this._applicationService;\n  }\n  set applicationService(value: string) {\n    this._applicationService = value;\n  }\n  get engineType(): string {\n    return this._engineType;\n  }\n  set engineType(value: string) {\n    this._engineType = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    TaskOptions.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(): TaskOptions.AsObject {\n    return {\n      options: this.options\n        ? Object.keys(this.options).reduce(\n            (r, k) => ({ ...r, [k]: this.options![k] }),\n            {}\n          )\n        : {},\n      maxDuration: this.maxDuration ? this.maxDuration.toObject() : undefined,\n      maxRetries: this.maxRetries,\n      priority: this.priority,\n      partitionId: this.partitionId,\n      applicationName: this.applicationName,\n      applicationVersion: this.applicationVersion,\n      applicationNamespace: this.applicationNamespace,\n      applicationService: this.applicationService,\n      engineType: this.engineType\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  ): TaskOptions.AsProtobufJSON {\n    return {\n      options: this.options\n        ? Object.keys(this.options).reduce(\n            (r, k) => ({ ...r, [k]: this.options![k] }),\n            {}\n          )\n        : {},\n      maxDuration: this.maxDuration\n        ? this.maxDuration.toProtobufJSON(options)\n        : null,\n      maxRetries: this.maxRetries,\n      priority: this.priority,\n      partitionId: this.partitionId,\n      applicationName: this.applicationName,\n      applicationVersion: this.applicationVersion,\n      applicationNamespace: this.applicationNamespace,\n      applicationService: this.applicationService,\n      engineType: this.engineType\n    };\n  }\n}\nexport module TaskOptions {\n  /**\n   * Standard JavaScript object representation for TaskOptions\n   */\n  export interface AsObject {\n    options: { [prop: string]: string };\n    maxDuration?: googleProtobuf000.Duration.AsObject;\n    maxRetries: number;\n    priority: number;\n    partitionId: string;\n    applicationName: string;\n    applicationVersion: string;\n    applicationNamespace: string;\n    applicationService: string;\n    engineType: string;\n  }\n\n  /**\n   * Protobuf JSON representation for TaskOptions\n   */\n  export interface AsProtobufJSON {\n    options: { [prop: string]: string };\n    maxDuration: googleProtobuf000.Duration.AsProtobufJSON | null;\n    maxRetries: number;\n    priority: number;\n    partitionId: string;\n    applicationName: string;\n    applicationVersion: string;\n    applicationNamespace: string;\n    applicationService: string;\n    engineType: string;\n  }\n\n  /**\n   * Message implementation for armonik.api.grpc.v1.TaskOptions.OptionsEntry\n   */\n  export class OptionsEntry implements GrpcMessage {\n    static id = 'armonik.api.grpc.v1.TaskOptions.OptionsEntry';\n\n    /**\n     * Deserialize binary data to message\n     * @param instance message instance\n     */\n    static deserializeBinary(bytes: ByteSource) {\n      const instance = new OptionsEntry();\n      OptionsEntry.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: OptionsEntry) {\n      _instance.key = _instance.key || '';\n      _instance.value = _instance.value || '';\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: OptionsEntry,\n      _reader: BinaryReader\n    ) {\n      while (_reader.nextField()) {\n        if (_reader.isEndGroup()) break;\n\n        switch (_reader.getFieldNumber()) {\n          case 1:\n            _instance.key = _reader.readString();\n            break;\n          case 2:\n            _instance.value = _reader.readString();\n            break;\n          default:\n            _reader.skipField();\n        }\n      }\n\n      OptionsEntry.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: OptionsEntry,\n      _writer: BinaryWriter\n    ) {\n      if (_instance.key) {\n        _writer.writeString(1, _instance.key);\n      }\n      if (_instance.value) {\n        _writer.writeString(2, _instance.value);\n      }\n    }\n\n    private _key: string;\n    private _value: 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 OptionsEntry to deeply clone from\n     */\n    constructor(_value?: RecursivePartial<OptionsEntry.AsObject>) {\n      _value = _value || {};\n      this.key = _value.key;\n      this.value = _value.value;\n      OptionsEntry.refineValues(this);\n    }\n    get key(): string {\n      return this._key;\n    }\n    set key(value: string) {\n      this._key = value;\n    }\n    get value(): string {\n      return this._value;\n    }\n    set value(value: string) {\n      this._value = value;\n    }\n\n    /**\n     * Serialize message to binary data\n     * @param instance message instance\n     */\n    serializeBinary() {\n      const writer = new BinaryWriter();\n      OptionsEntry.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(): OptionsEntry.AsObject {\n      return {\n        key: this.key,\n        value: this.value\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    ): OptionsEntry.AsProtobufJSON {\n      return {\n        key: this.key,\n        value: this.value\n      };\n    }\n  }\n  export module OptionsEntry {\n    /**\n     * Standard JavaScript object representation for OptionsEntry\n     */\n    export interface AsObject {\n      key: string;\n      value: string;\n    }\n\n    /**\n     * Protobuf JSON representation for OptionsEntry\n     */\n    export interface AsProtobufJSON {\n      key: string;\n      value: string;\n    }\n  }\n}\n\n/**\n * Message implementation for armonik.api.grpc.v1.Session\n */\nexport class Session implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.Session';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new Session();\n    Session.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: Session) {\n    _instance.id = _instance.id || '';\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: Session,\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        default:\n          _reader.skipField();\n      }\n    }\n\n    Session.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: Session, _writer: BinaryWriter) {\n    if (_instance.id) {\n      _writer.writeString(1, _instance.id);\n    }\n  }\n\n  private _id: 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 Session to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<Session.AsObject>) {\n    _value = _value || {};\n    this.id = _value.id;\n    Session.refineValues(this);\n  }\n  get id(): string {\n    return this._id;\n  }\n  set id(value: string) {\n    this._id = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    Session.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(): Session.AsObject {\n    return {\n      id: this.id\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  ): Session.AsProtobufJSON {\n    return {\n      id: this.id\n    };\n  }\n}\nexport module Session {\n  /**\n   * Standard JavaScript object representation for Session\n   */\n  export interface AsObject {\n    id: string;\n  }\n\n  /**\n   * Protobuf JSON representation for Session\n   */\n  export interface AsProtobufJSON {\n    id: string;\n  }\n}\n\n/**\n * Message implementation for armonik.api.grpc.v1.Configuration\n */\nexport class Configuration implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.Configuration';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new Configuration();\n    Configuration.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: Configuration) {\n    _instance.dataChunkMaxSize = _instance.dataChunkMaxSize || 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: Configuration,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.dataChunkMaxSize = _reader.readInt32();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    Configuration.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: Configuration,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.dataChunkMaxSize) {\n      _writer.writeInt32(1, _instance.dataChunkMaxSize);\n    }\n  }\n\n  private _dataChunkMaxSize: 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 Configuration to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<Configuration.AsObject>) {\n    _value = _value || {};\n    this.dataChunkMaxSize = _value.dataChunkMaxSize;\n    Configuration.refineValues(this);\n  }\n  get dataChunkMaxSize(): number {\n    return this._dataChunkMaxSize;\n  }\n  set dataChunkMaxSize(value: number) {\n    this._dataChunkMaxSize = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    Configuration.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(): Configuration.AsObject {\n    return {\n      dataChunkMaxSize: this.dataChunkMaxSize\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  ): Configuration.AsProtobufJSON {\n    return {\n      dataChunkMaxSize: this.dataChunkMaxSize\n    };\n  }\n}\nexport module Configuration {\n  /**\n   * Standard JavaScript object representation for Configuration\n   */\n  export interface AsObject {\n    dataChunkMaxSize: number;\n  }\n\n  /**\n   * Protobuf JSON representation for Configuration\n   */\n  export interface AsProtobufJSON {\n    dataChunkMaxSize: number;\n  }\n}\n\n/**\n * Message implementation for armonik.api.grpc.v1.Output\n */\nexport class Output implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.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\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: Output, _reader: BinaryReader) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 2:\n          _instance.ok = new Empty();\n          _reader.readMessage(_instance.ok, Empty.deserializeBinaryFromReader);\n          break;\n        case 3:\n          _instance.error = new Output.Error();\n          _reader.readMessage(\n            _instance.error,\n            Output.Error.deserializeBinaryFromReader\n          );\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.ok) {\n      _writer.writeMessage(\n        2,\n        _instance.ok as any,\n        Empty.serializeBinaryToWriter\n      );\n    }\n    if (_instance.error) {\n      _writer.writeMessage(\n        3,\n        _instance.error as any,\n        Output.Error.serializeBinaryToWriter\n      );\n    }\n  }\n\n  private _ok?: Empty;\n  private _error?: Output.Error;\n\n  private _type: Output.TypeCase = Output.TypeCase.none;\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.ok = _value.ok ? new Empty(_value.ok) : undefined;\n    this.error = _value.error ? new Output.Error(_value.error) : undefined;\n    Output.refineValues(this);\n  }\n  get ok(): Empty | undefined {\n    return this._ok;\n  }\n  set ok(value: Empty | undefined) {\n    if (value !== undefined && value !== null) {\n      this._error = undefined;\n      this._type = Output.TypeCase.ok;\n    }\n    this._ok = value;\n  }\n  get error(): Output.Error | undefined {\n    return this._error;\n  }\n  set error(value: Output.Error | undefined) {\n    if (value !== undefined && value !== null) {\n      this._ok = undefined;\n      this._type = Output.TypeCase.error;\n    }\n    this._error = value;\n  }\n  get type() {\n    return this._type;\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      ok: this.ok ? this.ok.toObject() : undefined,\n      error: this.error ? this.error.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  ): Output.AsProtobufJSON {\n    return {\n      ok: this.ok ? this.ok.toProtobufJSON(options) : null,\n      error: this.error ? this.error.toProtobufJSON(options) : null\n    };\n  }\n}\nexport module Output {\n  /**\n   * Standard JavaScript object representation for Output\n   */\n  export interface AsObject {\n    ok?: Empty.AsObject;\n    error?: Output.Error.AsObject;\n  }\n\n  /**\n   * Protobuf JSON representation for Output\n   */\n  export interface AsProtobufJSON {\n    ok: Empty.AsProtobufJSON | null;\n    error: Output.Error.AsProtobufJSON | null;\n  }\n  export enum TypeCase {\n    none = 0,\n    ok = 1,\n    error = 2\n  }\n  /**\n   * Message implementation for armonik.api.grpc.v1.Output.Error\n   */\n  export class Error implements GrpcMessage {\n    static id = 'armonik.api.grpc.v1.Output.Error';\n\n    /**\n     * Deserialize binary data to message\n     * @param instance message instance\n     */\n    static deserializeBinary(bytes: ByteSource) {\n      const instance = new Error();\n      Error.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: Error) {\n      _instance.details = _instance.details || '';\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: Error,\n      _reader: BinaryReader\n    ) {\n      while (_reader.nextField()) {\n        if (_reader.isEndGroup()) break;\n\n        switch (_reader.getFieldNumber()) {\n          case 1:\n            _instance.details = _reader.readString();\n            break;\n          default:\n            _reader.skipField();\n        }\n      }\n\n      Error.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: Error, _writer: BinaryWriter) {\n      if (_instance.details) {\n        _writer.writeString(1, _instance.details);\n      }\n    }\n\n    private _details: 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 Error to deeply clone from\n     */\n    constructor(_value?: RecursivePartial<Error.AsObject>) {\n      _value = _value || {};\n      this.details = _value.details;\n      Error.refineValues(this);\n    }\n    get details(): string {\n      return this._details;\n    }\n    set details(value: string) {\n      this._details = value;\n    }\n\n    /**\n     * Serialize message to binary data\n     * @param instance message instance\n     */\n    serializeBinary() {\n      const writer = new BinaryWriter();\n      Error.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(): Error.AsObject {\n      return {\n        details: this.details\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    ): Error.AsProtobufJSON {\n      return {\n        details: this.details\n      };\n    }\n  }\n  export module Error {\n    /**\n     * Standard JavaScript object representation for Error\n     */\n    export interface AsObject {\n      details: string;\n    }\n\n    /**\n     * Protobuf JSON representation for Error\n     */\n    export interface AsProtobufJSON {\n      details: string;\n    }\n  }\n}\n\n/**\n * Message implementation for armonik.api.grpc.v1.TaskRequest\n */\nexport class TaskRequest implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.TaskRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new TaskRequest();\n    TaskRequest.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: TaskRequest) {\n    _instance.expectedOutputKeys = _instance.expectedOutputKeys || [];\n    _instance.dataDependencies = _instance.dataDependencies || [];\n    _instance.payload = _instance.payload || new Uint8Array();\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: TaskRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          (_instance.expectedOutputKeys =\n            _instance.expectedOutputKeys || []).push(_reader.readString());\n          break;\n        case 2:\n          (_instance.dataDependencies = _instance.dataDependencies || []).push(\n            _reader.readString()\n          );\n          break;\n        case 3:\n          _instance.payload = _reader.readBytes();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    TaskRequest.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: TaskRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.expectedOutputKeys && _instance.expectedOutputKeys.length) {\n      _writer.writeRepeatedString(1, _instance.expectedOutputKeys);\n    }\n    if (_instance.dataDependencies && _instance.dataDependencies.length) {\n      _writer.writeRepeatedString(2, _instance.dataDependencies);\n    }\n    if (_instance.payload && _instance.payload.length) {\n      _writer.writeBytes(3, _instance.payload);\n    }\n  }\n\n  private _expectedOutputKeys: string[];\n  private _dataDependencies: string[];\n  private _payload: Uint8Array;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of TaskRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<TaskRequest.AsObject>) {\n    _value = _value || {};\n    this.expectedOutputKeys = (_value.expectedOutputKeys || []).slice();\n    this.dataDependencies = (_value.dataDependencies || []).slice();\n    this.payload = _value.payload;\n    TaskRequest.refineValues(this);\n  }\n  get expectedOutputKeys(): string[] {\n    return this._expectedOutputKeys;\n  }\n  set expectedOutputKeys(value: string[]) {\n    this._expectedOutputKeys = value;\n  }\n  get dataDependencies(): string[] {\n    return this._dataDependencies;\n  }\n  set dataDependencies(value: string[]) {\n    this._dataDependencies = value;\n  }\n  get payload(): Uint8Array {\n    return this._payload;\n  }\n  set payload(value: Uint8Array) {\n    this._payload = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    TaskRequest.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(): TaskRequest.AsObject {\n    return {\n      expectedOutputKeys: (this.expectedOutputKeys || []).slice(),\n      dataDependencies: (this.dataDependencies || []).slice(),\n      payload: this.payload ? this.payload.subarray(0) : new Uint8Array()\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  ): TaskRequest.AsProtobufJSON {\n    return {\n      expectedOutputKeys: (this.expectedOutputKeys || []).slice(),\n      dataDependencies: (this.dataDependencies || []).slice(),\n      payload: this.payload ? uint8ArrayToBase64(this.payload) : ''\n    };\n  }\n}\nexport module TaskRequest {\n  /**\n   * Standard JavaScript object representation for TaskRequest\n   */\n  export interface AsObject {\n    expectedOutputKeys: string[];\n    dataDependencies: string[];\n    payload: Uint8Array;\n  }\n\n  /**\n   * Protobuf JSON representation for TaskRequest\n   */\n  export interface AsProtobufJSON {\n    expectedOutputKeys: string[];\n    dataDependencies: string[];\n    payload: string;\n  }\n}\n\n/**\n * Message implementation for armonik.api.grpc.v1.InitKeyedDataStream\n */\nexport class InitKeyedDataStream implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.InitKeyedDataStream';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new InitKeyedDataStream();\n    InitKeyedDataStream.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: InitKeyedDataStream) {}\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: InitKeyedDataStream,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.key = _reader.readString();\n          break;\n        case 2:\n          _instance.lastResult = _reader.readBool();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    InitKeyedDataStream.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: InitKeyedDataStream,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.key || _instance.key === '') {\n      _writer.writeString(1, _instance.key);\n    }\n    if (_instance.lastResult || _instance.lastResult === false) {\n      _writer.writeBool(2, _instance.lastResult);\n    }\n  }\n\n  private _key: string;\n  private _lastResult: boolean;\n\n  private _type: InitKeyedDataStream.TypeCase =\n    InitKeyedDataStream.TypeCase.none;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of InitKeyedDataStream to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<InitKeyedDataStream.AsObject>) {\n    _value = _value || {};\n    this.key = _value.key;\n    this.lastResult = _value.lastResult;\n    InitKeyedDataStream.refineValues(this);\n  }\n  get key(): string {\n    return this._key;\n  }\n  set key(value: string) {\n    if (value !== undefined && value !== null) {\n      this._lastResult = undefined;\n      this._type = InitKeyedDataStream.TypeCase.key;\n    }\n    this._key = value;\n  }\n  get lastResult(): boolean {\n    return this._lastResult;\n  }\n  set lastResult(value: boolean) {\n    if (value !== undefined && value !== null) {\n      this._key = undefined;\n      this._type = InitKeyedDataStream.TypeCase.lastResult;\n    }\n    this._lastResult = value;\n  }\n  get type() {\n    return this._type;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    InitKeyedDataStream.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(): InitKeyedDataStream.AsObject {\n    return {\n      key: this.key,\n      lastResult: this.lastResult\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  ): InitKeyedDataStream.AsProtobufJSON {\n    return {\n      key: this.key === null || this.key === undefined ? null : this.key,\n      lastResult: this.lastResult\n    };\n  }\n}\nexport module InitKeyedDataStream {\n  /**\n   * Standard JavaScript object representation for InitKeyedDataStream\n   */\n  export interface AsObject {\n    key: string;\n    lastResult: boolean;\n  }\n\n  /**\n   * Protobuf JSON representation for InitKeyedDataStream\n   */\n  export interface AsProtobufJSON {\n    key: string | null;\n    lastResult: boolean;\n  }\n  export enum TypeCase {\n    none = 0,\n    key = 1,\n    lastResult = 2\n  }\n}\n\n/**\n * Message implementation for armonik.api.grpc.v1.DataChunk\n */\nexport class DataChunk implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.DataChunk';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new DataChunk();\n    DataChunk.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: DataChunk) {}\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: DataChunk,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.data = _reader.readBytes();\n          break;\n        case 2:\n          _instance.dataComplete = _reader.readBool();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    DataChunk.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: DataChunk, _writer: BinaryWriter) {\n    if (_instance.data && _instance.data.length) {\n      _writer.writeBytes(1, _instance.data);\n    }\n    if (_instance.dataComplete || _instance.dataComplete === false) {\n      _writer.writeBool(2, _instance.dataComplete);\n    }\n  }\n\n  private _data: Uint8Array;\n  private _dataComplete: boolean;\n\n  private _type: DataChunk.TypeCase = DataChunk.TypeCase.none;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of DataChunk to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<DataChunk.AsObject>) {\n    _value = _value || {};\n    this.data = _value.data;\n    this.dataComplete = _value.dataComplete;\n    DataChunk.refineValues(this);\n  }\n  get data(): Uint8Array {\n    return this._data;\n  }\n  set data(value: Uint8Array) {\n    if (value !== undefined && value !== null) {\n      this._dataComplete = undefined;\n      this._type = DataChunk.TypeCase.data;\n    }\n    this._data = value;\n  }\n  get dataComplete(): boolean {\n    return this._dataComplete;\n  }\n  set dataComplete(value: boolean) {\n    if (value !== undefined && value !== null) {\n      this._data = undefined;\n      this._type = DataChunk.TypeCase.dataComplete;\n    }\n    this._dataComplete = value;\n  }\n  get type() {\n    return this._type;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    DataChunk.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(): DataChunk.AsObject {\n    return {\n      data: this.data ? this.data.subarray(0) : new Uint8Array(),\n      dataComplete: this.dataComplete\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  ): DataChunk.AsProtobufJSON {\n    return {\n      data: this.data ? uint8ArrayToBase64(this.data) : '',\n      dataComplete: this.dataComplete\n    };\n  }\n}\nexport module DataChunk {\n  /**\n   * Standard JavaScript object representation for DataChunk\n   */\n  export interface AsObject {\n    data: Uint8Array;\n    dataComplete: boolean;\n  }\n\n  /**\n   * Protobuf JSON representation for DataChunk\n   */\n  export interface AsProtobufJSON {\n    data: string;\n    dataComplete: boolean;\n  }\n  export enum TypeCase {\n    none = 0,\n    data = 1,\n    dataComplete = 2\n  }\n}\n\n/**\n * Message implementation for armonik.api.grpc.v1.TaskRequestHeader\n */\nexport class TaskRequestHeader implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.TaskRequestHeader';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new TaskRequestHeader();\n    TaskRequestHeader.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: TaskRequestHeader) {\n    _instance.expectedOutputKeys = _instance.expectedOutputKeys || [];\n    _instance.dataDependencies = _instance.dataDependencies || [];\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: TaskRequestHeader,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          (_instance.expectedOutputKeys =\n            _instance.expectedOutputKeys || []).push(_reader.readString());\n          break;\n        case 2:\n          (_instance.dataDependencies = _instance.dataDependencies || []).push(\n            _reader.readString()\n          );\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    TaskRequestHeader.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: TaskRequestHeader,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.expectedOutputKeys && _instance.expectedOutputKeys.length) {\n      _writer.writeRepeatedString(1, _instance.expectedOutputKeys);\n    }\n    if (_instance.dataDependencies && _instance.dataDependencies.length) {\n      _writer.writeRepeatedString(2, _instance.dataDependencies);\n    }\n  }\n\n  private _expectedOutputKeys: string[];\n  private _dataDependencies: 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 TaskRequestHeader to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<TaskRequestHeader.AsObject>) {\n    _value = _value || {};\n    this.expectedOutputKeys = (_value.expectedOutputKeys || []).slice();\n    this.dataDependencies = (_value.dataDependencies || []).slice();\n    TaskRequestHeader.refineValues(this);\n  }\n  get expectedOutputKeys(): string[] {\n    return this._expectedOutputKeys;\n  }\n  set expectedOutputKeys(value: string[]) {\n    this._expectedOutputKeys = value;\n  }\n  get dataDependencies(): string[] {\n    return this._dataDependencies;\n  }\n  set dataDependencies(value: string[]) {\n    this._dataDependencies = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    TaskRequestHeader.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(): TaskRequestHeader.AsObject {\n    return {\n      expectedOutputKeys: (this.expectedOutputKeys || []).slice(),\n      dataDependencies: (this.dataDependencies || []).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  ): TaskRequestHeader.AsProtobufJSON {\n    return {\n      expectedOutputKeys: (this.expectedOutputKeys || []).slice(),\n      dataDependencies: (this.dataDependencies || []).slice()\n    };\n  }\n}\nexport module TaskRequestHeader {\n  /**\n   * Standard JavaScript object representation for TaskRequestHeader\n   */\n  export interface AsObject {\n    expectedOutputKeys: string[];\n    dataDependencies: string[];\n  }\n\n  /**\n   * Protobuf JSON representation for TaskRequestHeader\n   */\n  export interface AsProtobufJSON {\n    expectedOutputKeys: string[];\n    dataDependencies: string[];\n  }\n}\n\n/**\n * Message implementation for armonik.api.grpc.v1.InitTaskRequest\n */\nexport class InitTaskRequest implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.InitTaskRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new InitTaskRequest();\n    InitTaskRequest.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: InitTaskRequest) {}\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: InitTaskRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.header = new TaskRequestHeader();\n          _reader.readMessage(\n            _instance.header,\n            TaskRequestHeader.deserializeBinaryFromReader\n          );\n          break;\n        case 2:\n          _instance.lastTask = _reader.readBool();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    InitTaskRequest.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: InitTaskRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.header) {\n      _writer.writeMessage(\n        1,\n        _instance.header as any,\n        TaskRequestHeader.serializeBinaryToWriter\n      );\n    }\n    if (_instance.lastTask || _instance.lastTask === false) {\n      _writer.writeBool(2, _instance.lastTask);\n    }\n  }\n\n  private _header?: TaskRequestHeader;\n  private _lastTask: boolean;\n\n  private _type: InitTaskRequest.TypeCase = InitTaskRequest.TypeCase.none;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of InitTaskRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<InitTaskRequest.AsObject>) {\n    _value = _value || {};\n    this.header = _value.header\n      ? new TaskRequestHeader(_value.header)\n      : undefined;\n    this.lastTask = _value.lastTask;\n    InitTaskRequest.refineValues(this);\n  }\n  get header(): TaskRequestHeader | undefined {\n    return this._header;\n  }\n  set header(value: TaskRequestHeader | undefined) {\n    if (value !== undefined && value !== null) {\n      this._lastTask = undefined;\n      this._type = InitTaskRequest.TypeCase.header;\n    }\n    this._header = value;\n  }\n  get lastTask(): boolean {\n    return this._lastTask;\n  }\n  set lastTask(value: boolean) {\n    if (value !== undefined && value !== null) {\n      this._header = undefined;\n      this._type = InitTaskRequest.TypeCase.lastTask;\n    }\n    this._lastTask = value;\n  }\n  get type() {\n    return this._type;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    InitTaskRequest.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(): InitTaskRequest.AsObject {\n    return {\n      header: this.header ? this.header.toObject() : undefined,\n      lastTask: this.lastTask\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  ): InitTaskRequest.AsProtobufJSON {\n    return {\n      header: this.header ? this.header.toProtobufJSON(options) : null,\n      lastTask: this.lastTask\n    };\n  }\n}\nexport module InitTaskRequest {\n  /**\n   * Standard JavaScript object representation for InitTaskRequest\n   */\n  export interface AsObject {\n    header?: TaskRequestHeader.AsObject;\n    lastTask: boolean;\n  }\n\n  /**\n   * Protobuf JSON representation for InitTaskRequest\n   */\n  export interface AsProtobufJSON {\n    header: TaskRequestHeader.AsProtobufJSON | null;\n    lastTask: boolean;\n  }\n  export enum TypeCase {\n    none = 0,\n    header = 1,\n    lastTask = 2\n  }\n}\n\n/**\n * Message implementation for armonik.api.grpc.v1.TaskId\n */\nexport class TaskId implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.TaskId';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new TaskId();\n    TaskId.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: TaskId) {\n    _instance.session = _instance.session || '';\n    _instance.task = _instance.task || '';\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: TaskId, _reader: BinaryReader) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.session = _reader.readString();\n          break;\n        case 2:\n          _instance.task = _reader.readString();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    TaskId.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: TaskId, _writer: BinaryWriter) {\n    if (_instance.session) {\n      _writer.writeString(1, _instance.session);\n    }\n    if (_instance.task) {\n      _writer.writeString(2, _instance.task);\n    }\n  }\n\n  private _session: string;\n  private _task: 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 TaskId to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<TaskId.AsObject>) {\n    _value = _value || {};\n    this.session = _value.session;\n    this.task = _value.task;\n    TaskId.refineValues(this);\n  }\n  get session(): string {\n    return this._session;\n  }\n  set session(value: string) {\n    this._session = value;\n  }\n  get task(): string {\n    return this._task;\n  }\n  set task(value: string) {\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    TaskId.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(): TaskId.AsObject {\n    return {\n      session: this.session,\n      task: this.task\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  ): TaskId.AsProtobufJSON {\n    return {\n      session: this.session,\n      task: this.task\n    };\n  }\n}\nexport module TaskId {\n  /**\n   * Standard JavaScript object representation for TaskId\n   */\n  export interface AsObject {\n    session: string;\n    task: string;\n  }\n\n  /**\n   * Protobuf JSON representation for TaskId\n   */\n  export interface AsProtobufJSON {\n    session: string;\n    task: string;\n  }\n}\n\n/**\n * Message implementation for armonik.api.grpc.v1.TaskIdList\n */\nexport class TaskIdList implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.TaskIdList';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new TaskIdList();\n    TaskIdList.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: TaskIdList) {\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: TaskIdList,\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    TaskIdList.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: TaskIdList, _writer: BinaryWriter) {\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 TaskIdList to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<TaskIdList.AsObject>) {\n    _value = _value || {};\n    this.taskIds = (_value.taskIds || []).slice();\n    TaskIdList.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    TaskIdList.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(): TaskIdList.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  ): TaskIdList.AsProtobufJSON {\n    return {\n      taskIds: (this.taskIds || []).slice()\n    };\n  }\n}\nexport module TaskIdList {\n  /**\n   * Standard JavaScript object representation for TaskIdList\n   */\n  export interface AsObject {\n    taskIds: string[];\n  }\n\n  /**\n   * Protobuf JSON representation for TaskIdList\n   */\n  export interface AsProtobufJSON {\n    taskIds: string[];\n  }\n}\n\n/**\n * Message implementation for armonik.api.grpc.v1.StatusCount\n */\nexport class StatusCount implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.StatusCount';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new StatusCount();\n    StatusCount.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: StatusCount) {\n    _instance.status = _instance.status || 0;\n    _instance.count = _instance.count || 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: StatusCount,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.status = _reader.readEnum();\n          break;\n        case 2:\n          _instance.count = _reader.readInt32();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    StatusCount.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: StatusCount,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.status) {\n      _writer.writeEnum(1, _instance.status);\n    }\n    if (_instance.count) {\n      _writer.writeInt32(2, _instance.count);\n    }\n  }\n\n  private _status: armonikApiGrpcV1Task_status001.TaskStatus;\n  private _count: 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 StatusCount to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<StatusCount.AsObject>) {\n    _value = _value || {};\n    this.status = _value.status;\n    this.count = _value.count;\n    StatusCount.refineValues(this);\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 count(): number {\n    return this._count;\n  }\n  set count(value: number) {\n    this._count = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    StatusCount.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(): StatusCount.AsObject {\n    return {\n      status: this.status,\n      count: this.count\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  ): StatusCount.AsProtobufJSON {\n    return {\n      status:\n        armonikApiGrpcV1Task_status001.TaskStatus[\n          this.status === null || this.status === undefined ? 0 : this.status\n        ],\n      count: this.count\n    };\n  }\n}\nexport module StatusCount {\n  /**\n   * Standard JavaScript object representation for StatusCount\n   */\n  export interface AsObject {\n    status: armonikApiGrpcV1Task_status001.TaskStatus;\n    count: number;\n  }\n\n  /**\n   * Protobuf JSON representation for StatusCount\n   */\n  export interface AsProtobufJSON {\n    status: string;\n    count: number;\n  }\n}\n\n/**\n * Message implementation for armonik.api.grpc.v1.Count\n */\nexport class Count implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.Count';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new Count();\n    Count.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: Count) {\n    _instance.values = _instance.values || [];\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: Count, _reader: BinaryReader) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          const messageInitializer1 = new StatusCount();\n          _reader.readMessage(\n            messageInitializer1,\n            StatusCount.deserializeBinaryFromReader\n          );\n          (_instance.values = _instance.values || []).push(messageInitializer1);\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    Count.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: Count, _writer: BinaryWriter) {\n    if (_instance.values && _instance.values.length) {\n      _writer.writeRepeatedMessage(\n        1,\n        _instance.values as any,\n        StatusCount.serializeBinaryToWriter\n      );\n    }\n  }\n\n  private _values?: 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 Count to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<Count.AsObject>) {\n    _value = _value || {};\n    this.values = (_value.values || []).map(m => new StatusCount(m));\n    Count.refineValues(this);\n  }\n  get values(): StatusCount[] | undefined {\n    return this._values;\n  }\n  set values(value: StatusCount[] | undefined) {\n    this._values = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    Count.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(): Count.AsObject {\n    return {\n      values: (this.values || []).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  ): Count.AsProtobufJSON {\n    return {\n      values: (this.values || []).map(m => m.toProtobufJSON(options))\n    };\n  }\n}\nexport module Count {\n  /**\n   * Standard JavaScript object representation for Count\n   */\n  export interface AsObject {\n    values?: StatusCount.AsObject[];\n  }\n\n  /**\n   * Protobuf JSON representation for Count\n   */\n  export interface AsProtobufJSON {\n    values: StatusCount.AsProtobufJSON[] | null;\n  }\n}\n\n/**\n * Message implementation for armonik.api.grpc.v1.ResultRequest\n */\nexport class ResultRequest implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.ResultRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new ResultRequest();\n    ResultRequest.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: ResultRequest) {\n    _instance.session = _instance.session || '';\n    _instance.resultId = _instance.resultId || '';\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: ResultRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.session = _reader.readString();\n          break;\n        case 2:\n          _instance.resultId = _reader.readString();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    ResultRequest.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: ResultRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.session) {\n      _writer.writeString(1, _instance.session);\n    }\n    if (_instance.resultId) {\n      _writer.writeString(2, _instance.resultId);\n    }\n  }\n\n  private _session: string;\n  private _resultId: 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 ResultRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<ResultRequest.AsObject>) {\n    _value = _value || {};\n    this.session = _value.session;\n    this.resultId = _value.resultId;\n    ResultRequest.refineValues(this);\n  }\n  get session(): string {\n    return this._session;\n  }\n  set session(value: string) {\n    this._session = value;\n  }\n  get resultId(): string {\n    return this._resultId;\n  }\n  set resultId(value: string) {\n    this._resultId = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    ResultRequest.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(): ResultRequest.AsObject {\n    return {\n      session: this.session,\n      resultId: this.resultId\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  ): ResultRequest.AsProtobufJSON {\n    return {\n      session: this.session,\n      resultId: this.resultId\n    };\n  }\n}\nexport module ResultRequest {\n  /**\n   * Standard JavaScript object representation for ResultRequest\n   */\n  export interface AsObject {\n    session: string;\n    resultId: string;\n  }\n\n  /**\n   * Protobuf JSON representation for ResultRequest\n   */\n  export interface AsProtobufJSON {\n    session: string;\n    resultId: string;\n  }\n}\n\n/**\n * Message implementation for armonik.api.grpc.v1.TaskOutputRequest\n */\nexport class TaskOutputRequest implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.TaskOutputRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new TaskOutputRequest();\n    TaskOutputRequest.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: TaskOutputRequest) {\n    _instance.session = _instance.session || '';\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: TaskOutputRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.session = _reader.readString();\n          break;\n        case 2:\n          _instance.taskId = _reader.readString();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    TaskOutputRequest.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: TaskOutputRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.session) {\n      _writer.writeString(1, _instance.session);\n    }\n    if (_instance.taskId) {\n      _writer.writeString(2, _instance.taskId);\n    }\n  }\n\n  private _session: string;\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 TaskOutputRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<TaskOutputRequest.AsObject>) {\n    _value = _value || {};\n    this.session = _value.session;\n    this.taskId = _value.taskId;\n    TaskOutputRequest.refineValues(this);\n  }\n  get session(): string {\n    return this._session;\n  }\n  set session(value: string) {\n    this._session = value;\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    TaskOutputRequest.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(): TaskOutputRequest.AsObject {\n    return {\n      session: this.session,\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  ): TaskOutputRequest.AsProtobufJSON {\n    return {\n      session: this.session,\n      taskId: this.taskId\n    };\n  }\n}\nexport module TaskOutputRequest {\n  /**\n   * Standard JavaScript object representation for TaskOutputRequest\n   */\n  export interface AsObject {\n    session: string;\n    taskId: string;\n  }\n\n  /**\n   * Protobuf JSON representation for TaskOutputRequest\n   */\n  export interface AsProtobufJSON {\n    session: string;\n    taskId: string;\n  }\n}\n\n/**\n * Message implementation for armonik.api.grpc.v1.Error\n */\nexport class Error implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.Error';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new Error();\n    Error.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: Error) {\n    _instance.taskStatus = _instance.taskStatus || 0;\n    _instance.detail = _instance.detail || '';\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: Error, _reader: BinaryReader) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.taskStatus = _reader.readEnum();\n          break;\n        case 2:\n          _instance.detail = _reader.readString();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    Error.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: Error, _writer: BinaryWriter) {\n    if (_instance.taskStatus) {\n      _writer.writeEnum(1, _instance.taskStatus);\n    }\n    if (_instance.detail) {\n      _writer.writeString(2, _instance.detail);\n    }\n  }\n\n  private _taskStatus: armonikApiGrpcV1Task_status001.TaskStatus;\n  private _detail: 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 Error to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<Error.AsObject>) {\n    _value = _value || {};\n    this.taskStatus = _value.taskStatus;\n    this.detail = _value.detail;\n    Error.refineValues(this);\n  }\n  get taskStatus(): armonikApiGrpcV1Task_status001.TaskStatus {\n    return this._taskStatus;\n  }\n  set taskStatus(value: armonikApiGrpcV1Task_status001.TaskStatus) {\n    this._taskStatus = value;\n  }\n  get detail(): string {\n    return this._detail;\n  }\n  set detail(value: string) {\n    this._detail = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    Error.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(): Error.AsObject {\n    return {\n      taskStatus: this.taskStatus,\n      detail: this.detail\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  ): Error.AsProtobufJSON {\n    return {\n      taskStatus:\n        armonikApiGrpcV1Task_status001.TaskStatus[\n          this.taskStatus === null || this.taskStatus === undefined\n            ? 0\n            : this.taskStatus\n        ],\n      detail: this.detail\n    };\n  }\n}\nexport module Error {\n  /**\n   * Standard JavaScript object representation for Error\n   */\n  export interface AsObject {\n    taskStatus: armonikApiGrpcV1Task_status001.TaskStatus;\n    detail: string;\n  }\n\n  /**\n   * Protobuf JSON representation for Error\n   */\n  export interface AsProtobufJSON {\n    taskStatus: string;\n    detail: string;\n  }\n}\n\n/**\n * Message implementation for armonik.api.grpc.v1.TaskError\n */\nexport class TaskError implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.TaskError';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new TaskError();\n    TaskError.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: TaskError) {\n    _instance.taskId = _instance.taskId || '';\n    _instance.errors = _instance.errors || [];\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: TaskError,\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          const messageInitializer2 = new Error();\n          _reader.readMessage(\n            messageInitializer2,\n            Error.deserializeBinaryFromReader\n          );\n          (_instance.errors = _instance.errors || []).push(messageInitializer2);\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    TaskError.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: TaskError, _writer: BinaryWriter) {\n    if (_instance.taskId) {\n      _writer.writeString(1, _instance.taskId);\n    }\n    if (_instance.errors && _instance.errors.length) {\n      _writer.writeRepeatedMessage(\n        2,\n        _instance.errors as any,\n        Error.serializeBinaryToWriter\n      );\n    }\n  }\n\n  private _taskId: string;\n  private _errors?: Error[];\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of TaskError to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<TaskError.AsObject>) {\n    _value = _value || {};\n    this.taskId = _value.taskId;\n    this.errors = (_value.errors || []).map(m => new Error(m));\n    TaskError.refineValues(this);\n  }\n  get taskId(): string {\n    return this._taskId;\n  }\n  set taskId(value: string) {\n    this._taskId = value;\n  }\n  get errors(): Error[] | undefined {\n    return this._errors;\n  }\n  set errors(value: Error[] | undefined) {\n    this._errors = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    TaskError.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(): TaskError.AsObject {\n    return {\n      taskId: this.taskId,\n      errors: (this.errors || []).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  ): TaskError.AsProtobufJSON {\n    return {\n      taskId: this.taskId,\n      errors: (this.errors || []).map(m => m.toProtobufJSON(options))\n    };\n  }\n}\nexport module TaskError {\n  /**\n   * Standard JavaScript object representation for TaskError\n   */\n  export interface AsObject {\n    taskId: string;\n    errors?: Error.AsObject[];\n  }\n\n  /**\n   * Protobuf JSON representation for TaskError\n   */\n  export interface AsProtobufJSON {\n    taskId: string;\n    errors: Error.AsProtobufJSON[] | null;\n  }\n}\n\n/**\n * Message implementation for armonik.api.grpc.v1.TaskList\n */\nexport class TaskList implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.TaskList';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new TaskList();\n    TaskList.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: TaskList) {\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: TaskList,\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 TaskId();\n          _reader.readMessage(\n            messageInitializer1,\n            TaskId.deserializeBinaryFromReader\n          );\n          (_instance.taskIds = _instance.taskIds || []).push(\n            messageInitializer1\n          );\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    TaskList.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: TaskList, _writer: BinaryWriter) {\n    if (_instance.taskIds && _instance.taskIds.length) {\n      _writer.writeRepeatedMessage(\n        1,\n        _instance.taskIds as any,\n        TaskId.serializeBinaryToWriter\n      );\n    }\n  }\n\n  private _taskIds?: TaskId[];\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of TaskList to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<TaskList.AsObject>) {\n    _value = _value || {};\n    this.taskIds = (_value.taskIds || []).map(m => new TaskId(m));\n    TaskList.refineValues(this);\n  }\n  get taskIds(): TaskId[] | undefined {\n    return this._taskIds;\n  }\n  set taskIds(value: TaskId[] | undefined) {\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    TaskList.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(): TaskList.AsObject {\n    return {\n      taskIds: (this.taskIds || []).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  ): TaskList.AsProtobufJSON {\n    return {\n      taskIds: (this.taskIds || []).map(m => m.toProtobufJSON(options))\n    };\n  }\n}\nexport module TaskList {\n  /**\n   * Standard JavaScript object representation for TaskList\n   */\n  export interface AsObject {\n    taskIds?: TaskId.AsObject[];\n  }\n\n  /**\n   * Protobuf JSON representation for TaskList\n   */\n  export interface AsProtobufJSON {\n    taskIds: TaskId.AsProtobufJSON[] | null;\n  }\n}\n\n/**\n * Message implementation for armonik.api.grpc.v1.TaskIdWithStatus\n */\nexport class TaskIdWithStatus implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.TaskIdWithStatus';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new TaskIdWithStatus();\n    TaskIdWithStatus.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: TaskIdWithStatus) {\n    _instance.taskId = _instance.taskId || undefined;\n    _instance.status = _instance.status || 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: TaskIdWithStatus,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.taskId = new TaskId();\n          _reader.readMessage(\n            _instance.taskId,\n            TaskId.deserializeBinaryFromReader\n          );\n          break;\n        case 2:\n          _instance.status = _reader.readEnum();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    TaskIdWithStatus.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: TaskIdWithStatus,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.taskId) {\n      _writer.writeMessage(\n        1,\n        _instance.taskId as any,\n        TaskId.serializeBinaryToWriter\n      );\n    }\n    if (_instance.status) {\n      _writer.writeEnum(2, _instance.status);\n    }\n  }\n\n  private _taskId?: TaskId;\n  private _status: armonikApiGrpcV1Task_status001.TaskStatus;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of TaskIdWithStatus to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<TaskIdWithStatus.AsObject>) {\n    _value = _value || {};\n    this.taskId = _value.taskId ? new TaskId(_value.taskId) : undefined;\n    this.status = _value.status;\n    TaskIdWithStatus.refineValues(this);\n  }\n  get taskId(): TaskId | undefined {\n    return this._taskId;\n  }\n  set taskId(value: TaskId | undefined) {\n    this._taskId = 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\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    TaskIdWithStatus.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(): TaskIdWithStatus.AsObject {\n    return {\n      taskId: this.taskId ? this.taskId.toObject() : undefined,\n      status: this.status\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  ): TaskIdWithStatus.AsProtobufJSON {\n    return {\n      taskId: this.taskId ? this.taskId.toProtobufJSON(options) : null,\n      status:\n        armonikApiGrpcV1Task_status001.TaskStatus[\n          this.status === null || this.status === undefined ? 0 : this.status\n        ]\n    };\n  }\n}\nexport module TaskIdWithStatus {\n  /**\n   * Standard JavaScript object representation for TaskIdWithStatus\n   */\n  export interface AsObject {\n    taskId?: TaskId.AsObject;\n    status: armonikApiGrpcV1Task_status001.TaskStatus;\n  }\n\n  /**\n   * Protobuf JSON representation for TaskIdWithStatus\n   */\n  export interface AsProtobufJSON {\n    taskId: TaskId.AsProtobufJSON | null;\n    status: string;\n  }\n}\n"]}