@aneoconsultingfr/armonik.api.angular 3.4.0

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

@@ -0,0 +1,1167 @@
+import { BinaryReader, BinaryWriter } from 'google-protobuf';
+import * as googleProtobuf000 from '@ngx-grpc/well-known-types';
+import * as armonikApiGrpcV1Result_status001 from './result-status.pb';
+/**
+ * Message implementation for armonik.api.grpc.v1.results.ResultRaw
+ */
+export class ResultRaw {
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new ResultRaw();
+        ResultRaw.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+        return instance;
+    }
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance) {
+        _instance.sessionId = _instance.sessionId || '';
+        _instance.name = _instance.name || '';
+        _instance.ownerTaskId = _instance.ownerTaskId || '';
+        _instance.status = _instance.status || 0;
+        _instance.createdAt = _instance.createdAt || undefined;
+    }
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance, _reader) {
+        while (_reader.nextField()) {
+            if (_reader.isEndGroup())
+                break;
+            switch (_reader.getFieldNumber()) {
+                case 1:
+                    _instance.sessionId = _reader.readString();
+                    break;
+                case 2:
+                    _instance.name = _reader.readString();
+                    break;
+                case 3:
+                    _instance.ownerTaskId = _reader.readString();
+                    break;
+                case 4:
+                    _instance.status = _reader.readEnum();
+                    break;
+                case 5:
+                    _instance.createdAt = new googleProtobuf000.Timestamp();
+                    _reader.readMessage(_instance.createdAt, googleProtobuf000.Timestamp.deserializeBinaryFromReader);
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        ResultRaw.refineValues(_instance);
+    }
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance, _writer) {
+        if (_instance.sessionId) {
+            _writer.writeString(1, _instance.sessionId);
+        }
+        if (_instance.name) {
+            _writer.writeString(2, _instance.name);
+        }
+        if (_instance.ownerTaskId) {
+            _writer.writeString(3, _instance.ownerTaskId);
+        }
+        if (_instance.status) {
+            _writer.writeEnum(4, _instance.status);
+        }
+        if (_instance.createdAt) {
+            _writer.writeMessage(5, _instance.createdAt, googleProtobuf000.Timestamp.serializeBinaryToWriter);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of ResultRaw to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.sessionId = _value.sessionId;
+        this.name = _value.name;
+        this.ownerTaskId = _value.ownerTaskId;
+        this.status = _value.status;
+        this.createdAt = _value.createdAt
+            ? new googleProtobuf000.Timestamp(_value.createdAt)
+            : undefined;
+        ResultRaw.refineValues(this);
+    }
+    get sessionId() {
+        return this._sessionId;
+    }
+    set sessionId(value) {
+        this._sessionId = value;
+    }
+    get name() {
+        return this._name;
+    }
+    set name(value) {
+        this._name = value;
+    }
+    get ownerTaskId() {
+        return this._ownerTaskId;
+    }
+    set ownerTaskId(value) {
+        this._ownerTaskId = value;
+    }
+    get status() {
+        return this._status;
+    }
+    set status(value) {
+        this._status = value;
+    }
+    get createdAt() {
+        return this._createdAt;
+    }
+    set createdAt(value) {
+        this._createdAt = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        ResultRaw.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            sessionId: this.sessionId,
+            name: this.name,
+            ownerTaskId: this.ownerTaskId,
+            status: this.status,
+            createdAt: this.createdAt ? this.createdAt.toObject() : undefined
+        };
+    }
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON() {
+        return this.toObject();
+    }
+    /**
+     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+     */
+    toProtobufJSON(
+    // @ts-ignore
+    options) {
+        return {
+            sessionId: this.sessionId,
+            name: this.name,
+            ownerTaskId: this.ownerTaskId,
+            status: armonikApiGrpcV1Result_status001.ResultStatus[this.status === null || this.status === undefined ? 0 : this.status],
+            createdAt: this.createdAt ? this.createdAt.toProtobufJSON(options) : null
+        };
+    }
+}
+ResultRaw.id = 'armonik.api.grpc.v1.results.ResultRaw';
+/**
+ * Message implementation for armonik.api.grpc.v1.results.ListResultsRequest
+ */
+export class ListResultsRequest {
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new ListResultsRequest();
+        ListResultsRequest.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+        return instance;
+    }
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance) {
+        _instance.page = _instance.page || 0;
+        _instance.pageSize = _instance.pageSize || 0;
+        _instance.filter = _instance.filter || undefined;
+        _instance.sort = _instance.sort || undefined;
+    }
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance, _reader) {
+        while (_reader.nextField()) {
+            if (_reader.isEndGroup())
+                break;
+            switch (_reader.getFieldNumber()) {
+                case 1:
+                    _instance.page = _reader.readInt32();
+                    break;
+                case 2:
+                    _instance.pageSize = _reader.readInt32();
+                    break;
+                case 3:
+                    _instance.filter = new ListResultsRequest.Filter();
+                    _reader.readMessage(_instance.filter, ListResultsRequest.Filter.deserializeBinaryFromReader);
+                    break;
+                case 4:
+                    _instance.sort = new ListResultsRequest.Sort();
+                    _reader.readMessage(_instance.sort, ListResultsRequest.Sort.deserializeBinaryFromReader);
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        ListResultsRequest.refineValues(_instance);
+    }
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance, _writer) {
+        if (_instance.page) {
+            _writer.writeInt32(1, _instance.page);
+        }
+        if (_instance.pageSize) {
+            _writer.writeInt32(2, _instance.pageSize);
+        }
+        if (_instance.filter) {
+            _writer.writeMessage(3, _instance.filter, ListResultsRequest.Filter.serializeBinaryToWriter);
+        }
+        if (_instance.sort) {
+            _writer.writeMessage(4, _instance.sort, ListResultsRequest.Sort.serializeBinaryToWriter);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of ListResultsRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.page = _value.page;
+        this.pageSize = _value.pageSize;
+        this.filter = _value.filter
+            ? new ListResultsRequest.Filter(_value.filter)
+            : undefined;
+        this.sort = _value.sort
+            ? new ListResultsRequest.Sort(_value.sort)
+            : undefined;
+        ListResultsRequest.refineValues(this);
+    }
+    get page() {
+        return this._page;
+    }
+    set page(value) {
+        this._page = value;
+    }
+    get pageSize() {
+        return this._pageSize;
+    }
+    set pageSize(value) {
+        this._pageSize = value;
+    }
+    get filter() {
+        return this._filter;
+    }
+    set filter(value) {
+        this._filter = value;
+    }
+    get sort() {
+        return this._sort;
+    }
+    set sort(value) {
+        this._sort = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        ListResultsRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            page: this.page,
+            pageSize: this.pageSize,
+            filter: this.filter ? this.filter.toObject() : undefined,
+            sort: this.sort ? this.sort.toObject() : undefined
+        };
+    }
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON() {
+        return this.toObject();
+    }
+    /**
+     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+     */
+    toProtobufJSON(
+    // @ts-ignore
+    options) {
+        return {
+            page: this.page,
+            pageSize: this.pageSize,
+            filter: this.filter ? this.filter.toProtobufJSON(options) : null,
+            sort: this.sort ? this.sort.toProtobufJSON(options) : null
+        };
+    }
+}
+ListResultsRequest.id = 'armonik.api.grpc.v1.results.ListResultsRequest';
+(function (ListResultsRequest) {
+    let OrderByField;
+    (function (OrderByField) {
+        OrderByField[OrderByField["ORDER_BY_FIELD_UNSPECIFIED"] = 0] = "ORDER_BY_FIELD_UNSPECIFIED";
+        OrderByField[OrderByField["ORDER_BY_FIELD_SESSION_ID"] = 1] = "ORDER_BY_FIELD_SESSION_ID";
+        OrderByField[OrderByField["ORDER_BY_FIELD_NAME"] = 2] = "ORDER_BY_FIELD_NAME";
+        OrderByField[OrderByField["ORDER_BY_FIELD_OWNER_TASK_ID"] = 3] = "ORDER_BY_FIELD_OWNER_TASK_ID";
+        OrderByField[OrderByField["ORDER_BY_FIELD_STATUS"] = 4] = "ORDER_BY_FIELD_STATUS";
+        OrderByField[OrderByField["ORDER_BY_FIELD_CREATED_AT"] = 5] = "ORDER_BY_FIELD_CREATED_AT";
+    })(OrderByField = ListResultsRequest.OrderByField || (ListResultsRequest.OrderByField = {}));
+    let OrderDirection;
+    (function (OrderDirection) {
+        OrderDirection[OrderDirection["ORDER_DIRECTION_UNSPECIFIED"] = 0] = "ORDER_DIRECTION_UNSPECIFIED";
+        OrderDirection[OrderDirection["ORDER_DIRECTION_ASC"] = 1] = "ORDER_DIRECTION_ASC";
+        OrderDirection[OrderDirection["ORDER_DIRECTION_DESC"] = 2] = "ORDER_DIRECTION_DESC";
+    })(OrderDirection = ListResultsRequest.OrderDirection || (ListResultsRequest.OrderDirection = {}));
+    /**
+     * Message implementation for armonik.api.grpc.v1.results.ListResultsRequest.Filter
+     */
+    class Filter {
+        /**
+         * Deserialize binary data to message
+         * @param instance message instance
+         */
+        static deserializeBinary(bytes) {
+            const instance = new Filter();
+            Filter.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+            return instance;
+        }
+        /**
+         * Check all the properties and set default protobuf values if necessary
+         * @param _instance message instance
+         */
+        static refineValues(_instance) {
+            _instance.sessionId = _instance.sessionId || '';
+            _instance.name = _instance.name || '';
+            _instance.ownerTaskId = _instance.ownerTaskId || '';
+            _instance.status = _instance.status || 0;
+            _instance.createdAfter = _instance.createdAfter || undefined;
+            _instance.createdBefore = _instance.createdBefore || undefined;
+        }
+        /**
+         * Deserializes / reads binary message into message instance using provided binary reader
+         * @param _instance message instance
+         * @param _reader binary reader instance
+         */
+        static deserializeBinaryFromReader(_instance, _reader) {
+            while (_reader.nextField()) {
+                if (_reader.isEndGroup())
+                    break;
+                switch (_reader.getFieldNumber()) {
+                    case 1:
+                        _instance.sessionId = _reader.readString();
+                        break;
+                    case 2:
+                        _instance.name = _reader.readString();
+                        break;
+                    case 3:
+                        _instance.ownerTaskId = _reader.readString();
+                        break;
+                    case 4:
+                        _instance.status = _reader.readEnum();
+                        break;
+                    case 5:
+                        _instance.createdAfter = new googleProtobuf000.Timestamp();
+                        _reader.readMessage(_instance.createdAfter, googleProtobuf000.Timestamp.deserializeBinaryFromReader);
+                        break;
+                    case 6:
+                        _instance.createdBefore = new googleProtobuf000.Timestamp();
+                        _reader.readMessage(_instance.createdBefore, googleProtobuf000.Timestamp.deserializeBinaryFromReader);
+                        break;
+                    default:
+                        _reader.skipField();
+                }
+            }
+            Filter.refineValues(_instance);
+        }
+        /**
+         * Serializes a message to binary format using provided binary reader
+         * @param _instance message instance
+         * @param _writer binary writer instance
+         */
+        static serializeBinaryToWriter(_instance, _writer) {
+            if (_instance.sessionId) {
+                _writer.writeString(1, _instance.sessionId);
+            }
+            if (_instance.name) {
+                _writer.writeString(2, _instance.name);
+            }
+            if (_instance.ownerTaskId) {
+                _writer.writeString(3, _instance.ownerTaskId);
+            }
+            if (_instance.status) {
+                _writer.writeEnum(4, _instance.status);
+            }
+            if (_instance.createdAfter) {
+                _writer.writeMessage(5, _instance.createdAfter, googleProtobuf000.Timestamp.serializeBinaryToWriter);
+            }
+            if (_instance.createdBefore) {
+                _writer.writeMessage(6, _instance.createdBefore, googleProtobuf000.Timestamp.serializeBinaryToWriter);
+            }
+        }
+        /**
+         * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+         * @param _value initial values object or instance of Filter to deeply clone from
+         */
+        constructor(_value) {
+            _value = _value || {};
+            this.sessionId = _value.sessionId;
+            this.name = _value.name;
+            this.ownerTaskId = _value.ownerTaskId;
+            this.status = _value.status;
+            this.createdAfter = _value.createdAfter
+                ? new googleProtobuf000.Timestamp(_value.createdAfter)
+                : undefined;
+            this.createdBefore = _value.createdBefore
+                ? new googleProtobuf000.Timestamp(_value.createdBefore)
+                : undefined;
+            Filter.refineValues(this);
+        }
+        get sessionId() {
+            return this._sessionId;
+        }
+        set sessionId(value) {
+            this._sessionId = value;
+        }
+        get name() {
+            return this._name;
+        }
+        set name(value) {
+            this._name = value;
+        }
+        get ownerTaskId() {
+            return this._ownerTaskId;
+        }
+        set ownerTaskId(value) {
+            this._ownerTaskId = value;
+        }
+        get status() {
+            return this._status;
+        }
+        set status(value) {
+            this._status = value;
+        }
+        get createdAfter() {
+            return this._createdAfter;
+        }
+        set createdAfter(value) {
+            this._createdAfter = value;
+        }
+        get createdBefore() {
+            return this._createdBefore;
+        }
+        set createdBefore(value) {
+            this._createdBefore = value;
+        }
+        /**
+         * Serialize message to binary data
+         * @param instance message instance
+         */
+        serializeBinary() {
+            const writer = new BinaryWriter();
+            Filter.serializeBinaryToWriter(this, writer);
+            return writer.getResultBuffer();
+        }
+        /**
+         * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+         */
+        toObject() {
+            return {
+                sessionId: this.sessionId,
+                name: this.name,
+                ownerTaskId: this.ownerTaskId,
+                status: this.status,
+                createdAfter: this.createdAfter
+                    ? this.createdAfter.toObject()
+                    : undefined,
+                createdBefore: this.createdBefore
+                    ? this.createdBefore.toObject()
+                    : undefined
+            };
+        }
+        /**
+         * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+         */
+        toJSON() {
+            return this.toObject();
+        }
+        /**
+         * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+         * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+         * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+         */
+        toProtobufJSON(
+        // @ts-ignore
+        options) {
+            return {
+                sessionId: this.sessionId,
+                name: this.name,
+                ownerTaskId: this.ownerTaskId,
+                status: armonikApiGrpcV1Result_status001.ResultStatus[this.status === null || this.status === undefined ? 0 : this.status],
+                createdAfter: this.createdAfter
+                    ? this.createdAfter.toProtobufJSON(options)
+                    : null,
+                createdBefore: this.createdBefore
+                    ? this.createdBefore.toProtobufJSON(options)
+                    : null
+            };
+        }
+    }
+    Filter.id = 'armonik.api.grpc.v1.results.ListResultsRequest.Filter';
+    ListResultsRequest.Filter = Filter;
+    /**
+     * Message implementation for armonik.api.grpc.v1.results.ListResultsRequest.Sort
+     */
+    class Sort {
+        /**
+         * Deserialize binary data to message
+         * @param instance message instance
+         */
+        static deserializeBinary(bytes) {
+            const instance = new Sort();
+            Sort.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+            return instance;
+        }
+        /**
+         * Check all the properties and set default protobuf values if necessary
+         * @param _instance message instance
+         */
+        static refineValues(_instance) {
+            _instance.field = _instance.field || 0;
+            _instance.direction = _instance.direction || 0;
+        }
+        /**
+         * Deserializes / reads binary message into message instance using provided binary reader
+         * @param _instance message instance
+         * @param _reader binary reader instance
+         */
+        static deserializeBinaryFromReader(_instance, _reader) {
+            while (_reader.nextField()) {
+                if (_reader.isEndGroup())
+                    break;
+                switch (_reader.getFieldNumber()) {
+                    case 1:
+                        _instance.field = _reader.readEnum();
+                        break;
+                    case 2:
+                        _instance.direction = _reader.readEnum();
+                        break;
+                    default:
+                        _reader.skipField();
+                }
+            }
+            Sort.refineValues(_instance);
+        }
+        /**
+         * Serializes a message to binary format using provided binary reader
+         * @param _instance message instance
+         * @param _writer binary writer instance
+         */
+        static serializeBinaryToWriter(_instance, _writer) {
+            if (_instance.field) {
+                _writer.writeEnum(1, _instance.field);
+            }
+            if (_instance.direction) {
+                _writer.writeEnum(2, _instance.direction);
+            }
+        }
+        /**
+         * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+         * @param _value initial values object or instance of Sort to deeply clone from
+         */
+        constructor(_value) {
+            _value = _value || {};
+            this.field = _value.field;
+            this.direction = _value.direction;
+            Sort.refineValues(this);
+        }
+        get field() {
+            return this._field;
+        }
+        set field(value) {
+            this._field = value;
+        }
+        get direction() {
+            return this._direction;
+        }
+        set direction(value) {
+            this._direction = value;
+        }
+        /**
+         * Serialize message to binary data
+         * @param instance message instance
+         */
+        serializeBinary() {
+            const writer = new BinaryWriter();
+            Sort.serializeBinaryToWriter(this, writer);
+            return writer.getResultBuffer();
+        }
+        /**
+         * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+         */
+        toObject() {
+            return {
+                field: this.field,
+                direction: this.direction
+            };
+        }
+        /**
+         * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+         */
+        toJSON() {
+            return this.toObject();
+        }
+        /**
+         * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+         * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+         * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+         */
+        toProtobufJSON(
+        // @ts-ignore
+        options) {
+            return {
+                field: ListResultsRequest.OrderByField[this.field === null || this.field === undefined ? 0 : this.field],
+                direction: ListResultsRequest.OrderDirection[this.direction === null || this.direction === undefined
+                    ? 0
+                    : this.direction]
+            };
+        }
+    }
+    Sort.id = 'armonik.api.grpc.v1.results.ListResultsRequest.Sort';
+    ListResultsRequest.Sort = Sort;
+})(ListResultsRequest || (ListResultsRequest = {}));
+/**
+ * Message implementation for armonik.api.grpc.v1.results.ListResultsResponse
+ */
+export class ListResultsResponse {
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new ListResultsResponse();
+        ListResultsResponse.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.results = _instance.results || [];
+        _instance.page = _instance.page || 0;
+        _instance.pageSize = _instance.pageSize || 0;
+        _instance.total = _instance.total || 0;
+    }
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance, _reader) {
+        while (_reader.nextField()) {
+            if (_reader.isEndGroup())
+                break;
+            switch (_reader.getFieldNumber()) {
+                case 1:
+                    const messageInitializer1 = new ResultRaw();
+                    _reader.readMessage(messageInitializer1, ResultRaw.deserializeBinaryFromReader);
+                    (_instance.results = _instance.results || []).push(messageInitializer1);
+                    break;
+                case 2:
+                    _instance.page = _reader.readInt32();
+                    break;
+                case 3:
+                    _instance.pageSize = _reader.readInt32();
+                    break;
+                case 4:
+                    _instance.total = _reader.readInt32();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        ListResultsResponse.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.results && _instance.results.length) {
+            _writer.writeRepeatedMessage(1, _instance.results, ResultRaw.serializeBinaryToWriter);
+        }
+        if (_instance.page) {
+            _writer.writeInt32(2, _instance.page);
+        }
+        if (_instance.pageSize) {
+            _writer.writeInt32(3, _instance.pageSize);
+        }
+        if (_instance.total) {
+            _writer.writeInt32(4, _instance.total);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of ListResultsResponse to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.results = (_value.results || []).map(m => new ResultRaw(m));
+        this.page = _value.page;
+        this.pageSize = _value.pageSize;
+        this.total = _value.total;
+        ListResultsResponse.refineValues(this);
+    }
+    get results() {
+        return this._results;
+    }
+    set results(value) {
+        this._results = value;
+    }
+    get page() {
+        return this._page;
+    }
+    set page(value) {
+        this._page = value;
+    }
+    get pageSize() {
+        return this._pageSize;
+    }
+    set pageSize(value) {
+        this._pageSize = value;
+    }
+    get total() {
+        return this._total;
+    }
+    set total(value) {
+        this._total = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        ListResultsResponse.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            results: (this.results || []).map(m => m.toObject()),
+            page: this.page,
+            pageSize: this.pageSize,
+            total: this.total
+        };
+    }
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON() {
+        return this.toObject();
+    }
+    /**
+     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+     */
+    toProtobufJSON(
+    // @ts-ignore
+    options) {
+        return {
+            results: (this.results || []).map(m => m.toProtobufJSON(options)),
+            page: this.page,
+            pageSize: this.pageSize,
+            total: this.total
+        };
+    }
+}
+ListResultsResponse.id = 'armonik.api.grpc.v1.results.ListResultsResponse';
+/**
+ * Message implementation for armonik.api.grpc.v1.results.GetOwnerTaskIdRequest
+ */
+export class GetOwnerTaskIdRequest {
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new GetOwnerTaskIdRequest();
+        GetOwnerTaskIdRequest.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+        return instance;
+    }
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance) {
+        _instance.sessionId = _instance.sessionId || '';
+        _instance.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.sessionId = _reader.readString();
+                    break;
+                case 2:
+                    (_instance.resultId = _instance.resultId || []).push(_reader.readString());
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        GetOwnerTaskIdRequest.refineValues(_instance);
+    }
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance, _writer) {
+        if (_instance.sessionId) {
+            _writer.writeString(1, _instance.sessionId);
+        }
+        if (_instance.resultId && _instance.resultId.length) {
+            _writer.writeRepeatedString(2, _instance.resultId);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of GetOwnerTaskIdRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.sessionId = _value.sessionId;
+        this.resultId = (_value.resultId || []).slice();
+        GetOwnerTaskIdRequest.refineValues(this);
+    }
+    get sessionId() {
+        return this._sessionId;
+    }
+    set sessionId(value) {
+        this._sessionId = 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();
+        GetOwnerTaskIdRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            sessionId: this.sessionId,
+            resultId: (this.resultId || []).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 {
+            sessionId: this.sessionId,
+            resultId: (this.resultId || []).slice()
+        };
+    }
+}
+GetOwnerTaskIdRequest.id = 'armonik.api.grpc.v1.results.GetOwnerTaskIdRequest';
+/**
+ * Message implementation for armonik.api.grpc.v1.results.GetOwnerTaskIdResponse
+ */
+export class GetOwnerTaskIdResponse {
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new GetOwnerTaskIdResponse();
+        GetOwnerTaskIdResponse.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.resultTask = _instance.resultTask || [];
+        _instance.sessionId = _instance.sessionId || '';
+    }
+    /**
+     * 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 GetOwnerTaskIdResponse.MapResultTask();
+                    _reader.readMessage(messageInitializer1, GetOwnerTaskIdResponse.MapResultTask.deserializeBinaryFromReader);
+                    (_instance.resultTask = _instance.resultTask || []).push(messageInitializer1);
+                    break;
+                case 2:
+                    _instance.sessionId = _reader.readString();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        GetOwnerTaskIdResponse.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.resultTask && _instance.resultTask.length) {
+            _writer.writeRepeatedMessage(1, _instance.resultTask, GetOwnerTaskIdResponse.MapResultTask.serializeBinaryToWriter);
+        }
+        if (_instance.sessionId) {
+            _writer.writeString(2, _instance.sessionId);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of GetOwnerTaskIdResponse to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.resultTask = (_value.resultTask || []).map(m => new GetOwnerTaskIdResponse.MapResultTask(m));
+        this.sessionId = _value.sessionId;
+        GetOwnerTaskIdResponse.refineValues(this);
+    }
+    get resultTask() {
+        return this._resultTask;
+    }
+    set resultTask(value) {
+        this._resultTask = value;
+    }
+    get sessionId() {
+        return this._sessionId;
+    }
+    set sessionId(value) {
+        this._sessionId = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        GetOwnerTaskIdResponse.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            resultTask: (this.resultTask || []).map(m => m.toObject()),
+            sessionId: this.sessionId
+        };
+    }
+    /**
+     * 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 {
+            resultTask: (this.resultTask || []).map(m => m.toProtobufJSON(options)),
+            sessionId: this.sessionId
+        };
+    }
+}
+GetOwnerTaskIdResponse.id = 'armonik.api.grpc.v1.results.GetOwnerTaskIdResponse';
+(function (GetOwnerTaskIdResponse) {
+    /**
+     * Message implementation for armonik.api.grpc.v1.results.GetOwnerTaskIdResponse.MapResultTask
+     */
+    class MapResultTask {
+        /**
+         * Deserialize binary data to message
+         * @param instance message instance
+         */
+        static deserializeBinary(bytes) {
+            const instance = new MapResultTask();
+            MapResultTask.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.resultId = _instance.resultId || '';
+            _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.resultId = _reader.readString();
+                        break;
+                    case 2:
+                        _instance.taskId = _reader.readString();
+                        break;
+                    default:
+                        _reader.skipField();
+                }
+            }
+            MapResultTask.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.resultId) {
+                _writer.writeString(1, _instance.resultId);
+            }
+            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 MapResultTask to deeply clone from
+         */
+        constructor(_value) {
+            _value = _value || {};
+            this.resultId = _value.resultId;
+            this.taskId = _value.taskId;
+            MapResultTask.refineValues(this);
+        }
+        get resultId() {
+            return this._resultId;
+        }
+        set resultId(value) {
+            this._resultId = 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();
+            MapResultTask.serializeBinaryToWriter(this, writer);
+            return writer.getResultBuffer();
+        }
+        /**
+         * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+         */
+        toObject() {
+            return {
+                resultId: this.resultId,
+                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 {
+                resultId: this.resultId,
+                taskId: this.taskId
+            };
+        }
+    }
+    MapResultTask.id = 'armonik.api.grpc.v1.results.GetOwnerTaskIdResponse.MapResultTask';
+    GetOwnerTaskIdResponse.MapResultTask = MapResultTask;
+})(GetOwnerTaskIdResponse || (GetOwnerTaskIdResponse = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"results-common.pb.js","sourceRoot":"","sources":["../../../../../../projects/aneoconsultingfr/armonik.api.angular/src/lib/generated/results-common.pb.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,YAAY,EAAE,YAAY,EAAc,MAAM,iBAAiB,CAAC;AACzE,OAAO,KAAK,iBAAiB,MAAM,4BAA4B,CAAC;AAChE,OAAO,KAAK,gCAAgC,MAAM,oBAAoB,CAAC;AACvE;;GAEG;AACH,MAAM,OAAO,SAAS;IAGpB;;;OAGG;IACH,MAAM,CAAC,iBAAiB,CAAC,KAAiB;QACxC,MAAM,QAAQ,GAAG,IAAI,SAAS,EAAE,CAAC;QACjC,SAAS,CAAC,2BAA2B,CAAC,QAAQ,EAAE,IAAI,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC;QACzE,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,YAAY,CAAC,SAAoB;QACtC,SAAS,CAAC,SAAS,GAAG,SAAS,CAAC,SAAS,IAAI,EAAE,CAAC;QAChD,SAAS,CAAC,IAAI,GAAG,SAAS,CAAC,IAAI,IAAI,EAAE,CAAC;QACtC,SAAS,CAAC,WAAW,GAAG,SAAS,CAAC,WAAW,IAAI,EAAE,CAAC;QACpD,SAAS,CAAC,MAAM,GAAG,SAAS,CAAC,MAAM,IAAI,CAAC,CAAC;QACzC,SAAS,CAAC,SAAS,GAAG,SAAS,CAAC,SAAS,IAAI,SAAS,CAAC;IACzD,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,2BAA2B,CAChC,SAAoB,EACpB,OAAqB;QAErB,OAAO,OAAO,CAAC,SAAS,EAAE,EAAE;YAC1B,IAAI,OAAO,CAAC,UAAU,EAAE;gBAAE,MAAM;YAEhC,QAAQ,OAAO,CAAC,cAAc,EAAE,EAAE;gBAChC,KAAK,CAAC;oBACJ,SAAS,CAAC,SAAS,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;oBAC3C,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,IAAI,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;oBACtC,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,WAAW,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;oBAC7C,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,MAAM,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC;oBACtC,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,SAAS,GAAG,IAAI,iBAAiB,CAAC,SAAS,EAAE,CAAC;oBACxD,OAAO,CAAC,WAAW,CACjB,SAAS,CAAC,SAAS,EACnB,iBAAiB,CAAC,SAAS,CAAC,2BAA2B,CACxD,CAAC;oBACF,MAAM;gBACR;oBACE,OAAO,CAAC,SAAS,EAAE,CAAC;aACvB;SACF;QAED,SAAS,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;IACpC,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,uBAAuB,CAAC,SAAoB,EAAE,OAAqB;QACxE,IAAI,SAAS,CAAC,SAAS,EAAE;YACvB,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC;SAC7C;QACD,IAAI,SAAS,CAAC,IAAI,EAAE;YAClB,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC;SACxC;QACD,IAAI,SAAS,CAAC,WAAW,EAAE;YACzB,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,SAAS,CAAC,WAAW,CAAC,CAAC;SAC/C;QACD,IAAI,SAAS,CAAC,MAAM,EAAE;YACpB,OAAO,CAAC,SAAS,CAAC,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;SACxC;QACD,IAAI,SAAS,CAAC,SAAS,EAAE;YACvB,OAAO,CAAC,YAAY,CAClB,CAAC,EACD,SAAS,CAAC,SAAgB,EAC1B,iBAAiB,CAAC,SAAS,CAAC,uBAAuB,CACpD,CAAC;SACH;IACH,CAAC;IAQD;;;OAGG;IACH,YAAY,MAA6C;QACvD,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;QACtB,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC,SAAS,CAAC;QAClC,IAAI,CAAC,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC;QACxB,IAAI,CAAC,WAAW,GAAG,MAAM,CAAC,WAAW,CAAC;QACtC,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;QAC5B,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC,SAAS;YAC/B,CAAC,CAAC,IAAI,iBAAiB,CAAC,SAAS,CAAC,MAAM,CAAC,SAAS,CAAC;YACnD,CAAC,CAAC,SAAS,CAAC;QACd,SAAS,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IAC/B,CAAC;IACD,IAAI,SAAS;QACX,OAAO,IAAI,CAAC,UAAU,CAAC;IACzB,CAAC;IACD,IAAI,SAAS,CAAC,KAAa;QACzB,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;IAC1B,CAAC;IACD,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IACD,IAAI,IAAI,CAAC,KAAa;QACpB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACrB,CAAC;IACD,IAAI,WAAW;QACb,OAAO,IAAI,CAAC,YAAY,CAAC;IAC3B,CAAC;IACD,IAAI,WAAW,CAAC,KAAa;QAC3B,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC;IAC5B,CAAC;IACD,IAAI,MAAM;QACR,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IACD,IAAI,MAAM,CAAC,KAAoD;QAC7D,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;IACvB,CAAC;IACD,IAAI,SAAS;QACX,OAAO,IAAI,CAAC,UAAU,CAAC;IACzB,CAAC;IACD,IAAI,SAAS,CAAC,KAA8C;QAC1D,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;IAC1B,CAAC;IAED;;;OAGG;IACH,eAAe;QACb,MAAM,MAAM,GAAG,IAAI,YAAY,EAAE,CAAC;QAClC,SAAS,CAAC,uBAAuB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QAChD,OAAO,MAAM,CAAC,eAAe,EAAE,CAAC;IAClC,CAAC;IAED;;OAEG;IACH,QAAQ;QACN,OAAO;YACL,SAAS,EAAE,IAAI,CAAC,SAAS;YACzB,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,SAAS,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,SAAS;SAClE,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,MAAM;QACJ,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC;IACzB,CAAC;IAED;;;;OAIG;IACH,cAAc;IACZ,aAAa;IACb,OAA+B;QAE/B,OAAO;YACL,SAAS,EAAE,IAAI,CAAC,SAAS;YACzB,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,MAAM,EACJ,gCAAgC,CAAC,YAAY,CAC3C,IAAI,CAAC,MAAM,KAAK,IAAI,IAAI,IAAI,CAAC,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CACpE;YACH,SAAS,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI;SAC1E,CAAC;IACJ,CAAC;;AAhMM,YAAE,GAAG,uCAAuC,CAAC;AA0NtD;;GAEG;AACH,MAAM,OAAO,kBAAkB;IAG7B;;;OAGG;IACH,MAAM,CAAC,iBAAiB,CAAC,KAAiB;QACxC,MAAM,QAAQ,GAAG,IAAI,kBAAkB,EAAE,CAAC;QAC1C,kBAAkB,CAAC,2BAA2B,CAC5C,QAAQ,EACR,IAAI,YAAY,CAAC,KAAK,CAAC,CACxB,CAAC;QACF,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,YAAY,CAAC,SAA6B;QAC/C,SAAS,CAAC,IAAI,GAAG,SAAS,CAAC,IAAI,IAAI,CAAC,CAAC;QACrC,SAAS,CAAC,QAAQ,GAAG,SAAS,CAAC,QAAQ,IAAI,CAAC,CAAC;QAC7C,SAAS,CAAC,MAAM,GAAG,SAAS,CAAC,MAAM,IAAI,SAAS,CAAC;QACjD,SAAS,CAAC,IAAI,GAAG,SAAS,CAAC,IAAI,IAAI,SAAS,CAAC;IAC/C,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,2BAA2B,CAChC,SAA6B,EAC7B,OAAqB;QAErB,OAAO,OAAO,CAAC,SAAS,EAAE,EAAE;YAC1B,IAAI,OAAO,CAAC,UAAU,EAAE;gBAAE,MAAM;YAEhC,QAAQ,OAAO,CAAC,cAAc,EAAE,EAAE;gBAChC,KAAK,CAAC;oBACJ,SAAS,CAAC,IAAI,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;oBACrC,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,QAAQ,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;oBACzC,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,MAAM,GAAG,IAAI,kBAAkB,CAAC,MAAM,EAAE,CAAC;oBACnD,OAAO,CAAC,WAAW,CACjB,SAAS,CAAC,MAAM,EAChB,kBAAkB,CAAC,MAAM,CAAC,2BAA2B,CACtD,CAAC;oBACF,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,IAAI,GAAG,IAAI,kBAAkB,CAAC,IAAI,EAAE,CAAC;oBAC/C,OAAO,CAAC,WAAW,CACjB,SAAS,CAAC,IAAI,EACd,kBAAkB,CAAC,IAAI,CAAC,2BAA2B,CACpD,CAAC;oBACF,MAAM;gBACR;oBACE,OAAO,CAAC,SAAS,EAAE,CAAC;aACvB;SACF;QAED,kBAAkB,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;IAC7C,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,uBAAuB,CAC5B,SAA6B,EAC7B,OAAqB;QAErB,IAAI,SAAS,CAAC,IAAI,EAAE;YAClB,OAAO,CAAC,UAAU,CAAC,CAAC,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC;SACvC;QACD,IAAI,SAAS,CAAC,QAAQ,EAAE;YACtB,OAAO,CAAC,UAAU,CAAC,CAAC,EAAE,SAAS,CAAC,QAAQ,CAAC,CAAC;SAC3C;QACD,IAAI,SAAS,CAAC,MAAM,EAAE;YACpB,OAAO,CAAC,YAAY,CAClB,CAAC,EACD,SAAS,CAAC,MAAa,EACvB,kBAAkB,CAAC,MAAM,CAAC,uBAAuB,CAClD,CAAC;SACH;QACD,IAAI,SAAS,CAAC,IAAI,EAAE;YAClB,OAAO,CAAC,YAAY,CAClB,CAAC,EACD,SAAS,CAAC,IAAW,EACrB,kBAAkB,CAAC,IAAI,CAAC,uBAAuB,CAChD,CAAC;SACH;IACH,CAAC;IAOD;;;OAGG;IACH,YAAY,MAAsD;QAChE,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;QACtB,IAAI,CAAC,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC;QACxB,IAAI,CAAC,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC;QAChC,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM;YACzB,CAAC,CAAC,IAAI,kBAAkB,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC;YAC9C,CAAC,CAAC,SAAS,CAAC;QACd,IAAI,CAAC,IAAI,GAAG,MAAM,CAAC,IAAI;YACrB,CAAC,CAAC,IAAI,kBAAkB,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC;YAC1C,CAAC,CAAC,SAAS,CAAC;QACd,kBAAkB,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IACxC,CAAC;IACD,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IACD,IAAI,IAAI,CAAC,KAAa;QACpB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACrB,CAAC;IACD,IAAI,QAAQ;QACV,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IACD,IAAI,QAAQ,CAAC,KAAa;QACxB,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;IACzB,CAAC;IACD,IAAI,MAAM;QACR,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IACD,IAAI,MAAM,CAAC,KAA4C;QACrD,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;IACvB,CAAC;IACD,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IACD,IAAI,IAAI,CAAC,KAA0C;QACjD,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACrB,CAAC;IAED;;;OAGG;IACH,eAAe;QACb,MAAM,MAAM,GAAG,IAAI,YAAY,EAAE,CAAC;QAClC,kBAAkB,CAAC,uBAAuB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QACzD,OAAO,MAAM,CAAC,eAAe,EAAE,CAAC;IAClC,CAAC;IAED;;OAEG;IACH,QAAQ;QACN,OAAO;YACL,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,QAAQ,EAAE,IAAI,CAAC,QAAQ;YACvB,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,SAAS;YACxD,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,SAAS;SACnD,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,MAAM;QACJ,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC;IACzB,CAAC;IAED;;;;OAIG;IACH,cAAc;IACZ,aAAa;IACb,OAA+B;QAE/B,OAAO;YACL,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,QAAQ,EAAE,IAAI,CAAC,QAAQ;YACvB,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI;YAChE,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI;SAC3D,CAAC;IACJ,CAAC;;AA5LM,qBAAE,GAAG,gDAAgD,CAAC;AA8L/D,WAAc,kBAAkB;IAoB9B,IAAY,YAOX;IAPD,WAAY,YAAY;QACtB,2FAA8B,CAAA;QAC9B,yFAA6B,CAAA;QAC7B,6EAAuB,CAAA;QACvB,+FAAgC,CAAA;QAChC,iFAAyB,CAAA;QACzB,yFAA6B,CAAA;IAC/B,CAAC,EAPW,YAAY,GAAZ,+BAAY,KAAZ,+BAAY,QAOvB;IACD,IAAY,cAIX;IAJD,WAAY,cAAc;QACxB,iGAA+B,CAAA;QAC/B,iFAAuB,CAAA;QACvB,mFAAwB,CAAA;IAC1B,CAAC,EAJW,cAAc,GAAd,iCAAc,KAAd,iCAAc,QAIzB;IACD;;OAEG;IACH,MAAa,MAAM;QAGjB;;;WAGG;QACH,MAAM,CAAC,iBAAiB,CAAC,KAAiB;YACxC,MAAM,QAAQ,GAAG,IAAI,MAAM,EAAE,CAAC;YAC9B,MAAM,CAAC,2BAA2B,CAAC,QAAQ,EAAE,IAAI,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC;YACtE,OAAO,QAAQ,CAAC;QAClB,CAAC;QAED;;;WAGG;QACH,MAAM,CAAC,YAAY,CAAC,SAAiB;YACnC,SAAS,CAAC,SAAS,GAAG,SAAS,CAAC,SAAS,IAAI,EAAE,CAAC;YAChD,SAAS,CAAC,IAAI,GAAG,SAAS,CAAC,IAAI,IAAI,EAAE,CAAC;YACtC,SAAS,CAAC,WAAW,GAAG,SAAS,CAAC,WAAW,IAAI,EAAE,CAAC;YACpD,SAAS,CAAC,MAAM,GAAG,SAAS,CAAC,MAAM,IAAI,CAAC,CAAC;YACzC,SAAS,CAAC,YAAY,GAAG,SAAS,CAAC,YAAY,IAAI,SAAS,CAAC;YAC7D,SAAS,CAAC,aAAa,GAAG,SAAS,CAAC,aAAa,IAAI,SAAS,CAAC;QACjE,CAAC;QAED;;;;WAIG;QACH,MAAM,CAAC,2BAA2B,CAChC,SAAiB,EACjB,OAAqB;YAErB,OAAO,OAAO,CAAC,SAAS,EAAE,EAAE;gBAC1B,IAAI,OAAO,CAAC,UAAU,EAAE;oBAAE,MAAM;gBAEhC,QAAQ,OAAO,CAAC,cAAc,EAAE,EAAE;oBAChC,KAAK,CAAC;wBACJ,SAAS,CAAC,SAAS,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;wBAC3C,MAAM;oBACR,KAAK,CAAC;wBACJ,SAAS,CAAC,IAAI,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;wBACtC,MAAM;oBACR,KAAK,CAAC;wBACJ,SAAS,CAAC,WAAW,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;wBAC7C,MAAM;oBACR,KAAK,CAAC;wBACJ,SAAS,CAAC,MAAM,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC;wBACtC,MAAM;oBACR,KAAK,CAAC;wBACJ,SAAS,CAAC,YAAY,GAAG,IAAI,iBAAiB,CAAC,SAAS,EAAE,CAAC;wBAC3D,OAAO,CAAC,WAAW,CACjB,SAAS,CAAC,YAAY,EACtB,iBAAiB,CAAC,SAAS,CAAC,2BAA2B,CACxD,CAAC;wBACF,MAAM;oBACR,KAAK,CAAC;wBACJ,SAAS,CAAC,aAAa,GAAG,IAAI,iBAAiB,CAAC,SAAS,EAAE,CAAC;wBAC5D,OAAO,CAAC,WAAW,CACjB,SAAS,CAAC,aAAa,EACvB,iBAAiB,CAAC,SAAS,CAAC,2BAA2B,CACxD,CAAC;wBACF,MAAM;oBACR;wBACE,OAAO,CAAC,SAAS,EAAE,CAAC;iBACvB;aACF;YAED,MAAM,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;QACjC,CAAC;QAED;;;;WAIG;QACH,MAAM,CAAC,uBAAuB,CAAC,SAAiB,EAAE,OAAqB;YACrE,IAAI,SAAS,CAAC,SAAS,EAAE;gBACvB,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC;aAC7C;YACD,IAAI,SAAS,CAAC,IAAI,EAAE;gBAClB,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC;aACxC;YACD,IAAI,SAAS,CAAC,WAAW,EAAE;gBACzB,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,SAAS,CAAC,WAAW,CAAC,CAAC;aAC/C;YACD,IAAI,SAAS,CAAC,MAAM,EAAE;gBACpB,OAAO,CAAC,SAAS,CAAC,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;aACxC;YACD,IAAI,SAAS,CAAC,YAAY,EAAE;gBAC1B,OAAO,CAAC,YAAY,CAClB,CAAC,EACD,SAAS,CAAC,YAAmB,EAC7B,iBAAiB,CAAC,SAAS,CAAC,uBAAuB,CACpD,CAAC;aACH;YACD,IAAI,SAAS,CAAC,aAAa,EAAE;gBAC3B,OAAO,CAAC,YAAY,CAClB,CAAC,EACD,SAAS,CAAC,aAAoB,EAC9B,iBAAiB,CAAC,SAAS,CAAC,uBAAuB,CACpD,CAAC;aACH;QACH,CAAC;QASD;;;WAGG;QACH,YAAY,MAA0C;YACpD,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;YACtB,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC,SAAS,CAAC;YAClC,IAAI,CAAC,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC;YACxB,IAAI,CAAC,WAAW,GAAG,MAAM,CAAC,WAAW,CAAC;YACtC,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;YAC5B,IAAI,CAAC,YAAY,GAAG,MAAM,CAAC,YAAY;gBACrC,CAAC,CAAC,IAAI,iBAAiB,CAAC,SAAS,CAAC,MAAM,CAAC,YAAY,CAAC;gBACtD,CAAC,CAAC,SAAS,CAAC;YACd,IAAI,CAAC,aAAa,GAAG,MAAM,CAAC,aAAa;gBACvC,CAAC,CAAC,IAAI,iBAAiB,CAAC,SAAS,CAAC,MAAM,CAAC,aAAa,CAAC;gBACvD,CAAC,CAAC,SAAS,CAAC;YACd,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;QAC5B,CAAC;QACD,IAAI,SAAS;YACX,OAAO,IAAI,CAAC,UAAU,CAAC;QACzB,CAAC;QACD,IAAI,SAAS,CAAC,KAAa;YACzB,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;QAC1B,CAAC;QACD,IAAI,IAAI;YACN,OAAO,IAAI,CAAC,KAAK,CAAC;QACpB,CAAC;QACD,IAAI,IAAI,CAAC,KAAa;YACpB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACrB,CAAC;QACD,IAAI,WAAW;YACb,OAAO,IAAI,CAAC,YAAY,CAAC;QAC3B,CAAC;QACD,IAAI,WAAW,CAAC,KAAa;YAC3B,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC;QAC5B,CAAC;QACD,IAAI,MAAM;YACR,OAAO,IAAI,CAAC,OAAO,CAAC;QACtB,CAAC;QACD,IAAI,MAAM,CAAC,KAAoD;YAC7D,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;QACvB,CAAC;QACD,IAAI,YAAY;YACd,OAAO,IAAI,CAAC,aAAa,CAAC;QAC5B,CAAC;QACD,IAAI,YAAY,CAAC,KAA8C;YAC7D,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC;QAC7B,CAAC;QACD,IAAI,aAAa;YACf,OAAO,IAAI,CAAC,cAAc,CAAC;QAC7B,CAAC;QACD,IAAI,aAAa,CAAC,KAA8C;YAC9D,IAAI,CAAC,cAAc,GAAG,KAAK,CAAC;QAC9B,CAAC;QAED;;;WAGG;QACH,eAAe;YACb,MAAM,MAAM,GAAG,IAAI,YAAY,EAAE,CAAC;YAClC,MAAM,CAAC,uBAAuB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;YAC7C,OAAO,MAAM,CAAC,eAAe,EAAE,CAAC;QAClC,CAAC;QAED;;WAEG;QACH,QAAQ;YACN,OAAO;gBACL,SAAS,EAAE,IAAI,CAAC,SAAS;gBACzB,IAAI,EAAE,IAAI,CAAC,IAAI;gBACf,WAAW,EAAE,IAAI,CAAC,WAAW;gBAC7B,MAAM,EAAE,IAAI,CAAC,MAAM;gBACnB,YAAY,EAAE,IAAI,CAAC,YAAY;oBAC7B,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,QAAQ,EAAE;oBAC9B,CAAC,CAAC,SAAS;gBACb,aAAa,EAAE,IAAI,CAAC,aAAa;oBAC/B,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE;oBAC/B,CAAC,CAAC,SAAS;aACd,CAAC;QACJ,CAAC;QAED;;WAEG;QACH,MAAM;YACJ,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC;QACzB,CAAC;QAED;;;;WAIG;QACH,cAAc;QACZ,aAAa;QACb,OAA+B;YAE/B,OAAO;gBACL,SAAS,EAAE,IAAI,CAAC,SAAS;gBACzB,IAAI,EAAE,IAAI,CAAC,IAAI;gBACf,WAAW,EAAE,IAAI,CAAC,WAAW;gBAC7B,MAAM,EACJ,gCAAgC,CAAC,YAAY,CAC3C,IAAI,CAAC,MAAM,KAAK,IAAI,IAAI,IAAI,CAAC,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CACpE;gBACH,YAAY,EAAE,IAAI,CAAC,YAAY;oBAC7B,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,cAAc,CAAC,OAAO,CAAC;oBAC3C,CAAC,CAAC,IAAI;gBACR,aAAa,EAAE,IAAI,CAAC,aAAa;oBAC/B,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC,OAAO,CAAC;oBAC5C,CAAC,CAAC,IAAI;aACT,CAAC;QACJ,CAAC;;IAnOM,SAAE,GAAG,uDAAuD,CAAC;IADzD,yBAAM,SAqOlB,CAAA;IA2BD;;OAEG;IACH,MAAa,IAAI;QAGf;;;WAGG;QACH,MAAM,CAAC,iBAAiB,CAAC,KAAiB;YACxC,MAAM,QAAQ,GAAG,IAAI,IAAI,EAAE,CAAC;YAC5B,IAAI,CAAC,2BAA2B,CAAC,QAAQ,EAAE,IAAI,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC;YACpE,OAAO,QAAQ,CAAC;QAClB,CAAC;QAED;;;WAGG;QACH,MAAM,CAAC,YAAY,CAAC,SAAe;YACjC,SAAS,CAAC,KAAK,GAAG,SAAS,CAAC,KAAK,IAAI,CAAC,CAAC;YACvC,SAAS,CAAC,SAAS,GAAG,SAAS,CAAC,SAAS,IAAI,CAAC,CAAC;QACjD,CAAC;QAED;;;;WAIG;QACH,MAAM,CAAC,2BAA2B,CAAC,SAAe,EAAE,OAAqB;YACvE,OAAO,OAAO,CAAC,SAAS,EAAE,EAAE;gBAC1B,IAAI,OAAO,CAAC,UAAU,EAAE;oBAAE,MAAM;gBAEhC,QAAQ,OAAO,CAAC,cAAc,EAAE,EAAE;oBAChC,KAAK,CAAC;wBACJ,SAAS,CAAC,KAAK,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC;wBACrC,MAAM;oBACR,KAAK,CAAC;wBACJ,SAAS,CAAC,SAAS,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC;wBACzC,MAAM;oBACR;wBACE,OAAO,CAAC,SAAS,EAAE,CAAC;iBACvB;aACF;YAED,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;QAC/B,CAAC;QAED;;;;WAIG;QACH,MAAM,CAAC,uBAAuB,CAAC,SAAe,EAAE,OAAqB;YACnE,IAAI,SAAS,CAAC,KAAK,EAAE;gBACnB,OAAO,CAAC,SAAS,CAAC,CAAC,EAAE,SAAS,CAAC,KAAK,CAAC,CAAC;aACvC;YACD,IAAI,SAAS,CAAC,SAAS,EAAE;gBACvB,OAAO,CAAC,SAAS,CAAC,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC;aAC3C;QACH,CAAC;QAKD;;;WAGG;QACH,YAAY,MAAwC;YAClD,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;YACtB,IAAI,CAAC,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;YAC1B,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC,SAAS,CAAC;YAClC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;QAC1B,CAAC;QACD,IAAI,KAAK;YACP,OAAO,IAAI,CAAC,MAAM,CAAC;QACrB,CAAC;QACD,IAAI,KAAK,CAAC,KAAsC;YAC9C,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;QACtB,CAAC;QACD,IAAI,SAAS;YACX,OAAO,IAAI,CAAC,UAAU,CAAC;QACzB,CAAC;QACD,IAAI,SAAS,CAAC,KAAwC;YACpD,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;QAC1B,CAAC;QAED;;;WAGG;QACH,eAAe;YACb,MAAM,MAAM,GAAG,IAAI,YAAY,EAAE,CAAC;YAClC,IAAI,CAAC,uBAAuB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;YAC3C,OAAO,MAAM,CAAC,eAAe,EAAE,CAAC;QAClC,CAAC;QAED;;WAEG;QACH,QAAQ;YACN,OAAO;gBACL,KAAK,EAAE,IAAI,CAAC,KAAK;gBACjB,SAAS,EAAE,IAAI,CAAC,SAAS;aAC1B,CAAC;QACJ,CAAC;QAED;;WAEG;QACH,MAAM;YACJ,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC;QACzB,CAAC;QAED;;;;WAIG;QACH,cAAc;QACZ,aAAa;QACb,OAA+B;YAE/B,OAAO;gBACL,KAAK,EACH,kBAAkB,CAAC,YAAY,CAC7B,IAAI,CAAC,KAAK,KAAK,IAAI,IAAI,IAAI,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CACjE;gBACH,SAAS,EACP,kBAAkB,CAAC,cAAc,CAC/B,IAAI,CAAC,SAAS,KAAK,IAAI,IAAI,IAAI,CAAC,SAAS,KAAK,SAAS;oBACrD,CAAC,CAAC,CAAC;oBACH,CAAC,CAAC,IAAI,CAAC,SAAS,CACnB;aACJ,CAAC;QACJ,CAAC;;IArIM,OAAE,GAAG,qDAAqD,CAAC;IADvD,uBAAI,OAuIhB,CAAA;AAkBH,CAAC,EAhca,kBAAkB,KAAlB,kBAAkB,QAgc/B;AAED;;GAEG;AACH,MAAM,OAAO,mBAAmB;IAG9B;;;OAGG;IACH,MAAM,CAAC,iBAAiB,CAAC,KAAiB;QACxC,MAAM,QAAQ,GAAG,IAAI,mBAAmB,EAAE,CAAC;QAC3C,mBAAmB,CAAC,2BAA2B,CAC7C,QAAQ,EACR,IAAI,YAAY,CAAC,KAAK,CAAC,CACxB,CAAC;QACF,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,YAAY,CAAC,SAA8B;QAChD,SAAS,CAAC,OAAO,GAAG,SAAS,CAAC,OAAO,IAAI,EAAE,CAAC;QAC5C,SAAS,CAAC,IAAI,GAAG,SAAS,CAAC,IAAI,IAAI,CAAC,CAAC;QACrC,SAAS,CAAC,QAAQ,GAAG,SAAS,CAAC,QAAQ,IAAI,CAAC,CAAC;QAC7C,SAAS,CAAC,KAAK,GAAG,SAAS,CAAC,KAAK,IAAI,CAAC,CAAC;IACzC,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,2BAA2B,CAChC,SAA8B,EAC9B,OAAqB;QAErB,OAAO,OAAO,CAAC,SAAS,EAAE,EAAE;YAC1B,IAAI,OAAO,CAAC,UAAU,EAAE;gBAAE,MAAM;YAEhC,QAAQ,OAAO,CAAC,cAAc,EAAE,EAAE;gBAChC,KAAK,CAAC;oBACJ,MAAM,mBAAmB,GAAG,IAAI,SAAS,EAAE,CAAC;oBAC5C,OAAO,CAAC,WAAW,CACjB,mBAAmB,EACnB,SAAS,CAAC,2BAA2B,CACtC,CAAC;oBACF,CAAC,SAAS,CAAC,OAAO,GAAG,SAAS,CAAC,OAAO,IAAI,EAAE,CAAC,CAAC,IAAI,CAChD,mBAAmB,CACpB,CAAC;oBACF,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,IAAI,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;oBACrC,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,QAAQ,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;oBACzC,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,KAAK,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;oBACtC,MAAM;gBACR;oBACE,OAAO,CAAC,SAAS,EAAE,CAAC;aACvB;SACF;QAED,mBAAmB,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;IAC9C,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,uBAAuB,CAC5B,SAA8B,EAC9B,OAAqB;QAErB,IAAI,SAAS,CAAC,OAAO,IAAI,SAAS,CAAC,OAAO,CAAC,MAAM,EAAE;YACjD,OAAO,CAAC,oBAAoB,CAC1B,CAAC,EACD,SAAS,CAAC,OAAc,EACxB,SAAS,CAAC,uBAAuB,CAClC,CAAC;SACH;QACD,IAAI,SAAS,CAAC,IAAI,EAAE;YAClB,OAAO,CAAC,UAAU,CAAC,CAAC,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC;SACvC;QACD,IAAI,SAAS,CAAC,QAAQ,EAAE;YACtB,OAAO,CAAC,UAAU,CAAC,CAAC,EAAE,SAAS,CAAC,QAAQ,CAAC,CAAC;SAC3C;QACD,IAAI,SAAS,CAAC,KAAK,EAAE;YACnB,OAAO,CAAC,UAAU,CAAC,CAAC,EAAE,SAAS,CAAC,KAAK,CAAC,CAAC;SACxC;IACH,CAAC;IAOD;;;OAGG;IACH,YAAY,MAAuD;QACjE,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;QACtB,IAAI,CAAC,OAAO,GAAG,CAAC,MAAM,CAAC,OAAO,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;QACjE,IAAI,CAAC,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC;QACxB,IAAI,CAAC,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC;QAChC,IAAI,CAAC,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;QAC1B,mBAAmB,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IACzC,CAAC;IACD,IAAI,OAAO;QACT,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;IACD,IAAI,OAAO,CAAC,KAA8B;QACxC,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;IACxB,CAAC;IACD,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IACD,IAAI,IAAI,CAAC,KAAa;QACpB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACrB,CAAC;IACD,IAAI,QAAQ;QACV,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IACD,IAAI,QAAQ,CAAC,KAAa;QACxB,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;IACzB,CAAC;IACD,IAAI,KAAK;QACP,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IACD,IAAI,KAAK,CAAC,KAAa;QACrB,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;IACtB,CAAC;IAED;;;OAGG;IACH,eAAe;QACb,MAAM,MAAM,GAAG,IAAI,YAAY,EAAE,CAAC;QAClC,mBAAmB,CAAC,uBAAuB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QAC1D,OAAO,MAAM,CAAC,eAAe,EAAE,CAAC;IAClC,CAAC;IAED;;OAEG;IACH,QAAQ;QACN,OAAO;YACL,OAAO,EAAE,CAAC,IAAI,CAAC,OAAO,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC;YACpD,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,QAAQ,EAAE,IAAI,CAAC,QAAQ;YACvB,KAAK,EAAE,IAAI,CAAC,KAAK;SAClB,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,MAAM;QACJ,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC;IACzB,CAAC;IAED;;;;OAIG;IACH,cAAc;IACZ,aAAa;IACb,OAA+B;QAE/B,OAAO;YACL,OAAO,EAAE,CAAC,IAAI,CAAC,OAAO,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;YACjE,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,QAAQ,EAAE,IAAI,CAAC,QAAQ;YACvB,KAAK,EAAE,IAAI,CAAC,KAAK;SAClB,CAAC;IACJ,CAAC;;AAnLM,sBAAE,GAAG,iDAAiD,CAAC;AA2MhE;;GAEG;AACH,MAAM,OAAO,qBAAqB;IAGhC;;;OAGG;IACH,MAAM,CAAC,iBAAiB,CAAC,KAAiB;QACxC,MAAM,QAAQ,GAAG,IAAI,qBAAqB,EAAE,CAAC;QAC7C,qBAAqB,CAAC,2BAA2B,CAC/C,QAAQ,EACR,IAAI,YAAY,CAAC,KAAK,CAAC,CACxB,CAAC;QACF,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,YAAY,CAAC,SAAgC;QAClD,SAAS,CAAC,SAAS,GAAG,SAAS,CAAC,SAAS,IAAI,EAAE,CAAC;QAChD,SAAS,CAAC,QAAQ,GAAG,SAAS,CAAC,QAAQ,IAAI,EAAE,CAAC;IAChD,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,2BAA2B,CAChC,SAAgC,EAChC,OAAqB;QAErB,OAAO,OAAO,CAAC,SAAS,EAAE,EAAE;YAC1B,IAAI,OAAO,CAAC,UAAU,EAAE;gBAAE,MAAM;YAEhC,QAAQ,OAAO,CAAC,cAAc,EAAE,EAAE;gBAChC,KAAK,CAAC;oBACJ,SAAS,CAAC,SAAS,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;oBAC3C,MAAM;gBACR,KAAK,CAAC;oBACJ,CAAC,SAAS,CAAC,QAAQ,GAAG,SAAS,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAC,IAAI,CAClD,OAAO,CAAC,UAAU,EAAE,CACrB,CAAC;oBACF,MAAM;gBACR;oBACE,OAAO,CAAC,SAAS,EAAE,CAAC;aACvB;SACF;QAED,qBAAqB,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;IAChD,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,uBAAuB,CAC5B,SAAgC,EAChC,OAAqB;QAErB,IAAI,SAAS,CAAC,SAAS,EAAE;YACvB,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC;SAC7C;QACD,IAAI,SAAS,CAAC,QAAQ,IAAI,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE;YACnD,OAAO,CAAC,mBAAmB,CAAC,CAAC,EAAE,SAAS,CAAC,QAAQ,CAAC,CAAC;SACpD;IACH,CAAC;IAKD;;;OAGG;IACH,YAAY,MAAyD;QACnE,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;QACtB,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC,SAAS,CAAC;QAClC,IAAI,CAAC,QAAQ,GAAG,CAAC,MAAM,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC;QAChD,qBAAqB,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IAC3C,CAAC;IACD,IAAI,SAAS;QACX,OAAO,IAAI,CAAC,UAAU,CAAC;IACzB,CAAC;IACD,IAAI,SAAS,CAAC,KAAa;QACzB,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;IAC1B,CAAC;IACD,IAAI,QAAQ;QACV,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IACD,IAAI,QAAQ,CAAC,KAAe;QAC1B,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;IACzB,CAAC;IAED;;;OAGG;IACH,eAAe;QACb,MAAM,MAAM,GAAG,IAAI,YAAY,EAAE,CAAC;QAClC,qBAAqB,CAAC,uBAAuB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QAC5D,OAAO,MAAM,CAAC,eAAe,EAAE,CAAC;IAClC,CAAC;IAED;;OAEG;IACH,QAAQ;QACN,OAAO;YACL,SAAS,EAAE,IAAI,CAAC,SAAS;YACzB,QAAQ,EAAE,CAAC,IAAI,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAC,KAAK,EAAE;SACxC,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,MAAM;QACJ,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC;IACzB,CAAC;IAED;;;;OAIG;IACH,cAAc;IACZ,aAAa;IACb,OAA+B;QAE/B,OAAO;YACL,SAAS,EAAE,IAAI,CAAC,SAAS;YACzB,QAAQ,EAAE,CAAC,IAAI,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAC,KAAK,EAAE;SACxC,CAAC;IACJ,CAAC;;AAxIM,wBAAE,GAAG,mDAAmD,CAAC;AA4JlE;;GAEG;AACH,MAAM,OAAO,sBAAsB;IAGjC;;;OAGG;IACH,MAAM,CAAC,iBAAiB,CAAC,KAAiB;QACxC,MAAM,QAAQ,GAAG,IAAI,sBAAsB,EAAE,CAAC;QAC9C,sBAAsB,CAAC,2BAA2B,CAChD,QAAQ,EACR,IAAI,YAAY,CAAC,KAAK,CAAC,CACxB,CAAC;QACF,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,YAAY,CAAC,SAAiC;QACnD,SAAS,CAAC,UAAU,GAAG,SAAS,CAAC,UAAU,IAAI,EAAE,CAAC;QAClD,SAAS,CAAC,SAAS,GAAG,SAAS,CAAC,SAAS,IAAI,EAAE,CAAC;IAClD,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,2BAA2B,CAChC,SAAiC,EACjC,OAAqB;QAErB,OAAO,OAAO,CAAC,SAAS,EAAE,EAAE;YAC1B,IAAI,OAAO,CAAC,UAAU,EAAE;gBAAE,MAAM;YAEhC,QAAQ,OAAO,CAAC,cAAc,EAAE,EAAE;gBAChC,KAAK,CAAC;oBACJ,MAAM,mBAAmB,GAAG,IAAI,sBAAsB,CAAC,aAAa,EAAE,CAAC;oBACvE,OAAO,CAAC,WAAW,CACjB,mBAAmB,EACnB,sBAAsB,CAAC,aAAa,CAAC,2BAA2B,CACjE,CAAC;oBACF,CAAC,SAAS,CAAC,UAAU,GAAG,SAAS,CAAC,UAAU,IAAI,EAAE,CAAC,CAAC,IAAI,CACtD,mBAAmB,CACpB,CAAC;oBACF,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,SAAS,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;oBAC3C,MAAM;gBACR;oBACE,OAAO,CAAC,SAAS,EAAE,CAAC;aACvB;SACF;QAED,sBAAsB,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;IACjD,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,uBAAuB,CAC5B,SAAiC,EACjC,OAAqB;QAErB,IAAI,SAAS,CAAC,UAAU,IAAI,SAAS,CAAC,UAAU,CAAC,MAAM,EAAE;YACvD,OAAO,CAAC,oBAAoB,CAC1B,CAAC,EACD,SAAS,CAAC,UAAiB,EAC3B,sBAAsB,CAAC,aAAa,CAAC,uBAAuB,CAC7D,CAAC;SACH;QACD,IAAI,SAAS,CAAC,SAAS,EAAE;YACvB,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC;SAC7C;IACH,CAAC;IAKD;;;OAGG;IACH,YAAY,MAA0D;QACpE,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;QACtB,IAAI,CAAC,UAAU,GAAG,CAAC,MAAM,CAAC,UAAU,IAAI,EAAE,CAAC,CAAC,GAAG,CAC7C,CAAC,CAAC,EAAE,CAAC,IAAI,sBAAsB,CAAC,aAAa,CAAC,CAAC,CAAC,CACjD,CAAC;QACF,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC,SAAS,CAAC;QAClC,sBAAsB,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IAC5C,CAAC;IACD,IAAI,UAAU;QACZ,OAAO,IAAI,CAAC,WAAW,CAAC;IAC1B,CAAC;IACD,IAAI,UAAU,CAAC,KAAyD;QACtE,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC;IAC3B,CAAC;IACD,IAAI,SAAS;QACX,OAAO,IAAI,CAAC,UAAU,CAAC;IACzB,CAAC;IACD,IAAI,SAAS,CAAC,KAAa;QACzB,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;IAC1B,CAAC;IAED;;;OAGG;IACH,eAAe;QACb,MAAM,MAAM,GAAG,IAAI,YAAY,EAAE,CAAC;QAClC,sBAAsB,CAAC,uBAAuB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QAC7D,OAAO,MAAM,CAAC,eAAe,EAAE,CAAC;IAClC,CAAC;IAED;;OAEG;IACH,QAAQ;QACN,OAAO;YACL,UAAU,EAAE,CAAC,IAAI,CAAC,UAAU,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC;YAC1D,SAAS,EAAE,IAAI,CAAC,SAAS;SAC1B,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,MAAM;QACJ,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC;IACzB,CAAC;IAED;;;;OAIG;IACH,cAAc;IACZ,aAAa;IACb,OAA+B;QAE/B,OAAO;YACL,UAAU,EAAE,CAAC,IAAI,CAAC,UAAU,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;YACvE,SAAS,EAAE,IAAI,CAAC,SAAS;SAC1B,CAAC;IACJ,CAAC;;AAnJM,yBAAE,GAAG,oDAAoD,CAAC;AAqJnE,WAAc,sBAAsB;IAiBlC;;OAEG;IACH,MAAa,aAAa;QAIxB;;;WAGG;QACH,MAAM,CAAC,iBAAiB,CAAC,KAAiB;YACxC,MAAM,QAAQ,GAAG,IAAI,aAAa,EAAE,CAAC;YACrC,aAAa,CAAC,2BAA2B,CACvC,QAAQ,EACR,IAAI,YAAY,CAAC,KAAK,CAAC,CACxB,CAAC;YACF,OAAO,QAAQ,CAAC;QAClB,CAAC;QAED;;;WAGG;QACH,MAAM,CAAC,YAAY,CAAC,SAAwB;YAC1C,SAAS,CAAC,QAAQ,GAAG,SAAS,CAAC,QAAQ,IAAI,EAAE,CAAC;YAC9C,SAAS,CAAC,MAAM,GAAG,SAAS,CAAC,MAAM,IAAI,EAAE,CAAC;QAC5C,CAAC;QAED;;;;WAIG;QACH,MAAM,CAAC,2BAA2B,CAChC,SAAwB,EACxB,OAAqB;YAErB,OAAO,OAAO,CAAC,SAAS,EAAE,EAAE;gBAC1B,IAAI,OAAO,CAAC,UAAU,EAAE;oBAAE,MAAM;gBAEhC,QAAQ,OAAO,CAAC,cAAc,EAAE,EAAE;oBAChC,KAAK,CAAC;wBACJ,SAAS,CAAC,QAAQ,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;wBAC1C,MAAM;oBACR,KAAK,CAAC;wBACJ,SAAS,CAAC,MAAM,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;wBACxC,MAAM;oBACR;wBACE,OAAO,CAAC,SAAS,EAAE,CAAC;iBACvB;aACF;YAED,aAAa,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;QACxC,CAAC;QAED;;;;WAIG;QACH,MAAM,CAAC,uBAAuB,CAC5B,SAAwB,EACxB,OAAqB;YAErB,IAAI,SAAS,CAAC,QAAQ,EAAE;gBACtB,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,SAAS,CAAC,QAAQ,CAAC,CAAC;aAC5C;YACD,IAAI,SAAS,CAAC,MAAM,EAAE;gBACpB,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;aAC1C;QACH,CAAC;QAKD;;;WAGG;QACH,YAAY,MAAiD;YAC3D,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;YACtB,IAAI,CAAC,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC;YAChC,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;YAC5B,aAAa,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;QACnC,CAAC;QACD,IAAI,QAAQ;YACV,OAAO,IAAI,CAAC,SAAS,CAAC;QACxB,CAAC;QACD,IAAI,QAAQ,CAAC,KAAa;YACxB,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;QACzB,CAAC;QACD,IAAI,MAAM;YACR,OAAO,IAAI,CAAC,OAAO,CAAC;QACtB,CAAC;QACD,IAAI,MAAM,CAAC,KAAa;YACtB,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;QACvB,CAAC;QAED;;;WAGG;QACH,eAAe;YACb,MAAM,MAAM,GAAG,IAAI,YAAY,EAAE,CAAC;YAClC,aAAa,CAAC,uBAAuB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;YACpD,OAAO,MAAM,CAAC,eAAe,EAAE,CAAC;QAClC,CAAC;QAED;;WAEG;QACH,QAAQ;YACN,OAAO;gBACL,QAAQ,EAAE,IAAI,CAAC,QAAQ;gBACvB,MAAM,EAAE,IAAI,CAAC,MAAM;aACpB,CAAC;QACJ,CAAC;QAED;;WAEG;QACH,MAAM;YACJ,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC;QACzB,CAAC;QAED;;;;WAIG;QACH,cAAc;QACZ,aAAa;QACb,OAA+B;YAE/B,OAAO;gBACL,QAAQ,EAAE,IAAI,CAAC,QAAQ;gBACvB,MAAM,EAAE,IAAI,CAAC,MAAM;aACpB,CAAC;QACJ,CAAC;;IAvIM,gBAAE,GACP,kEAAkE,CAAC;IAF1D,oCAAa,gBAyIzB,CAAA;AAkBH,CAAC,EA/Ka,sBAAsB,KAAtB,sBAAsB,QA+KnC","sourcesContent":["/* tslint:disable */\n/* eslint-disable */\n// @ts-nocheck\n//\n// THIS IS A GENERATED FILE\n// DO NOT MODIFY IT! YOUR CHANGES WILL BE LOST\nimport {\n  GrpcMessage,\n  RecursivePartial,\n  ToProtobufJSONOptions\n} from '@ngx-grpc/common';\nimport { BinaryReader, BinaryWriter, ByteSource } from 'google-protobuf';\nimport * as googleProtobuf000 from '@ngx-grpc/well-known-types';\nimport * as armonikApiGrpcV1Result_status001 from './result-status.pb';\n/**\n * Message implementation for armonik.api.grpc.v1.results.ResultRaw\n */\nexport class ResultRaw implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.results.ResultRaw';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new ResultRaw();\n    ResultRaw.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: ResultRaw) {\n    _instance.sessionId = _instance.sessionId || '';\n    _instance.name = _instance.name || '';\n    _instance.ownerTaskId = _instance.ownerTaskId || '';\n    _instance.status = _instance.status || 0;\n    _instance.createdAt = _instance.createdAt || undefined;\n  }\n\n  /**\n   * Deserializes / reads binary message into message instance using provided binary reader\n   * @param _instance message instance\n   * @param _reader binary reader instance\n   */\n  static deserializeBinaryFromReader(\n    _instance: ResultRaw,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.sessionId = _reader.readString();\n          break;\n        case 2:\n          _instance.name = _reader.readString();\n          break;\n        case 3:\n          _instance.ownerTaskId = _reader.readString();\n          break;\n        case 4:\n          _instance.status = _reader.readEnum();\n          break;\n        case 5:\n          _instance.createdAt = new googleProtobuf000.Timestamp();\n          _reader.readMessage(\n            _instance.createdAt,\n            googleProtobuf000.Timestamp.deserializeBinaryFromReader\n          );\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    ResultRaw.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: ResultRaw, _writer: BinaryWriter) {\n    if (_instance.sessionId) {\n      _writer.writeString(1, _instance.sessionId);\n    }\n    if (_instance.name) {\n      _writer.writeString(2, _instance.name);\n    }\n    if (_instance.ownerTaskId) {\n      _writer.writeString(3, _instance.ownerTaskId);\n    }\n    if (_instance.status) {\n      _writer.writeEnum(4, _instance.status);\n    }\n    if (_instance.createdAt) {\n      _writer.writeMessage(\n        5,\n        _instance.createdAt as any,\n        googleProtobuf000.Timestamp.serializeBinaryToWriter\n      );\n    }\n  }\n\n  private _sessionId: string;\n  private _name: string;\n  private _ownerTaskId: string;\n  private _status: armonikApiGrpcV1Result_status001.ResultStatus;\n  private _createdAt?: googleProtobuf000.Timestamp;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of ResultRaw to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<ResultRaw.AsObject>) {\n    _value = _value || {};\n    this.sessionId = _value.sessionId;\n    this.name = _value.name;\n    this.ownerTaskId = _value.ownerTaskId;\n    this.status = _value.status;\n    this.createdAt = _value.createdAt\n      ? new googleProtobuf000.Timestamp(_value.createdAt)\n      : undefined;\n    ResultRaw.refineValues(this);\n  }\n  get sessionId(): string {\n    return this._sessionId;\n  }\n  set sessionId(value: string) {\n    this._sessionId = value;\n  }\n  get name(): string {\n    return this._name;\n  }\n  set name(value: string) {\n    this._name = value;\n  }\n  get ownerTaskId(): string {\n    return this._ownerTaskId;\n  }\n  set ownerTaskId(value: string) {\n    this._ownerTaskId = value;\n  }\n  get status(): armonikApiGrpcV1Result_status001.ResultStatus {\n    return this._status;\n  }\n  set status(value: armonikApiGrpcV1Result_status001.ResultStatus) {\n    this._status = value;\n  }\n  get createdAt(): googleProtobuf000.Timestamp | undefined {\n    return this._createdAt;\n  }\n  set createdAt(value: googleProtobuf000.Timestamp | undefined) {\n    this._createdAt = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    ResultRaw.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(): ResultRaw.AsObject {\n    return {\n      sessionId: this.sessionId,\n      name: this.name,\n      ownerTaskId: this.ownerTaskId,\n      status: this.status,\n      createdAt: this.createdAt ? this.createdAt.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  ): ResultRaw.AsProtobufJSON {\n    return {\n      sessionId: this.sessionId,\n      name: this.name,\n      ownerTaskId: this.ownerTaskId,\n      status:\n        armonikApiGrpcV1Result_status001.ResultStatus[\n          this.status === null || this.status === undefined ? 0 : this.status\n        ],\n      createdAt: this.createdAt ? this.createdAt.toProtobufJSON(options) : null\n    };\n  }\n}\nexport module ResultRaw {\n  /**\n   * Standard JavaScript object representation for ResultRaw\n   */\n  export interface AsObject {\n    sessionId: string;\n    name: string;\n    ownerTaskId: string;\n    status: armonikApiGrpcV1Result_status001.ResultStatus;\n    createdAt?: googleProtobuf000.Timestamp.AsObject;\n  }\n\n  /**\n   * Protobuf JSON representation for ResultRaw\n   */\n  export interface AsProtobufJSON {\n    sessionId: string;\n    name: string;\n    ownerTaskId: string;\n    status: string;\n    createdAt: googleProtobuf000.Timestamp.AsProtobufJSON | null;\n  }\n}\n\n/**\n * Message implementation for armonik.api.grpc.v1.results.ListResultsRequest\n */\nexport class ListResultsRequest implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.results.ListResultsRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new ListResultsRequest();\n    ListResultsRequest.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: ListResultsRequest) {\n    _instance.page = _instance.page || 0;\n    _instance.pageSize = _instance.pageSize || 0;\n    _instance.filter = _instance.filter || undefined;\n    _instance.sort = _instance.sort || undefined;\n  }\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: ListResultsRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.page = _reader.readInt32();\n          break;\n        case 2:\n          _instance.pageSize = _reader.readInt32();\n          break;\n        case 3:\n          _instance.filter = new ListResultsRequest.Filter();\n          _reader.readMessage(\n            _instance.filter,\n            ListResultsRequest.Filter.deserializeBinaryFromReader\n          );\n          break;\n        case 4:\n          _instance.sort = new ListResultsRequest.Sort();\n          _reader.readMessage(\n            _instance.sort,\n            ListResultsRequest.Sort.deserializeBinaryFromReader\n          );\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    ListResultsRequest.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: ListResultsRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.page) {\n      _writer.writeInt32(1, _instance.page);\n    }\n    if (_instance.pageSize) {\n      _writer.writeInt32(2, _instance.pageSize);\n    }\n    if (_instance.filter) {\n      _writer.writeMessage(\n        3,\n        _instance.filter as any,\n        ListResultsRequest.Filter.serializeBinaryToWriter\n      );\n    }\n    if (_instance.sort) {\n      _writer.writeMessage(\n        4,\n        _instance.sort as any,\n        ListResultsRequest.Sort.serializeBinaryToWriter\n      );\n    }\n  }\n\n  private _page: number;\n  private _pageSize: number;\n  private _filter?: ListResultsRequest.Filter;\n  private _sort?: ListResultsRequest.Sort;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of ListResultsRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<ListResultsRequest.AsObject>) {\n    _value = _value || {};\n    this.page = _value.page;\n    this.pageSize = _value.pageSize;\n    this.filter = _value.filter\n      ? new ListResultsRequest.Filter(_value.filter)\n      : undefined;\n    this.sort = _value.sort\n      ? new ListResultsRequest.Sort(_value.sort)\n      : undefined;\n    ListResultsRequest.refineValues(this);\n  }\n  get page(): number {\n    return this._page;\n  }\n  set page(value: number) {\n    this._page = value;\n  }\n  get pageSize(): number {\n    return this._pageSize;\n  }\n  set pageSize(value: number) {\n    this._pageSize = value;\n  }\n  get filter(): ListResultsRequest.Filter | undefined {\n    return this._filter;\n  }\n  set filter(value: ListResultsRequest.Filter | undefined) {\n    this._filter = value;\n  }\n  get sort(): ListResultsRequest.Sort | undefined {\n    return this._sort;\n  }\n  set sort(value: ListResultsRequest.Sort | undefined) {\n    this._sort = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    ListResultsRequest.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(): ListResultsRequest.AsObject {\n    return {\n      page: this.page,\n      pageSize: this.pageSize,\n      filter: this.filter ? this.filter.toObject() : undefined,\n      sort: this.sort ? this.sort.toObject() : undefined\n    };\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  ): ListResultsRequest.AsProtobufJSON {\n    return {\n      page: this.page,\n      pageSize: this.pageSize,\n      filter: this.filter ? this.filter.toProtobufJSON(options) : null,\n      sort: this.sort ? this.sort.toProtobufJSON(options) : null\n    };\n  }\n}\nexport module ListResultsRequest {\n  /**\n   * Standard JavaScript object representation for ListResultsRequest\n   */\n  export interface AsObject {\n    page: number;\n    pageSize: number;\n    filter?: ListResultsRequest.Filter.AsObject;\n    sort?: ListResultsRequest.Sort.AsObject;\n  }\n\n  /**\n   * Protobuf JSON representation for ListResultsRequest\n   */\n  export interface AsProtobufJSON {\n    page: number;\n    pageSize: number;\n    filter: ListResultsRequest.Filter.AsProtobufJSON | null;\n    sort: ListResultsRequest.Sort.AsProtobufJSON | null;\n  }\n  export enum OrderByField {\n    ORDER_BY_FIELD_UNSPECIFIED = 0,\n    ORDER_BY_FIELD_SESSION_ID = 1,\n    ORDER_BY_FIELD_NAME = 2,\n    ORDER_BY_FIELD_OWNER_TASK_ID = 3,\n    ORDER_BY_FIELD_STATUS = 4,\n    ORDER_BY_FIELD_CREATED_AT = 5\n  }\n  export enum OrderDirection {\n    ORDER_DIRECTION_UNSPECIFIED = 0,\n    ORDER_DIRECTION_ASC = 1,\n    ORDER_DIRECTION_DESC = 2\n  }\n  /**\n   * Message implementation for armonik.api.grpc.v1.results.ListResultsRequest.Filter\n   */\n  export class Filter implements GrpcMessage {\n    static id = 'armonik.api.grpc.v1.results.ListResultsRequest.Filter';\n\n    /**\n     * Deserialize binary data to message\n     * @param instance message instance\n     */\n    static deserializeBinary(bytes: ByteSource) {\n      const instance = new Filter();\n      Filter.deserializeBinaryFromReader(instance, new BinaryReader(bytes));\n      return instance;\n    }\n\n    /**\n     * Check all the properties and set default protobuf values if necessary\n     * @param _instance message instance\n     */\n    static refineValues(_instance: Filter) {\n      _instance.sessionId = _instance.sessionId || '';\n      _instance.name = _instance.name || '';\n      _instance.ownerTaskId = _instance.ownerTaskId || '';\n      _instance.status = _instance.status || 0;\n      _instance.createdAfter = _instance.createdAfter || undefined;\n      _instance.createdBefore = _instance.createdBefore || undefined;\n    }\n\n    /**\n     * Deserializes / reads binary message into message instance using provided binary reader\n     * @param _instance message instance\n     * @param _reader binary reader instance\n     */\n    static deserializeBinaryFromReader(\n      _instance: Filter,\n      _reader: BinaryReader\n    ) {\n      while (_reader.nextField()) {\n        if (_reader.isEndGroup()) break;\n\n        switch (_reader.getFieldNumber()) {\n          case 1:\n            _instance.sessionId = _reader.readString();\n            break;\n          case 2:\n            _instance.name = _reader.readString();\n            break;\n          case 3:\n            _instance.ownerTaskId = _reader.readString();\n            break;\n          case 4:\n            _instance.status = _reader.readEnum();\n            break;\n          case 5:\n            _instance.createdAfter = new googleProtobuf000.Timestamp();\n            _reader.readMessage(\n              _instance.createdAfter,\n              googleProtobuf000.Timestamp.deserializeBinaryFromReader\n            );\n            break;\n          case 6:\n            _instance.createdBefore = new googleProtobuf000.Timestamp();\n            _reader.readMessage(\n              _instance.createdBefore,\n              googleProtobuf000.Timestamp.deserializeBinaryFromReader\n            );\n            break;\n          default:\n            _reader.skipField();\n        }\n      }\n\n      Filter.refineValues(_instance);\n    }\n\n    /**\n     * Serializes a message to binary format using provided binary reader\n     * @param _instance message instance\n     * @param _writer binary writer instance\n     */\n    static serializeBinaryToWriter(_instance: Filter, _writer: BinaryWriter) {\n      if (_instance.sessionId) {\n        _writer.writeString(1, _instance.sessionId);\n      }\n      if (_instance.name) {\n        _writer.writeString(2, _instance.name);\n      }\n      if (_instance.ownerTaskId) {\n        _writer.writeString(3, _instance.ownerTaskId);\n      }\n      if (_instance.status) {\n        _writer.writeEnum(4, _instance.status);\n      }\n      if (_instance.createdAfter) {\n        _writer.writeMessage(\n          5,\n          _instance.createdAfter as any,\n          googleProtobuf000.Timestamp.serializeBinaryToWriter\n        );\n      }\n      if (_instance.createdBefore) {\n        _writer.writeMessage(\n          6,\n          _instance.createdBefore as any,\n          googleProtobuf000.Timestamp.serializeBinaryToWriter\n        );\n      }\n    }\n\n    private _sessionId: string;\n    private _name: string;\n    private _ownerTaskId: string;\n    private _status: armonikApiGrpcV1Result_status001.ResultStatus;\n    private _createdAfter?: googleProtobuf000.Timestamp;\n    private _createdBefore?: googleProtobuf000.Timestamp;\n\n    /**\n     * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n     * @param _value initial values object or instance of Filter to deeply clone from\n     */\n    constructor(_value?: RecursivePartial<Filter.AsObject>) {\n      _value = _value || {};\n      this.sessionId = _value.sessionId;\n      this.name = _value.name;\n      this.ownerTaskId = _value.ownerTaskId;\n      this.status = _value.status;\n      this.createdAfter = _value.createdAfter\n        ? new googleProtobuf000.Timestamp(_value.createdAfter)\n        : undefined;\n      this.createdBefore = _value.createdBefore\n        ? new googleProtobuf000.Timestamp(_value.createdBefore)\n        : undefined;\n      Filter.refineValues(this);\n    }\n    get sessionId(): string {\n      return this._sessionId;\n    }\n    set sessionId(value: string) {\n      this._sessionId = value;\n    }\n    get name(): string {\n      return this._name;\n    }\n    set name(value: string) {\n      this._name = value;\n    }\n    get ownerTaskId(): string {\n      return this._ownerTaskId;\n    }\n    set ownerTaskId(value: string) {\n      this._ownerTaskId = value;\n    }\n    get status(): armonikApiGrpcV1Result_status001.ResultStatus {\n      return this._status;\n    }\n    set status(value: armonikApiGrpcV1Result_status001.ResultStatus) {\n      this._status = value;\n    }\n    get createdAfter(): googleProtobuf000.Timestamp | undefined {\n      return this._createdAfter;\n    }\n    set createdAfter(value: googleProtobuf000.Timestamp | undefined) {\n      this._createdAfter = value;\n    }\n    get createdBefore(): googleProtobuf000.Timestamp | undefined {\n      return this._createdBefore;\n    }\n    set createdBefore(value: googleProtobuf000.Timestamp | undefined) {\n      this._createdBefore = value;\n    }\n\n    /**\n     * Serialize message to binary data\n     * @param instance message instance\n     */\n    serializeBinary() {\n      const writer = new BinaryWriter();\n      Filter.serializeBinaryToWriter(this, writer);\n      return writer.getResultBuffer();\n    }\n\n    /**\n     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)\n     */\n    toObject(): Filter.AsObject {\n      return {\n        sessionId: this.sessionId,\n        name: this.name,\n        ownerTaskId: this.ownerTaskId,\n        status: this.status,\n        createdAfter: this.createdAfter\n          ? this.createdAfter.toObject()\n          : undefined,\n        createdBefore: this.createdBefore\n          ? this.createdBefore.toObject()\n          : undefined\n      };\n    }\n\n    /**\n     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()\n     */\n    toJSON() {\n      return this.toObject();\n    }\n\n    /**\n     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json\n     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.\n     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required\n     */\n    toProtobufJSON(\n      // @ts-ignore\n      options?: ToProtobufJSONOptions\n    ): Filter.AsProtobufJSON {\n      return {\n        sessionId: this.sessionId,\n        name: this.name,\n        ownerTaskId: this.ownerTaskId,\n        status:\n          armonikApiGrpcV1Result_status001.ResultStatus[\n            this.status === null || this.status === undefined ? 0 : this.status\n          ],\n        createdAfter: this.createdAfter\n          ? this.createdAfter.toProtobufJSON(options)\n          : null,\n        createdBefore: this.createdBefore\n          ? this.createdBefore.toProtobufJSON(options)\n          : null\n      };\n    }\n  }\n  export module Filter {\n    /**\n     * Standard JavaScript object representation for Filter\n     */\n    export interface AsObject {\n      sessionId: string;\n      name: string;\n      ownerTaskId: string;\n      status: armonikApiGrpcV1Result_status001.ResultStatus;\n      createdAfter?: googleProtobuf000.Timestamp.AsObject;\n      createdBefore?: googleProtobuf000.Timestamp.AsObject;\n    }\n\n    /**\n     * Protobuf JSON representation for Filter\n     */\n    export interface AsProtobufJSON {\n      sessionId: string;\n      name: string;\n      ownerTaskId: string;\n      status: string;\n      createdAfter: googleProtobuf000.Timestamp.AsProtobufJSON | null;\n      createdBefore: googleProtobuf000.Timestamp.AsProtobufJSON | null;\n    }\n  }\n\n  /**\n   * Message implementation for armonik.api.grpc.v1.results.ListResultsRequest.Sort\n   */\n  export class Sort implements GrpcMessage {\n    static id = 'armonik.api.grpc.v1.results.ListResultsRequest.Sort';\n\n    /**\n     * Deserialize binary data to message\n     * @param instance message instance\n     */\n    static deserializeBinary(bytes: ByteSource) {\n      const instance = new Sort();\n      Sort.deserializeBinaryFromReader(instance, new BinaryReader(bytes));\n      return instance;\n    }\n\n    /**\n     * Check all the properties and set default protobuf values if necessary\n     * @param _instance message instance\n     */\n    static refineValues(_instance: Sort) {\n      _instance.field = _instance.field || 0;\n      _instance.direction = _instance.direction || 0;\n    }\n\n    /**\n     * Deserializes / reads binary message into message instance using provided binary reader\n     * @param _instance message instance\n     * @param _reader binary reader instance\n     */\n    static deserializeBinaryFromReader(_instance: Sort, _reader: BinaryReader) {\n      while (_reader.nextField()) {\n        if (_reader.isEndGroup()) break;\n\n        switch (_reader.getFieldNumber()) {\n          case 1:\n            _instance.field = _reader.readEnum();\n            break;\n          case 2:\n            _instance.direction = _reader.readEnum();\n            break;\n          default:\n            _reader.skipField();\n        }\n      }\n\n      Sort.refineValues(_instance);\n    }\n\n    /**\n     * Serializes a message to binary format using provided binary reader\n     * @param _instance message instance\n     * @param _writer binary writer instance\n     */\n    static serializeBinaryToWriter(_instance: Sort, _writer: BinaryWriter) {\n      if (_instance.field) {\n        _writer.writeEnum(1, _instance.field);\n      }\n      if (_instance.direction) {\n        _writer.writeEnum(2, _instance.direction);\n      }\n    }\n\n    private _field: ListResultsRequest.OrderByField;\n    private _direction: ListResultsRequest.OrderDirection;\n\n    /**\n     * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n     * @param _value initial values object or instance of Sort to deeply clone from\n     */\n    constructor(_value?: RecursivePartial<Sort.AsObject>) {\n      _value = _value || {};\n      this.field = _value.field;\n      this.direction = _value.direction;\n      Sort.refineValues(this);\n    }\n    get field(): ListResultsRequest.OrderByField {\n      return this._field;\n    }\n    set field(value: ListResultsRequest.OrderByField) {\n      this._field = value;\n    }\n    get direction(): ListResultsRequest.OrderDirection {\n      return this._direction;\n    }\n    set direction(value: ListResultsRequest.OrderDirection) {\n      this._direction = value;\n    }\n\n    /**\n     * Serialize message to binary data\n     * @param instance message instance\n     */\n    serializeBinary() {\n      const writer = new BinaryWriter();\n      Sort.serializeBinaryToWriter(this, writer);\n      return writer.getResultBuffer();\n    }\n\n    /**\n     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)\n     */\n    toObject(): Sort.AsObject {\n      return {\n        field: this.field,\n        direction: this.direction\n      };\n    }\n\n    /**\n     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()\n     */\n    toJSON() {\n      return this.toObject();\n    }\n\n    /**\n     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json\n     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.\n     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required\n     */\n    toProtobufJSON(\n      // @ts-ignore\n      options?: ToProtobufJSONOptions\n    ): Sort.AsProtobufJSON {\n      return {\n        field:\n          ListResultsRequest.OrderByField[\n            this.field === null || this.field === undefined ? 0 : this.field\n          ],\n        direction:\n          ListResultsRequest.OrderDirection[\n            this.direction === null || this.direction === undefined\n              ? 0\n              : this.direction\n          ]\n      };\n    }\n  }\n  export module Sort {\n    /**\n     * Standard JavaScript object representation for Sort\n     */\n    export interface AsObject {\n      field: ListResultsRequest.OrderByField;\n      direction: ListResultsRequest.OrderDirection;\n    }\n\n    /**\n     * Protobuf JSON representation for Sort\n     */\n    export interface AsProtobufJSON {\n      field: string;\n      direction: string;\n    }\n  }\n}\n\n/**\n * Message implementation for armonik.api.grpc.v1.results.ListResultsResponse\n */\nexport class ListResultsResponse implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.results.ListResultsResponse';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new ListResultsResponse();\n    ListResultsResponse.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: ListResultsResponse) {\n    _instance.results = _instance.results || [];\n    _instance.page = _instance.page || 0;\n    _instance.pageSize = _instance.pageSize || 0;\n    _instance.total = _instance.total || 0;\n  }\n\n  /**\n   * Deserializes / reads binary message into message instance using provided binary reader\n   * @param _instance message instance\n   * @param _reader binary reader instance\n   */\n  static deserializeBinaryFromReader(\n    _instance: ListResultsResponse,\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 ResultRaw();\n          _reader.readMessage(\n            messageInitializer1,\n            ResultRaw.deserializeBinaryFromReader\n          );\n          (_instance.results = _instance.results || []).push(\n            messageInitializer1\n          );\n          break;\n        case 2:\n          _instance.page = _reader.readInt32();\n          break;\n        case 3:\n          _instance.pageSize = _reader.readInt32();\n          break;\n        case 4:\n          _instance.total = _reader.readInt32();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    ListResultsResponse.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: ListResultsResponse,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.results && _instance.results.length) {\n      _writer.writeRepeatedMessage(\n        1,\n        _instance.results as any,\n        ResultRaw.serializeBinaryToWriter\n      );\n    }\n    if (_instance.page) {\n      _writer.writeInt32(2, _instance.page);\n    }\n    if (_instance.pageSize) {\n      _writer.writeInt32(3, _instance.pageSize);\n    }\n    if (_instance.total) {\n      _writer.writeInt32(4, _instance.total);\n    }\n  }\n\n  private _results?: ResultRaw[];\n  private _page: number;\n  private _pageSize: number;\n  private _total: number;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of ListResultsResponse to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<ListResultsResponse.AsObject>) {\n    _value = _value || {};\n    this.results = (_value.results || []).map(m => new ResultRaw(m));\n    this.page = _value.page;\n    this.pageSize = _value.pageSize;\n    this.total = _value.total;\n    ListResultsResponse.refineValues(this);\n  }\n  get results(): ResultRaw[] | undefined {\n    return this._results;\n  }\n  set results(value: ResultRaw[] | undefined) {\n    this._results = value;\n  }\n  get page(): number {\n    return this._page;\n  }\n  set page(value: number) {\n    this._page = value;\n  }\n  get pageSize(): number {\n    return this._pageSize;\n  }\n  set pageSize(value: number) {\n    this._pageSize = value;\n  }\n  get total(): number {\n    return this._total;\n  }\n  set total(value: number) {\n    this._total = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    ListResultsResponse.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(): ListResultsResponse.AsObject {\n    return {\n      results: (this.results || []).map(m => m.toObject()),\n      page: this.page,\n      pageSize: this.pageSize,\n      total: this.total\n    };\n  }\n\n  /**\n   * Convenience method to support JSON.stringify(message), replicates the structure of toObject()\n   */\n  toJSON() {\n    return this.toObject();\n  }\n\n  /**\n   * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json\n   * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.\n   * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required\n   */\n  toProtobufJSON(\n    // @ts-ignore\n    options?: ToProtobufJSONOptions\n  ): ListResultsResponse.AsProtobufJSON {\n    return {\n      results: (this.results || []).map(m => m.toProtobufJSON(options)),\n      page: this.page,\n      pageSize: this.pageSize,\n      total: this.total\n    };\n  }\n}\nexport module ListResultsResponse {\n  /**\n   * Standard JavaScript object representation for ListResultsResponse\n   */\n  export interface AsObject {\n    results?: ResultRaw.AsObject[];\n    page: number;\n    pageSize: number;\n    total: number;\n  }\n\n  /**\n   * Protobuf JSON representation for ListResultsResponse\n   */\n  export interface AsProtobufJSON {\n    results: ResultRaw.AsProtobufJSON[] | null;\n    page: number;\n    pageSize: number;\n    total: number;\n  }\n}\n\n/**\n * Message implementation for armonik.api.grpc.v1.results.GetOwnerTaskIdRequest\n */\nexport class GetOwnerTaskIdRequest implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.results.GetOwnerTaskIdRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new GetOwnerTaskIdRequest();\n    GetOwnerTaskIdRequest.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: GetOwnerTaskIdRequest) {\n    _instance.sessionId = _instance.sessionId || '';\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: GetOwnerTaskIdRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.sessionId = _reader.readString();\n          break;\n        case 2:\n          (_instance.resultId = _instance.resultId || []).push(\n            _reader.readString()\n          );\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    GetOwnerTaskIdRequest.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: GetOwnerTaskIdRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.sessionId) {\n      _writer.writeString(1, _instance.sessionId);\n    }\n    if (_instance.resultId && _instance.resultId.length) {\n      _writer.writeRepeatedString(2, _instance.resultId);\n    }\n  }\n\n  private _sessionId: 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 GetOwnerTaskIdRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<GetOwnerTaskIdRequest.AsObject>) {\n    _value = _value || {};\n    this.sessionId = _value.sessionId;\n    this.resultId = (_value.resultId || []).slice();\n    GetOwnerTaskIdRequest.refineValues(this);\n  }\n  get sessionId(): string {\n    return this._sessionId;\n  }\n  set sessionId(value: string) {\n    this._sessionId = 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    GetOwnerTaskIdRequest.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(): GetOwnerTaskIdRequest.AsObject {\n    return {\n      sessionId: this.sessionId,\n      resultId: (this.resultId || []).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  ): GetOwnerTaskIdRequest.AsProtobufJSON {\n    return {\n      sessionId: this.sessionId,\n      resultId: (this.resultId || []).slice()\n    };\n  }\n}\nexport module GetOwnerTaskIdRequest {\n  /**\n   * Standard JavaScript object representation for GetOwnerTaskIdRequest\n   */\n  export interface AsObject {\n    sessionId: string;\n    resultId: string[];\n  }\n\n  /**\n   * Protobuf JSON representation for GetOwnerTaskIdRequest\n   */\n  export interface AsProtobufJSON {\n    sessionId: string;\n    resultId: string[];\n  }\n}\n\n/**\n * Message implementation for armonik.api.grpc.v1.results.GetOwnerTaskIdResponse\n */\nexport class GetOwnerTaskIdResponse implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.results.GetOwnerTaskIdResponse';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new GetOwnerTaskIdResponse();\n    GetOwnerTaskIdResponse.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: GetOwnerTaskIdResponse) {\n    _instance.resultTask = _instance.resultTask || [];\n    _instance.sessionId = _instance.sessionId || '';\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: GetOwnerTaskIdResponse,\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 GetOwnerTaskIdResponse.MapResultTask();\n          _reader.readMessage(\n            messageInitializer1,\n            GetOwnerTaskIdResponse.MapResultTask.deserializeBinaryFromReader\n          );\n          (_instance.resultTask = _instance.resultTask || []).push(\n            messageInitializer1\n          );\n          break;\n        case 2:\n          _instance.sessionId = _reader.readString();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    GetOwnerTaskIdResponse.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: GetOwnerTaskIdResponse,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.resultTask && _instance.resultTask.length) {\n      _writer.writeRepeatedMessage(\n        1,\n        _instance.resultTask as any,\n        GetOwnerTaskIdResponse.MapResultTask.serializeBinaryToWriter\n      );\n    }\n    if (_instance.sessionId) {\n      _writer.writeString(2, _instance.sessionId);\n    }\n  }\n\n  private _resultTask?: GetOwnerTaskIdResponse.MapResultTask[];\n  private _sessionId: 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 GetOwnerTaskIdResponse to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<GetOwnerTaskIdResponse.AsObject>) {\n    _value = _value || {};\n    this.resultTask = (_value.resultTask || []).map(\n      m => new GetOwnerTaskIdResponse.MapResultTask(m)\n    );\n    this.sessionId = _value.sessionId;\n    GetOwnerTaskIdResponse.refineValues(this);\n  }\n  get resultTask(): GetOwnerTaskIdResponse.MapResultTask[] | undefined {\n    return this._resultTask;\n  }\n  set resultTask(value: GetOwnerTaskIdResponse.MapResultTask[] | undefined) {\n    this._resultTask = value;\n  }\n  get sessionId(): string {\n    return this._sessionId;\n  }\n  set sessionId(value: string) {\n    this._sessionId = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    GetOwnerTaskIdResponse.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(): GetOwnerTaskIdResponse.AsObject {\n    return {\n      resultTask: (this.resultTask || []).map(m => m.toObject()),\n      sessionId: this.sessionId\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  ): GetOwnerTaskIdResponse.AsProtobufJSON {\n    return {\n      resultTask: (this.resultTask || []).map(m => m.toProtobufJSON(options)),\n      sessionId: this.sessionId\n    };\n  }\n}\nexport module GetOwnerTaskIdResponse {\n  /**\n   * Standard JavaScript object representation for GetOwnerTaskIdResponse\n   */\n  export interface AsObject {\n    resultTask?: GetOwnerTaskIdResponse.MapResultTask.AsObject[];\n    sessionId: string;\n  }\n\n  /**\n   * Protobuf JSON representation for GetOwnerTaskIdResponse\n   */\n  export interface AsProtobufJSON {\n    resultTask: GetOwnerTaskIdResponse.MapResultTask.AsProtobufJSON[] | null;\n    sessionId: string;\n  }\n\n  /**\n   * Message implementation for armonik.api.grpc.v1.results.GetOwnerTaskIdResponse.MapResultTask\n   */\n  export class MapResultTask implements GrpcMessage {\n    static id =\n      'armonik.api.grpc.v1.results.GetOwnerTaskIdResponse.MapResultTask';\n\n    /**\n     * Deserialize binary data to message\n     * @param instance message instance\n     */\n    static deserializeBinary(bytes: ByteSource) {\n      const instance = new MapResultTask();\n      MapResultTask.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: MapResultTask) {\n      _instance.resultId = _instance.resultId || '';\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: MapResultTask,\n      _reader: BinaryReader\n    ) {\n      while (_reader.nextField()) {\n        if (_reader.isEndGroup()) break;\n\n        switch (_reader.getFieldNumber()) {\n          case 1:\n            _instance.resultId = _reader.readString();\n            break;\n          case 2:\n            _instance.taskId = _reader.readString();\n            break;\n          default:\n            _reader.skipField();\n        }\n      }\n\n      MapResultTask.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: MapResultTask,\n      _writer: BinaryWriter\n    ) {\n      if (_instance.resultId) {\n        _writer.writeString(1, _instance.resultId);\n      }\n      if (_instance.taskId) {\n        _writer.writeString(2, _instance.taskId);\n      }\n    }\n\n    private _resultId: 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 MapResultTask to deeply clone from\n     */\n    constructor(_value?: RecursivePartial<MapResultTask.AsObject>) {\n      _value = _value || {};\n      this.resultId = _value.resultId;\n      this.taskId = _value.taskId;\n      MapResultTask.refineValues(this);\n    }\n    get resultId(): string {\n      return this._resultId;\n    }\n    set resultId(value: string) {\n      this._resultId = 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      MapResultTask.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(): MapResultTask.AsObject {\n      return {\n        resultId: this.resultId,\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    ): MapResultTask.AsProtobufJSON {\n      return {\n        resultId: this.resultId,\n        taskId: this.taskId\n      };\n    }\n  }\n  export module MapResultTask {\n    /**\n     * Standard JavaScript object representation for MapResultTask\n     */\n    export interface AsObject {\n      resultId: string;\n      taskId: string;\n    }\n\n    /**\n     * Protobuf JSON representation for MapResultTask\n     */\n    export interface AsProtobufJSON {\n      resultId: string;\n      taskId: string;\n    }\n  }\n}\n"]}