@aneoconsultingfr/armonik.api.angular 3.4.0

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

@@ -0,0 +1,1169 @@
+import { BinaryReader, BinaryWriter } from 'google-protobuf';
+/**
+ * Message implementation for armonik.api.grpc.v1.partitions.PartitionRaw
+ */
+export class PartitionRaw {
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new PartitionRaw();
+        PartitionRaw.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+        return instance;
+    }
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance) {
+        _instance.id = _instance.id || '';
+        _instance.parentPartitionIds = _instance.parentPartitionIds || [];
+        _instance.podReserved = _instance.podReserved || '0';
+        _instance.podMax = _instance.podMax || '0';
+        _instance.podConfiguration = _instance.podConfiguration || {};
+        _instance.preemptionPercentage = _instance.preemptionPercentage || '0';
+        _instance.priority = _instance.priority || '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.id = _reader.readString();
+                    break;
+                case 2:
+                    (_instance.parentPartitionIds =
+                        _instance.parentPartitionIds || []).push(_reader.readString());
+                    break;
+                case 3:
+                    _instance.podReserved = _reader.readInt64String();
+                    break;
+                case 4:
+                    _instance.podMax = _reader.readInt64String();
+                    break;
+                case 7:
+                    const msg_7 = {};
+                    _reader.readMessage(msg_7, PartitionRaw.PodConfigurationEntry.deserializeBinaryFromReader);
+                    _instance.podConfiguration = _instance.podConfiguration || {};
+                    _instance.podConfiguration[msg_7.key] = msg_7.value;
+                    break;
+                case 5:
+                    _instance.preemptionPercentage = _reader.readInt64String();
+                    break;
+                case 6:
+                    _instance.priority = _reader.readInt64String();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        PartitionRaw.refineValues(_instance);
+    }
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance, _writer) {
+        if (_instance.id) {
+            _writer.writeString(1, _instance.id);
+        }
+        if (_instance.parentPartitionIds && _instance.parentPartitionIds.length) {
+            _writer.writeRepeatedString(2, _instance.parentPartitionIds);
+        }
+        if (_instance.podReserved) {
+            _writer.writeInt64String(3, _instance.podReserved);
+        }
+        if (_instance.podMax) {
+            _writer.writeInt64String(4, _instance.podMax);
+        }
+        if (!!_instance.podConfiguration) {
+            const keys_7 = Object.keys(_instance.podConfiguration);
+            if (keys_7.length) {
+                const repeated_7 = keys_7
+                    .map(key => ({
+                    key: key,
+                    value: _instance.podConfiguration[key]
+                }))
+                    .reduce((r, v) => [...r, v], []);
+                _writer.writeRepeatedMessage(7, repeated_7, PartitionRaw.PodConfigurationEntry.serializeBinaryToWriter);
+            }
+        }
+        if (_instance.preemptionPercentage) {
+            _writer.writeInt64String(5, _instance.preemptionPercentage);
+        }
+        if (_instance.priority) {
+            _writer.writeInt64String(6, _instance.priority);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of PartitionRaw to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.id = _value.id;
+        this.parentPartitionIds = (_value.parentPartitionIds || []).slice();
+        this.podReserved = _value.podReserved;
+        this.podMax = _value.podMax;
+        (this.podConfiguration = _value.podConfiguration
+            ? Object.keys(_value.podConfiguration).reduce((r, k) => ({ ...r, [k]: _value.podConfiguration[k] }), {})
+            : {}),
+            (this.preemptionPercentage = _value.preemptionPercentage);
+        this.priority = _value.priority;
+        PartitionRaw.refineValues(this);
+    }
+    get id() {
+        return this._id;
+    }
+    set id(value) {
+        this._id = value;
+    }
+    get parentPartitionIds() {
+        return this._parentPartitionIds;
+    }
+    set parentPartitionIds(value) {
+        this._parentPartitionIds = value;
+    }
+    get podReserved() {
+        return this._podReserved;
+    }
+    set podReserved(value) {
+        this._podReserved = value;
+    }
+    get podMax() {
+        return this._podMax;
+    }
+    set podMax(value) {
+        this._podMax = value;
+    }
+    get podConfiguration() {
+        return this._podConfiguration;
+    }
+    set podConfiguration(value) {
+        this._podConfiguration = value;
+    }
+    get preemptionPercentage() {
+        return this._preemptionPercentage;
+    }
+    set preemptionPercentage(value) {
+        this._preemptionPercentage = value;
+    }
+    get priority() {
+        return this._priority;
+    }
+    set priority(value) {
+        this._priority = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        PartitionRaw.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            id: this.id,
+            parentPartitionIds: (this.parentPartitionIds || []).slice(),
+            podReserved: this.podReserved,
+            podMax: this.podMax,
+            podConfiguration: this.podConfiguration
+                ? Object.keys(this.podConfiguration).reduce((r, k) => ({ ...r, [k]: this.podConfiguration[k] }), {})
+                : {},
+            preemptionPercentage: this.preemptionPercentage,
+            priority: this.priority
+        };
+    }
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON() {
+        return this.toObject();
+    }
+    /**
+     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+     */
+    toProtobufJSON(
+    // @ts-ignore
+    options) {
+        return {
+            id: this.id,
+            parentPartitionIds: (this.parentPartitionIds || []).slice(),
+            podReserved: this.podReserved,
+            podMax: this.podMax,
+            podConfiguration: this.podConfiguration
+                ? Object.keys(this.podConfiguration).reduce((r, k) => ({ ...r, [k]: this.podConfiguration[k] }), {})
+                : {},
+            preemptionPercentage: this.preemptionPercentage,
+            priority: this.priority
+        };
+    }
+}
+PartitionRaw.id = 'armonik.api.grpc.v1.partitions.PartitionRaw';
+(function (PartitionRaw) {
+    /**
+     * Message implementation for armonik.api.grpc.v1.partitions.PartitionRaw.PodConfigurationEntry
+     */
+    class PodConfigurationEntry {
+        /**
+         * Deserialize binary data to message
+         * @param instance message instance
+         */
+        static deserializeBinary(bytes) {
+            const instance = new PodConfigurationEntry();
+            PodConfigurationEntry.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+            return instance;
+        }
+        /**
+         * Check all the properties and set default protobuf values if necessary
+         * @param _instance message instance
+         */
+        static refineValues(_instance) {
+            _instance.key = _instance.key || '';
+            _instance.value = _instance.value || '';
+        }
+        /**
+         * Deserializes / reads binary message into message instance using provided binary reader
+         * @param _instance message instance
+         * @param _reader binary reader instance
+         */
+        static deserializeBinaryFromReader(_instance, _reader) {
+            while (_reader.nextField()) {
+                if (_reader.isEndGroup())
+                    break;
+                switch (_reader.getFieldNumber()) {
+                    case 1:
+                        _instance.key = _reader.readString();
+                        break;
+                    case 2:
+                        _instance.value = _reader.readString();
+                        break;
+                    default:
+                        _reader.skipField();
+                }
+            }
+            PodConfigurationEntry.refineValues(_instance);
+        }
+        /**
+         * Serializes a message to binary format using provided binary reader
+         * @param _instance message instance
+         * @param _writer binary writer instance
+         */
+        static serializeBinaryToWriter(_instance, _writer) {
+            if (_instance.key) {
+                _writer.writeString(1, _instance.key);
+            }
+            if (_instance.value) {
+                _writer.writeString(2, _instance.value);
+            }
+        }
+        /**
+         * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+         * @param _value initial values object or instance of PodConfigurationEntry to deeply clone from
+         */
+        constructor(_value) {
+            _value = _value || {};
+            this.key = _value.key;
+            this.value = _value.value;
+            PodConfigurationEntry.refineValues(this);
+        }
+        get key() {
+            return this._key;
+        }
+        set key(value) {
+            this._key = value;
+        }
+        get value() {
+            return this._value;
+        }
+        set value(value) {
+            this._value = value;
+        }
+        /**
+         * Serialize message to binary data
+         * @param instance message instance
+         */
+        serializeBinary() {
+            const writer = new BinaryWriter();
+            PodConfigurationEntry.serializeBinaryToWriter(this, writer);
+            return writer.getResultBuffer();
+        }
+        /**
+         * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+         */
+        toObject() {
+            return {
+                key: this.key,
+                value: this.value
+            };
+        }
+        /**
+         * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+         */
+        toJSON() {
+            return this.toObject();
+        }
+        /**
+         * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+         * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+         * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+         */
+        toProtobufJSON(
+        // @ts-ignore
+        options) {
+            return {
+                key: this.key,
+                value: this.value
+            };
+        }
+    }
+    PodConfigurationEntry.id = 'armonik.api.grpc.v1.partitions.PartitionRaw.PodConfigurationEntry';
+    PartitionRaw.PodConfigurationEntry = PodConfigurationEntry;
+})(PartitionRaw || (PartitionRaw = {}));
+/**
+ * Message implementation for armonik.api.grpc.v1.partitions.ListPartitionsRequest
+ */
+export class ListPartitionsRequest {
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new ListPartitionsRequest();
+        ListPartitionsRequest.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 ListPartitionsRequest.Filter();
+                    _reader.readMessage(_instance.filter, ListPartitionsRequest.Filter.deserializeBinaryFromReader);
+                    break;
+                case 4:
+                    _instance.sort = new ListPartitionsRequest.Sort();
+                    _reader.readMessage(_instance.sort, ListPartitionsRequest.Sort.deserializeBinaryFromReader);
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        ListPartitionsRequest.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, ListPartitionsRequest.Filter.serializeBinaryToWriter);
+        }
+        if (_instance.sort) {
+            _writer.writeMessage(4, _instance.sort, ListPartitionsRequest.Sort.serializeBinaryToWriter);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of ListPartitionsRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.page = _value.page;
+        this.pageSize = _value.pageSize;
+        this.filter = _value.filter
+            ? new ListPartitionsRequest.Filter(_value.filter)
+            : undefined;
+        this.sort = _value.sort
+            ? new ListPartitionsRequest.Sort(_value.sort)
+            : undefined;
+        ListPartitionsRequest.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();
+        ListPartitionsRequest.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
+        };
+    }
+}
+ListPartitionsRequest.id = 'armonik.api.grpc.v1.partitions.ListPartitionsRequest';
+(function (ListPartitionsRequest) {
+    let OrderByField;
+    (function (OrderByField) {
+        OrderByField[OrderByField["ORDER_BY_FIELD_UNSPECIFIED"] = 0] = "ORDER_BY_FIELD_UNSPECIFIED";
+        OrderByField[OrderByField["ORDER_BY_FIELD_ID"] = 1] = "ORDER_BY_FIELD_ID";
+        OrderByField[OrderByField["ORDER_BY_FIELD_PARENT_PARTITION_IDS"] = 2] = "ORDER_BY_FIELD_PARENT_PARTITION_IDS";
+        OrderByField[OrderByField["ORDER_BY_FIELD_POD_RESERVED"] = 3] = "ORDER_BY_FIELD_POD_RESERVED";
+        OrderByField[OrderByField["ORDER_BY_FIELD_POD_MAX"] = 4] = "ORDER_BY_FIELD_POD_MAX";
+        OrderByField[OrderByField["ORDER_BY_FIELD_PREEMPTION_PERCENTAGE"] = 5] = "ORDER_BY_FIELD_PREEMPTION_PERCENTAGE";
+        OrderByField[OrderByField["ORDER_BY_FIELD_PRIORITY"] = 6] = "ORDER_BY_FIELD_PRIORITY";
+    })(OrderByField = ListPartitionsRequest.OrderByField || (ListPartitionsRequest.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 = ListPartitionsRequest.OrderDirection || (ListPartitionsRequest.OrderDirection = {}));
+    /**
+     * Message implementation for armonik.api.grpc.v1.partitions.ListPartitionsRequest.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.id = _instance.id || '';
+            _instance.parentPartitionId = _instance.parentPartitionId || '';
+            _instance.podReserved = _instance.podReserved || 0;
+            _instance.podMax = _instance.podMax || 0;
+            _instance.preemptionPercentage = _instance.preemptionPercentage || 0;
+            _instance.priority = _instance.priority || 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.id = _reader.readString();
+                        break;
+                    case 2:
+                        _instance.parentPartitionId = _reader.readString();
+                        break;
+                    case 3:
+                        _instance.podReserved = _reader.readInt32();
+                        break;
+                    case 4:
+                        _instance.podMax = _reader.readInt32();
+                        break;
+                    case 5:
+                        _instance.preemptionPercentage = _reader.readInt32();
+                        break;
+                    case 6:
+                        _instance.priority = _reader.readInt32();
+                        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.id) {
+                _writer.writeString(1, _instance.id);
+            }
+            if (_instance.parentPartitionId) {
+                _writer.writeString(2, _instance.parentPartitionId);
+            }
+            if (_instance.podReserved) {
+                _writer.writeInt32(3, _instance.podReserved);
+            }
+            if (_instance.podMax) {
+                _writer.writeInt32(4, _instance.podMax);
+            }
+            if (_instance.preemptionPercentage) {
+                _writer.writeInt32(5, _instance.preemptionPercentage);
+            }
+            if (_instance.priority) {
+                _writer.writeInt32(6, _instance.priority);
+            }
+        }
+        /**
+         * 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.id = _value.id;
+            this.parentPartitionId = _value.parentPartitionId;
+            this.podReserved = _value.podReserved;
+            this.podMax = _value.podMax;
+            this.preemptionPercentage = _value.preemptionPercentage;
+            this.priority = _value.priority;
+            Filter.refineValues(this);
+        }
+        get id() {
+            return this._id;
+        }
+        set id(value) {
+            this._id = value;
+        }
+        get parentPartitionId() {
+            return this._parentPartitionId;
+        }
+        set parentPartitionId(value) {
+            this._parentPartitionId = value;
+        }
+        get podReserved() {
+            return this._podReserved;
+        }
+        set podReserved(value) {
+            this._podReserved = value;
+        }
+        get podMax() {
+            return this._podMax;
+        }
+        set podMax(value) {
+            this._podMax = value;
+        }
+        get preemptionPercentage() {
+            return this._preemptionPercentage;
+        }
+        set preemptionPercentage(value) {
+            this._preemptionPercentage = value;
+        }
+        get priority() {
+            return this._priority;
+        }
+        set priority(value) {
+            this._priority = 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 {
+                id: this.id,
+                parentPartitionId: this.parentPartitionId,
+                podReserved: this.podReserved,
+                podMax: this.podMax,
+                preemptionPercentage: this.preemptionPercentage,
+                priority: this.priority
+            };
+        }
+        /**
+         * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+         */
+        toJSON() {
+            return this.toObject();
+        }
+        /**
+         * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+         * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+         * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+         */
+        toProtobufJSON(
+        // @ts-ignore
+        options) {
+            return {
+                id: this.id,
+                parentPartitionId: this.parentPartitionId,
+                podReserved: this.podReserved,
+                podMax: this.podMax,
+                preemptionPercentage: this.preemptionPercentage,
+                priority: this.priority
+            };
+        }
+    }
+    Filter.id = 'armonik.api.grpc.v1.partitions.ListPartitionsRequest.Filter';
+    ListPartitionsRequest.Filter = Filter;
+    /**
+     * Message implementation for armonik.api.grpc.v1.partitions.ListPartitionsRequest.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: ListPartitionsRequest.OrderByField[this.field === null || this.field === undefined ? 0 : this.field],
+                direction: ListPartitionsRequest.OrderDirection[this.direction === null || this.direction === undefined
+                    ? 0
+                    : this.direction]
+            };
+        }
+    }
+    Sort.id = 'armonik.api.grpc.v1.partitions.ListPartitionsRequest.Sort';
+    ListPartitionsRequest.Sort = Sort;
+})(ListPartitionsRequest || (ListPartitionsRequest = {}));
+/**
+ * Message implementation for armonik.api.grpc.v1.partitions.ListPartitionsResponse
+ */
+export class ListPartitionsResponse {
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new ListPartitionsResponse();
+        ListPartitionsResponse.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.partitions = _instance.partitions || [];
+        _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 PartitionRaw();
+                    _reader.readMessage(messageInitializer1, PartitionRaw.deserializeBinaryFromReader);
+                    (_instance.partitions = _instance.partitions || []).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();
+            }
+        }
+        ListPartitionsResponse.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.partitions && _instance.partitions.length) {
+            _writer.writeRepeatedMessage(1, _instance.partitions, PartitionRaw.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 ListPartitionsResponse to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.partitions = (_value.partitions || []).map(m => new PartitionRaw(m));
+        this.page = _value.page;
+        this.pageSize = _value.pageSize;
+        this.total = _value.total;
+        ListPartitionsResponse.refineValues(this);
+    }
+    get partitions() {
+        return this._partitions;
+    }
+    set partitions(value) {
+        this._partitions = 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();
+        ListPartitionsResponse.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            partitions: (this.partitions || []).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 {
+            partitions: (this.partitions || []).map(m => m.toProtobufJSON(options)),
+            page: this.page,
+            pageSize: this.pageSize,
+            total: this.total
+        };
+    }
+}
+ListPartitionsResponse.id = 'armonik.api.grpc.v1.partitions.ListPartitionsResponse';
+/**
+ * Message implementation for armonik.api.grpc.v1.partitions.GetPartitionRequest
+ */
+export class GetPartitionRequest {
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new GetPartitionRequest();
+        GetPartitionRequest.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+        return instance;
+    }
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance) {
+        _instance.id = _instance.id || '';
+    }
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance, _reader) {
+        while (_reader.nextField()) {
+            if (_reader.isEndGroup())
+                break;
+            switch (_reader.getFieldNumber()) {
+                case 1:
+                    _instance.id = _reader.readString();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        GetPartitionRequest.refineValues(_instance);
+    }
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance, _writer) {
+        if (_instance.id) {
+            _writer.writeString(1, _instance.id);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of GetPartitionRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.id = _value.id;
+        GetPartitionRequest.refineValues(this);
+    }
+    get id() {
+        return this._id;
+    }
+    set id(value) {
+        this._id = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        GetPartitionRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            id: this.id
+        };
+    }
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON() {
+        return this.toObject();
+    }
+    /**
+     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+     */
+    toProtobufJSON(
+    // @ts-ignore
+    options) {
+        return {
+            id: this.id
+        };
+    }
+}
+GetPartitionRequest.id = 'armonik.api.grpc.v1.partitions.GetPartitionRequest';
+/**
+ * Message implementation for armonik.api.grpc.v1.partitions.GetPartitionResponse
+ */
+export class GetPartitionResponse {
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new GetPartitionResponse();
+        GetPartitionResponse.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.partition = _instance.partition || 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.partition = new PartitionRaw();
+                    _reader.readMessage(_instance.partition, PartitionRaw.deserializeBinaryFromReader);
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        GetPartitionResponse.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.partition) {
+            _writer.writeMessage(1, _instance.partition, PartitionRaw.serializeBinaryToWriter);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of GetPartitionResponse to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.partition = _value.partition
+            ? new PartitionRaw(_value.partition)
+            : undefined;
+        GetPartitionResponse.refineValues(this);
+    }
+    get partition() {
+        return this._partition;
+    }
+    set partition(value) {
+        this._partition = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        GetPartitionResponse.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            partition: this.partition ? this.partition.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 {
+            partition: this.partition ? this.partition.toProtobufJSON(options) : null
+        };
+    }
+}
+GetPartitionResponse.id = 'armonik.api.grpc.v1.partitions.GetPartitionResponse';
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"partitions-common.pb.js","sourceRoot":"","sources":["../../../../../../projects/aneoconsultingfr/armonik.api.angular/src/lib/generated/partitions-common.pb.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,YAAY,EAAE,YAAY,EAAc,MAAM,iBAAiB,CAAC;AAEzE;;GAEG;AACH,MAAM,OAAO,YAAY;IAGvB;;;OAGG;IACH,MAAM,CAAC,iBAAiB,CAAC,KAAiB;QACxC,MAAM,QAAQ,GAAG,IAAI,YAAY,EAAE,CAAC;QACpC,YAAY,CAAC,2BAA2B,CAAC,QAAQ,EAAE,IAAI,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC;QAC5E,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,YAAY,CAAC,SAAuB;QACzC,SAAS,CAAC,EAAE,GAAG,SAAS,CAAC,EAAE,IAAI,EAAE,CAAC;QAClC,SAAS,CAAC,kBAAkB,GAAG,SAAS,CAAC,kBAAkB,IAAI,EAAE,CAAC;QAClE,SAAS,CAAC,WAAW,GAAG,SAAS,CAAC,WAAW,IAAI,GAAG,CAAC;QACrD,SAAS,CAAC,MAAM,GAAG,SAAS,CAAC,MAAM,IAAI,GAAG,CAAC;QAC3C,SAAS,CAAC,gBAAgB,GAAG,SAAS,CAAC,gBAAgB,IAAI,EAAE,CAAC;QAC9D,SAAS,CAAC,oBAAoB,GAAG,SAAS,CAAC,oBAAoB,IAAI,GAAG,CAAC;QACvE,SAAS,CAAC,QAAQ,GAAG,SAAS,CAAC,QAAQ,IAAI,GAAG,CAAC;IACjD,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,2BAA2B,CAChC,SAAuB,EACvB,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,EAAE,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;oBACpC,MAAM;gBACR,KAAK,CAAC;oBACJ,CAAC,SAAS,CAAC,kBAAkB;wBAC3B,SAAS,CAAC,kBAAkB,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC;oBACjE,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,WAAW,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC;oBAClD,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,MAAM,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC;oBAC7C,MAAM;gBACR,KAAK,CAAC;oBACJ,MAAM,KAAK,GAAG,EAAS,CAAC;oBACxB,OAAO,CAAC,WAAW,CACjB,KAAK,EACL,YAAY,CAAC,qBAAqB,CAAC,2BAA2B,CAC/D,CAAC;oBACF,SAAS,CAAC,gBAAgB,GAAG,SAAS,CAAC,gBAAgB,IAAI,EAAE,CAAC;oBAC9D,SAAS,CAAC,gBAAgB,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC;oBACpD,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,oBAAoB,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC;oBAC3D,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,QAAQ,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC;oBAC/C,MAAM;gBACR;oBACE,OAAO,CAAC,SAAS,EAAE,CAAC;aACvB;SACF;QAED,YAAY,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;IACvC,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,uBAAuB,CAC5B,SAAuB,EACvB,OAAqB;QAErB,IAAI,SAAS,CAAC,EAAE,EAAE;YAChB,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,SAAS,CAAC,EAAE,CAAC,CAAC;SACtC;QACD,IAAI,SAAS,CAAC,kBAAkB,IAAI,SAAS,CAAC,kBAAkB,CAAC,MAAM,EAAE;YACvE,OAAO,CAAC,mBAAmB,CAAC,CAAC,EAAE,SAAS,CAAC,kBAAkB,CAAC,CAAC;SAC9D;QACD,IAAI,SAAS,CAAC,WAAW,EAAE;YACzB,OAAO,CAAC,gBAAgB,CAAC,CAAC,EAAE,SAAS,CAAC,WAAW,CAAC,CAAC;SACpD;QACD,IAAI,SAAS,CAAC,MAAM,EAAE;YACpB,OAAO,CAAC,gBAAgB,CAAC,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;SAC/C;QACD,IAAI,CAAC,CAAC,SAAS,CAAC,gBAAgB,EAAE;YAChC,MAAM,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,gBAAuB,CAAC,CAAC;YAE9D,IAAI,MAAM,CAAC,MAAM,EAAE;gBACjB,MAAM,UAAU,GAAG,MAAM;qBACtB,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;oBACX,GAAG,EAAE,GAAG;oBACR,KAAK,EAAG,SAAS,CAAC,gBAAwB,CAAC,GAAG,CAAC;iBAChD,CAAC,CAAC;qBACF,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,EAAE,EAAW,CAAC,CAAC;gBAE5C,OAAO,CAAC,oBAAoB,CAC1B,CAAC,EACD,UAAU,EACV,YAAY,CAAC,qBAAqB,CAAC,uBAAuB,CAC3D,CAAC;aACH;SACF;QACD,IAAI,SAAS,CAAC,oBAAoB,EAAE;YAClC,OAAO,CAAC,gBAAgB,CAAC,CAAC,EAAE,SAAS,CAAC,oBAAoB,CAAC,CAAC;SAC7D;QACD,IAAI,SAAS,CAAC,QAAQ,EAAE;YACtB,OAAO,CAAC,gBAAgB,CAAC,CAAC,EAAE,SAAS,CAAC,QAAQ,CAAC,CAAC;SACjD;IACH,CAAC;IAUD;;;OAGG;IACH,YAAY,MAAgD;QAC1D,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;QACtB,IAAI,CAAC,EAAE,GAAG,MAAM,CAAC,EAAE,CAAC;QACpB,IAAI,CAAC,kBAAkB,GAAG,CAAC,MAAM,CAAC,kBAAkB,IAAI,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC;QACpE,IAAI,CAAC,WAAW,GAAG,MAAM,CAAC,WAAW,CAAC;QACtC,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;QAC5B,CAAC,IAAI,CAAC,gBAAgB,GAAG,MAAO,CAAC,gBAAgB;YAC/C,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,MAAO,CAAC,gBAAgB,CAAC,CAAC,MAAM,CAC1C,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,MAAO,CAAC,gBAAiB,CAAC,CAAC,CAAC,EAAE,CAAC,EACvD,EAAE,CACH;YACH,CAAC,CAAC,EAAE,CAAC;YACL,CAAC,IAAI,CAAC,oBAAoB,GAAG,MAAM,CAAC,oBAAoB,CAAC,CAAC;QAC5D,IAAI,CAAC,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC;QAChC,YAAY,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IAClC,CAAC;IACD,IAAI,EAAE;QACJ,OAAO,IAAI,CAAC,GAAG,CAAC;IAClB,CAAC;IACD,IAAI,EAAE,CAAC,KAAa;QAClB,IAAI,CAAC,GAAG,GAAG,KAAK,CAAC;IACnB,CAAC;IACD,IAAI,kBAAkB;QACpB,OAAO,IAAI,CAAC,mBAAmB,CAAC;IAClC,CAAC;IACD,IAAI,kBAAkB,CAAC,KAAe;QACpC,IAAI,CAAC,mBAAmB,GAAG,KAAK,CAAC;IACnC,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,KAAa;QACtB,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;IACvB,CAAC;IACD,IAAI,gBAAgB;QAClB,OAAO,IAAI,CAAC,iBAAiB,CAAC;IAChC,CAAC;IACD,IAAI,gBAAgB,CAAC,KAAiC;QACpD,IAAI,CAAC,iBAAiB,GAAG,KAAK,CAAC;IACjC,CAAC;IACD,IAAI,oBAAoB;QACtB,OAAO,IAAI,CAAC,qBAAqB,CAAC;IACpC,CAAC;IACD,IAAI,oBAAoB,CAAC,KAAa;QACpC,IAAI,CAAC,qBAAqB,GAAG,KAAK,CAAC;IACrC,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;IAED;;;OAGG;IACH,eAAe;QACb,MAAM,MAAM,GAAG,IAAI,YAAY,EAAE,CAAC;QAClC,YAAY,CAAC,uBAAuB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QACnD,OAAO,MAAM,CAAC,eAAe,EAAE,CAAC;IAClC,CAAC;IAED;;OAEG;IACH,QAAQ;QACN,OAAO;YACL,EAAE,EAAE,IAAI,CAAC,EAAE;YACX,kBAAkB,EAAE,CAAC,IAAI,CAAC,kBAAkB,IAAI,EAAE,CAAC,CAAC,KAAK,EAAE;YAC3D,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,gBAAgB,EAAE,IAAI,CAAC,gBAAgB;gBACrC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC,MAAM,CACvC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,gBAAiB,CAAC,CAAC,CAAC,EAAE,CAAC,EACpD,EAAE,CACH;gBACH,CAAC,CAAC,EAAE;YACN,oBAAoB,EAAE,IAAI,CAAC,oBAAoB;YAC/C,QAAQ,EAAE,IAAI,CAAC,QAAQ;SACxB,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,EAAE,EAAE,IAAI,CAAC,EAAE;YACX,kBAAkB,EAAE,CAAC,IAAI,CAAC,kBAAkB,IAAI,EAAE,CAAC,CAAC,KAAK,EAAE;YAC3D,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,gBAAgB,EAAE,IAAI,CAAC,gBAAgB;gBACrC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC,MAAM,CACvC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,gBAAiB,CAAC,CAAC,CAAC,EAAE,CAAC,EACpD,EAAE,CACH;gBACH,CAAC,CAAC,EAAE;YACN,oBAAoB,EAAE,IAAI,CAAC,oBAAoB;YAC/C,QAAQ,EAAE,IAAI,CAAC,QAAQ;SACxB,CAAC;IACJ,CAAC;;AA7PM,eAAE,GAAG,6CAA6C,CAAC;AA+P5D,WAAc,YAAY;IA2BxB;;OAEG;IACH,MAAa,qBAAqB;QAIhC;;;WAGG;QACH,MAAM,CAAC,iBAAiB,CAAC,KAAiB;YACxC,MAAM,QAAQ,GAAG,IAAI,qBAAqB,EAAE,CAAC;YAC7C,qBAAqB,CAAC,2BAA2B,CAC/C,QAAQ,EACR,IAAI,YAAY,CAAC,KAAK,CAAC,CACxB,CAAC;YACF,OAAO,QAAQ,CAAC;QAClB,CAAC;QAED;;;WAGG;QACH,MAAM,CAAC,YAAY,CAAC,SAAgC;YAClD,SAAS,CAAC,GAAG,GAAG,SAAS,CAAC,GAAG,IAAI,EAAE,CAAC;YACpC,SAAS,CAAC,KAAK,GAAG,SAAS,CAAC,KAAK,IAAI,EAAE,CAAC;QAC1C,CAAC;QAED;;;;WAIG;QACH,MAAM,CAAC,2BAA2B,CAChC,SAAgC,EAChC,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,GAAG,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;wBACrC,MAAM;oBACR,KAAK,CAAC;wBACJ,SAAS,CAAC,KAAK,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;wBACvC,MAAM;oBACR;wBACE,OAAO,CAAC,SAAS,EAAE,CAAC;iBACvB;aACF;YAED,qBAAqB,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;QAChD,CAAC;QAED;;;;WAIG;QACH,MAAM,CAAC,uBAAuB,CAC5B,SAAgC,EAChC,OAAqB;YAErB,IAAI,SAAS,CAAC,GAAG,EAAE;gBACjB,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,SAAS,CAAC,GAAG,CAAC,CAAC;aACvC;YACD,IAAI,SAAS,CAAC,KAAK,EAAE;gBACnB,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,SAAS,CAAC,KAAK,CAAC,CAAC;aACzC;QACH,CAAC;QAKD;;;WAGG;QACH,YAAY,MAAyD;YACnE,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;YACtB,IAAI,CAAC,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC;YACtB,IAAI,CAAC,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;YAC1B,qBAAqB,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;QAC3C,CAAC;QACD,IAAI,GAAG;YACL,OAAO,IAAI,CAAC,IAAI,CAAC;QACnB,CAAC;QACD,IAAI,GAAG,CAAC,KAAa;YACnB,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC;QACpB,CAAC;QACD,IAAI,KAAK;YACP,OAAO,IAAI,CAAC,MAAM,CAAC;QACrB,CAAC;QACD,IAAI,KAAK,CAAC,KAAa;YACrB,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;QACtB,CAAC;QAED;;;WAGG;QACH,eAAe;YACb,MAAM,MAAM,GAAG,IAAI,YAAY,EAAE,CAAC;YAClC,qBAAqB,CAAC,uBAAuB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;YAC5D,OAAO,MAAM,CAAC,eAAe,EAAE,CAAC;QAClC,CAAC;QAED;;WAEG;QACH,QAAQ;YACN,OAAO;gBACL,GAAG,EAAE,IAAI,CAAC,GAAG;gBACb,KAAK,EAAE,IAAI,CAAC,KAAK;aAClB,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,GAAG,EAAE,IAAI,CAAC,GAAG;gBACb,KAAK,EAAE,IAAI,CAAC,KAAK;aAClB,CAAC;QACJ,CAAC;;IAvIM,wBAAE,GACP,mEAAmE,CAAC;IAF3D,kCAAqB,wBAyIjC,CAAA;AAkBH,CAAC,EAzLa,YAAY,KAAZ,YAAY,QAyLzB;AAED;;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,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,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,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,qBAAqB,CAAC,MAAM,EAAE,CAAC;oBACtD,OAAO,CAAC,WAAW,CACjB,SAAS,CAAC,MAAM,EAChB,qBAAqB,CAAC,MAAM,CAAC,2BAA2B,CACzD,CAAC;oBACF,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,IAAI,GAAG,IAAI,qBAAqB,CAAC,IAAI,EAAE,CAAC;oBAClD,OAAO,CAAC,WAAW,CACjB,SAAS,CAAC,IAAI,EACd,qBAAqB,CAAC,IAAI,CAAC,2BAA2B,CACvD,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,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,qBAAqB,CAAC,MAAM,CAAC,uBAAuB,CACrD,CAAC;SACH;QACD,IAAI,SAAS,CAAC,IAAI,EAAE;YAClB,OAAO,CAAC,YAAY,CAClB,CAAC,EACD,SAAS,CAAC,IAAW,EACrB,qBAAqB,CAAC,IAAI,CAAC,uBAAuB,CACnD,CAAC;SACH;IACH,CAAC;IAOD;;;OAGG;IACH,YAAY,MAAyD;QACnE,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,qBAAqB,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC;YACjD,CAAC,CAAC,SAAS,CAAC;QACd,IAAI,CAAC,IAAI,GAAG,MAAM,CAAC,IAAI;YACrB,CAAC,CAAC,IAAI,qBAAqB,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC;YAC7C,CAAC,CAAC,SAAS,CAAC;QACd,qBAAqB,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IAC3C,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,KAA+C;QACxD,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;IACvB,CAAC;IACD,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IACD,IAAI,IAAI,CAAC,KAA6C;QACpD,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACrB,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,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,wBAAE,GAAG,sDAAsD,CAAC;AA8LrE,WAAc,qBAAqB;IAoBjC,IAAY,YAQX;IARD,WAAY,YAAY;QACtB,2FAA8B,CAAA;QAC9B,yEAAqB,CAAA;QACrB,6GAAuC,CAAA;QACvC,6FAA+B,CAAA;QAC/B,mFAA0B,CAAA;QAC1B,+GAAwC,CAAA;QACxC,qFAA2B,CAAA;IAC7B,CAAC,EARW,YAAY,GAAZ,kCAAY,KAAZ,kCAAY,QAQvB;IACD,IAAY,cAIX;IAJD,WAAY,cAAc;QACxB,iGAA+B,CAAA;QAC/B,iFAAuB,CAAA;QACvB,mFAAwB,CAAA;IAC1B,CAAC,EAJW,cAAc,GAAd,oCAAc,KAAd,oCAAc,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,EAAE,GAAG,SAAS,CAAC,EAAE,IAAI,EAAE,CAAC;YAClC,SAAS,CAAC,iBAAiB,GAAG,SAAS,CAAC,iBAAiB,IAAI,EAAE,CAAC;YAChE,SAAS,CAAC,WAAW,GAAG,SAAS,CAAC,WAAW,IAAI,CAAC,CAAC;YACnD,SAAS,CAAC,MAAM,GAAG,SAAS,CAAC,MAAM,IAAI,CAAC,CAAC;YACzC,SAAS,CAAC,oBAAoB,GAAG,SAAS,CAAC,oBAAoB,IAAI,CAAC,CAAC;YACrE,SAAS,CAAC,QAAQ,GAAG,SAAS,CAAC,QAAQ,IAAI,CAAC,CAAC;QAC/C,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,EAAE,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;wBACpC,MAAM;oBACR,KAAK,CAAC;wBACJ,SAAS,CAAC,iBAAiB,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;wBACnD,MAAM;oBACR,KAAK,CAAC;wBACJ,SAAS,CAAC,WAAW,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;wBAC5C,MAAM;oBACR,KAAK,CAAC;wBACJ,SAAS,CAAC,MAAM,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;wBACvC,MAAM;oBACR,KAAK,CAAC;wBACJ,SAAS,CAAC,oBAAoB,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;wBACrD,MAAM;oBACR,KAAK,CAAC;wBACJ,SAAS,CAAC,QAAQ,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;wBACzC,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,EAAE,EAAE;gBAChB,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,SAAS,CAAC,EAAE,CAAC,CAAC;aACtC;YACD,IAAI,SAAS,CAAC,iBAAiB,EAAE;gBAC/B,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,SAAS,CAAC,iBAAiB,CAAC,CAAC;aACrD;YACD,IAAI,SAAS,CAAC,WAAW,EAAE;gBACzB,OAAO,CAAC,UAAU,CAAC,CAAC,EAAE,SAAS,CAAC,WAAW,CAAC,CAAC;aAC9C;YACD,IAAI,SAAS,CAAC,MAAM,EAAE;gBACpB,OAAO,CAAC,UAAU,CAAC,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;aACzC;YACD,IAAI,SAAS,CAAC,oBAAoB,EAAE;gBAClC,OAAO,CAAC,UAAU,CAAC,CAAC,EAAE,SAAS,CAAC,oBAAoB,CAAC,CAAC;aACvD;YACD,IAAI,SAAS,CAAC,QAAQ,EAAE;gBACtB,OAAO,CAAC,UAAU,CAAC,CAAC,EAAE,SAAS,CAAC,QAAQ,CAAC,CAAC;aAC3C;QACH,CAAC;QASD;;;WAGG;QACH,YAAY,MAA0C;YACpD,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;YACtB,IAAI,CAAC,EAAE,GAAG,MAAM,CAAC,EAAE,CAAC;YACpB,IAAI,CAAC,iBAAiB,GAAG,MAAM,CAAC,iBAAiB,CAAC;YAClD,IAAI,CAAC,WAAW,GAAG,MAAM,CAAC,WAAW,CAAC;YACtC,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;YAC5B,IAAI,CAAC,oBAAoB,GAAG,MAAM,CAAC,oBAAoB,CAAC;YACxD,IAAI,CAAC,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC;YAChC,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;QAC5B,CAAC;QACD,IAAI,EAAE;YACJ,OAAO,IAAI,CAAC,GAAG,CAAC;QAClB,CAAC;QACD,IAAI,EAAE,CAAC,KAAa;YAClB,IAAI,CAAC,GAAG,GAAG,KAAK,CAAC;QACnB,CAAC;QACD,IAAI,iBAAiB;YACnB,OAAO,IAAI,CAAC,kBAAkB,CAAC;QACjC,CAAC;QACD,IAAI,iBAAiB,CAAC,KAAa;YACjC,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC;QAClC,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,KAAa;YACtB,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;QACvB,CAAC;QACD,IAAI,oBAAoB;YACtB,OAAO,IAAI,CAAC,qBAAqB,CAAC;QACpC,CAAC;QACD,IAAI,oBAAoB,CAAC,KAAa;YACpC,IAAI,CAAC,qBAAqB,GAAG,KAAK,CAAC;QACrC,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;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,EAAE,EAAE,IAAI,CAAC,EAAE;gBACX,iBAAiB,EAAE,IAAI,CAAC,iBAAiB;gBACzC,WAAW,EAAE,IAAI,CAAC,WAAW;gBAC7B,MAAM,EAAE,IAAI,CAAC,MAAM;gBACnB,oBAAoB,EAAE,IAAI,CAAC,oBAAoB;gBAC/C,QAAQ,EAAE,IAAI,CAAC,QAAQ;aACxB,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,EAAE,EAAE,IAAI,CAAC,EAAE;gBACX,iBAAiB,EAAE,IAAI,CAAC,iBAAiB;gBACzC,WAAW,EAAE,IAAI,CAAC,WAAW;gBAC7B,MAAM,EAAE,IAAI,CAAC,MAAM;gBACnB,oBAAoB,EAAE,IAAI,CAAC,oBAAoB;gBAC/C,QAAQ,EAAE,IAAI,CAAC,QAAQ;aACxB,CAAC;QACJ,CAAC;;IApMM,SAAE,GAAG,6DAA6D,CAAC;IAD/D,4BAAM,SAsMlB,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,KAAyC;YACjD,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;QACtB,CAAC;QACD,IAAI,SAAS;YACX,OAAO,IAAI,CAAC,UAAU,CAAC;QACzB,CAAC;QACD,IAAI,SAAS,CAAC,KAA2C;YACvD,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,qBAAqB,CAAC,YAAY,CAChC,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,qBAAqB,CAAC,cAAc,CAClC,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,2DAA2D,CAAC;IAD7D,0BAAI,OAuIhB,CAAA;AAkBH,CAAC,EAlaa,qBAAqB,KAArB,qBAAqB,QAkalC;AAED;;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,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,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,YAAY,EAAE,CAAC;oBAC/C,OAAO,CAAC,WAAW,CACjB,mBAAmB,EACnB,YAAY,CAAC,2BAA2B,CACzC,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,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,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,YAAY,CAAC,uBAAuB,CACrC,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,MAA0D;QACpE,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;QACtB,IAAI,CAAC,UAAU,GAAG,CAAC,MAAM,CAAC,UAAU,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC;QAC1E,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,sBAAsB,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IAC5C,CAAC;IACD,IAAI,UAAU;QACZ,OAAO,IAAI,CAAC,WAAW,CAAC;IAC1B,CAAC;IACD,IAAI,UAAU,CAAC,KAAiC;QAC9C,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC;IAC3B,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,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,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,UAAU,EAAE,CAAC,IAAI,CAAC,UAAU,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;YACvE,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,QAAQ,EAAE,IAAI,CAAC,QAAQ;YACvB,KAAK,EAAE,IAAI,CAAC,KAAK;SAClB,CAAC;IACJ,CAAC;;AAnLM,yBAAE,GAAG,uDAAuD,CAAC;AA2MtE;;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,EAAE,GAAG,SAAS,CAAC,EAAE,IAAI,EAAE,CAAC;IACpC,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,SAAS,CAAC,EAAE,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;oBACpC,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,EAAE,EAAE;YAChB,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,SAAS,CAAC,EAAE,CAAC,CAAC;SACtC;IACH,CAAC;IAID;;;OAGG;IACH,YAAY,MAAuD;QACjE,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;QACtB,IAAI,CAAC,EAAE,GAAG,MAAM,CAAC,EAAE,CAAC;QACpB,mBAAmB,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IACzC,CAAC;IACD,IAAI,EAAE;QACJ,OAAO,IAAI,CAAC,GAAG,CAAC;IAClB,CAAC;IACD,IAAI,EAAE,CAAC,KAAa;QAClB,IAAI,CAAC,GAAG,GAAG,KAAK,CAAC;IACnB,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,EAAE,EAAE,IAAI,CAAC,EAAE;SACZ,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,EAAE,EAAE,IAAI,CAAC,EAAE;SACZ,CAAC;IACJ,CAAC;;AArHM,sBAAE,GAAG,oDAAoD,CAAC;AAuInE;;GAEG;AACH,MAAM,OAAO,oBAAoB;IAG/B;;;OAGG;IACH,MAAM,CAAC,iBAAiB,CAAC,KAAiB;QACxC,MAAM,QAAQ,GAAG,IAAI,oBAAoB,EAAE,CAAC;QAC5C,oBAAoB,CAAC,2BAA2B,CAC9C,QAAQ,EACR,IAAI,YAAY,CAAC,KAAK,CAAC,CACxB,CAAC;QACF,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,YAAY,CAAC,SAA+B;QACjD,SAAS,CAAC,SAAS,GAAG,SAAS,CAAC,SAAS,IAAI,SAAS,CAAC;IACzD,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,2BAA2B,CAChC,SAA+B,EAC/B,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,IAAI,YAAY,EAAE,CAAC;oBACzC,OAAO,CAAC,WAAW,CACjB,SAAS,CAAC,SAAS,EACnB,YAAY,CAAC,2BAA2B,CACzC,CAAC;oBACF,MAAM;gBACR;oBACE,OAAO,CAAC,SAAS,EAAE,CAAC;aACvB;SACF;QAED,oBAAoB,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;IAC/C,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,uBAAuB,CAC5B,SAA+B,EAC/B,OAAqB;QAErB,IAAI,SAAS,CAAC,SAAS,EAAE;YACvB,OAAO,CAAC,YAAY,CAClB,CAAC,EACD,SAAS,CAAC,SAAgB,EAC1B,YAAY,CAAC,uBAAuB,CACrC,CAAC;SACH;IACH,CAAC;IAID;;;OAGG;IACH,YAAY,MAAwD;QAClE,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;QACtB,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC,SAAS;YAC/B,CAAC,CAAC,IAAI,YAAY,CAAC,MAAM,CAAC,SAAS,CAAC;YACpC,CAAC,CAAC,SAAS,CAAC;QACd,oBAAoB,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IAC1C,CAAC;IACD,IAAI,SAAS;QACX,OAAO,IAAI,CAAC,UAAU,CAAC;IACzB,CAAC;IACD,IAAI,SAAS,CAAC,KAA+B;QAC3C,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;IAC1B,CAAC;IAED;;;OAGG;IACH,eAAe;QACb,MAAM,MAAM,GAAG,IAAI,YAAY,EAAE,CAAC;QAClC,oBAAoB,CAAC,uBAAuB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QAC3D,OAAO,MAAM,CAAC,eAAe,EAAE,CAAC;IAClC,CAAC;IAED;;OAEG;IACH,QAAQ;QACN,OAAO;YACL,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,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI;SAC1E,CAAC;IACJ,CAAC;;AA/HM,uBAAE,GAAG,qDAAqD,CAAC","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';\n\n/**\n * Message implementation for armonik.api.grpc.v1.partitions.PartitionRaw\n */\nexport class PartitionRaw implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.partitions.PartitionRaw';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new PartitionRaw();\n    PartitionRaw.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: PartitionRaw) {\n    _instance.id = _instance.id || '';\n    _instance.parentPartitionIds = _instance.parentPartitionIds || [];\n    _instance.podReserved = _instance.podReserved || '0';\n    _instance.podMax = _instance.podMax || '0';\n    _instance.podConfiguration = _instance.podConfiguration || {};\n    _instance.preemptionPercentage = _instance.preemptionPercentage || '0';\n    _instance.priority = _instance.priority || '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: PartitionRaw,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.id = _reader.readString();\n          break;\n        case 2:\n          (_instance.parentPartitionIds =\n            _instance.parentPartitionIds || []).push(_reader.readString());\n          break;\n        case 3:\n          _instance.podReserved = _reader.readInt64String();\n          break;\n        case 4:\n          _instance.podMax = _reader.readInt64String();\n          break;\n        case 7:\n          const msg_7 = {} as any;\n          _reader.readMessage(\n            msg_7,\n            PartitionRaw.PodConfigurationEntry.deserializeBinaryFromReader\n          );\n          _instance.podConfiguration = _instance.podConfiguration || {};\n          _instance.podConfiguration[msg_7.key] = msg_7.value;\n          break;\n        case 5:\n          _instance.preemptionPercentage = _reader.readInt64String();\n          break;\n        case 6:\n          _instance.priority = _reader.readInt64String();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    PartitionRaw.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: PartitionRaw,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.id) {\n      _writer.writeString(1, _instance.id);\n    }\n    if (_instance.parentPartitionIds && _instance.parentPartitionIds.length) {\n      _writer.writeRepeatedString(2, _instance.parentPartitionIds);\n    }\n    if (_instance.podReserved) {\n      _writer.writeInt64String(3, _instance.podReserved);\n    }\n    if (_instance.podMax) {\n      _writer.writeInt64String(4, _instance.podMax);\n    }\n    if (!!_instance.podConfiguration) {\n      const keys_7 = Object.keys(_instance.podConfiguration as any);\n\n      if (keys_7.length) {\n        const repeated_7 = keys_7\n          .map(key => ({\n            key: key,\n            value: (_instance.podConfiguration as any)[key]\n          }))\n          .reduce((r, v) => [...r, v], [] as any[]);\n\n        _writer.writeRepeatedMessage(\n          7,\n          repeated_7,\n          PartitionRaw.PodConfigurationEntry.serializeBinaryToWriter\n        );\n      }\n    }\n    if (_instance.preemptionPercentage) {\n      _writer.writeInt64String(5, _instance.preemptionPercentage);\n    }\n    if (_instance.priority) {\n      _writer.writeInt64String(6, _instance.priority);\n    }\n  }\n\n  private _id: string;\n  private _parentPartitionIds: string[];\n  private _podReserved: string;\n  private _podMax: string;\n  private _podConfiguration: { [prop: string]: string };\n  private _preemptionPercentage: string;\n  private _priority: 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 PartitionRaw to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<PartitionRaw.AsObject>) {\n    _value = _value || {};\n    this.id = _value.id;\n    this.parentPartitionIds = (_value.parentPartitionIds || []).slice();\n    this.podReserved = _value.podReserved;\n    this.podMax = _value.podMax;\n    (this.podConfiguration = _value!.podConfiguration\n      ? Object.keys(_value!.podConfiguration).reduce(\n          (r, k) => ({ ...r, [k]: _value!.podConfiguration![k] }),\n          {}\n        )\n      : {}),\n      (this.preemptionPercentage = _value.preemptionPercentage);\n    this.priority = _value.priority;\n    PartitionRaw.refineValues(this);\n  }\n  get id(): string {\n    return this._id;\n  }\n  set id(value: string) {\n    this._id = value;\n  }\n  get parentPartitionIds(): string[] {\n    return this._parentPartitionIds;\n  }\n  set parentPartitionIds(value: string[]) {\n    this._parentPartitionIds = value;\n  }\n  get podReserved(): string {\n    return this._podReserved;\n  }\n  set podReserved(value: string) {\n    this._podReserved = value;\n  }\n  get podMax(): string {\n    return this._podMax;\n  }\n  set podMax(value: string) {\n    this._podMax = value;\n  }\n  get podConfiguration(): { [prop: string]: string } {\n    return this._podConfiguration;\n  }\n  set podConfiguration(value: { [prop: string]: string }) {\n    this._podConfiguration = value;\n  }\n  get preemptionPercentage(): string {\n    return this._preemptionPercentage;\n  }\n  set preemptionPercentage(value: string) {\n    this._preemptionPercentage = value;\n  }\n  get priority(): string {\n    return this._priority;\n  }\n  set priority(value: string) {\n    this._priority = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    PartitionRaw.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(): PartitionRaw.AsObject {\n    return {\n      id: this.id,\n      parentPartitionIds: (this.parentPartitionIds || []).slice(),\n      podReserved: this.podReserved,\n      podMax: this.podMax,\n      podConfiguration: this.podConfiguration\n        ? Object.keys(this.podConfiguration).reduce(\n            (r, k) => ({ ...r, [k]: this.podConfiguration![k] }),\n            {}\n          )\n        : {},\n      preemptionPercentage: this.preemptionPercentage,\n      priority: this.priority\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  ): PartitionRaw.AsProtobufJSON {\n    return {\n      id: this.id,\n      parentPartitionIds: (this.parentPartitionIds || []).slice(),\n      podReserved: this.podReserved,\n      podMax: this.podMax,\n      podConfiguration: this.podConfiguration\n        ? Object.keys(this.podConfiguration).reduce(\n            (r, k) => ({ ...r, [k]: this.podConfiguration![k] }),\n            {}\n          )\n        : {},\n      preemptionPercentage: this.preemptionPercentage,\n      priority: this.priority\n    };\n  }\n}\nexport module PartitionRaw {\n  /**\n   * Standard JavaScript object representation for PartitionRaw\n   */\n  export interface AsObject {\n    id: string;\n    parentPartitionIds: string[];\n    podReserved: string;\n    podMax: string;\n    podConfiguration: { [prop: string]: string };\n    preemptionPercentage: string;\n    priority: string;\n  }\n\n  /**\n   * Protobuf JSON representation for PartitionRaw\n   */\n  export interface AsProtobufJSON {\n    id: string;\n    parentPartitionIds: string[];\n    podReserved: string;\n    podMax: string;\n    podConfiguration: { [prop: string]: string };\n    preemptionPercentage: string;\n    priority: string;\n  }\n\n  /**\n   * Message implementation for armonik.api.grpc.v1.partitions.PartitionRaw.PodConfigurationEntry\n   */\n  export class PodConfigurationEntry implements GrpcMessage {\n    static id =\n      'armonik.api.grpc.v1.partitions.PartitionRaw.PodConfigurationEntry';\n\n    /**\n     * Deserialize binary data to message\n     * @param instance message instance\n     */\n    static deserializeBinary(bytes: ByteSource) {\n      const instance = new PodConfigurationEntry();\n      PodConfigurationEntry.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: PodConfigurationEntry) {\n      _instance.key = _instance.key || '';\n      _instance.value = _instance.value || '';\n    }\n\n    /**\n     * Deserializes / reads binary message into message instance using provided binary reader\n     * @param _instance message instance\n     * @param _reader binary reader instance\n     */\n    static deserializeBinaryFromReader(\n      _instance: PodConfigurationEntry,\n      _reader: BinaryReader\n    ) {\n      while (_reader.nextField()) {\n        if (_reader.isEndGroup()) break;\n\n        switch (_reader.getFieldNumber()) {\n          case 1:\n            _instance.key = _reader.readString();\n            break;\n          case 2:\n            _instance.value = _reader.readString();\n            break;\n          default:\n            _reader.skipField();\n        }\n      }\n\n      PodConfigurationEntry.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: PodConfigurationEntry,\n      _writer: BinaryWriter\n    ) {\n      if (_instance.key) {\n        _writer.writeString(1, _instance.key);\n      }\n      if (_instance.value) {\n        _writer.writeString(2, _instance.value);\n      }\n    }\n\n    private _key: string;\n    private _value: string;\n\n    /**\n     * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n     * @param _value initial values object or instance of PodConfigurationEntry to deeply clone from\n     */\n    constructor(_value?: RecursivePartial<PodConfigurationEntry.AsObject>) {\n      _value = _value || {};\n      this.key = _value.key;\n      this.value = _value.value;\n      PodConfigurationEntry.refineValues(this);\n    }\n    get key(): string {\n      return this._key;\n    }\n    set key(value: string) {\n      this._key = value;\n    }\n    get value(): string {\n      return this._value;\n    }\n    set value(value: string) {\n      this._value = value;\n    }\n\n    /**\n     * Serialize message to binary data\n     * @param instance message instance\n     */\n    serializeBinary() {\n      const writer = new BinaryWriter();\n      PodConfigurationEntry.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(): PodConfigurationEntry.AsObject {\n      return {\n        key: this.key,\n        value: this.value\n      };\n    }\n\n    /**\n     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()\n     */\n    toJSON() {\n      return this.toObject();\n    }\n\n    /**\n     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json\n     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.\n     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required\n     */\n    toProtobufJSON(\n      // @ts-ignore\n      options?: ToProtobufJSONOptions\n    ): PodConfigurationEntry.AsProtobufJSON {\n      return {\n        key: this.key,\n        value: this.value\n      };\n    }\n  }\n  export module PodConfigurationEntry {\n    /**\n     * Standard JavaScript object representation for PodConfigurationEntry\n     */\n    export interface AsObject {\n      key: string;\n      value: string;\n    }\n\n    /**\n     * Protobuf JSON representation for PodConfigurationEntry\n     */\n    export interface AsProtobufJSON {\n      key: string;\n      value: string;\n    }\n  }\n}\n\n/**\n * Message implementation for armonik.api.grpc.v1.partitions.ListPartitionsRequest\n */\nexport class ListPartitionsRequest implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.partitions.ListPartitionsRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new ListPartitionsRequest();\n    ListPartitionsRequest.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: ListPartitionsRequest) {\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: ListPartitionsRequest,\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 ListPartitionsRequest.Filter();\n          _reader.readMessage(\n            _instance.filter,\n            ListPartitionsRequest.Filter.deserializeBinaryFromReader\n          );\n          break;\n        case 4:\n          _instance.sort = new ListPartitionsRequest.Sort();\n          _reader.readMessage(\n            _instance.sort,\n            ListPartitionsRequest.Sort.deserializeBinaryFromReader\n          );\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    ListPartitionsRequest.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: ListPartitionsRequest,\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        ListPartitionsRequest.Filter.serializeBinaryToWriter\n      );\n    }\n    if (_instance.sort) {\n      _writer.writeMessage(\n        4,\n        _instance.sort as any,\n        ListPartitionsRequest.Sort.serializeBinaryToWriter\n      );\n    }\n  }\n\n  private _page: number;\n  private _pageSize: number;\n  private _filter?: ListPartitionsRequest.Filter;\n  private _sort?: ListPartitionsRequest.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 ListPartitionsRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<ListPartitionsRequest.AsObject>) {\n    _value = _value || {};\n    this.page = _value.page;\n    this.pageSize = _value.pageSize;\n    this.filter = _value.filter\n      ? new ListPartitionsRequest.Filter(_value.filter)\n      : undefined;\n    this.sort = _value.sort\n      ? new ListPartitionsRequest.Sort(_value.sort)\n      : undefined;\n    ListPartitionsRequest.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(): ListPartitionsRequest.Filter | undefined {\n    return this._filter;\n  }\n  set filter(value: ListPartitionsRequest.Filter | undefined) {\n    this._filter = value;\n  }\n  get sort(): ListPartitionsRequest.Sort | undefined {\n    return this._sort;\n  }\n  set sort(value: ListPartitionsRequest.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    ListPartitionsRequest.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(): ListPartitionsRequest.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  ): ListPartitionsRequest.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 ListPartitionsRequest {\n  /**\n   * Standard JavaScript object representation for ListPartitionsRequest\n   */\n  export interface AsObject {\n    page: number;\n    pageSize: number;\n    filter?: ListPartitionsRequest.Filter.AsObject;\n    sort?: ListPartitionsRequest.Sort.AsObject;\n  }\n\n  /**\n   * Protobuf JSON representation for ListPartitionsRequest\n   */\n  export interface AsProtobufJSON {\n    page: number;\n    pageSize: number;\n    filter: ListPartitionsRequest.Filter.AsProtobufJSON | null;\n    sort: ListPartitionsRequest.Sort.AsProtobufJSON | null;\n  }\n  export enum OrderByField {\n    ORDER_BY_FIELD_UNSPECIFIED = 0,\n    ORDER_BY_FIELD_ID = 1,\n    ORDER_BY_FIELD_PARENT_PARTITION_IDS = 2,\n    ORDER_BY_FIELD_POD_RESERVED = 3,\n    ORDER_BY_FIELD_POD_MAX = 4,\n    ORDER_BY_FIELD_PREEMPTION_PERCENTAGE = 5,\n    ORDER_BY_FIELD_PRIORITY = 6\n  }\n  export enum OrderDirection {\n    ORDER_DIRECTION_UNSPECIFIED = 0,\n    ORDER_DIRECTION_ASC = 1,\n    ORDER_DIRECTION_DESC = 2\n  }\n  /**\n   * Message implementation for armonik.api.grpc.v1.partitions.ListPartitionsRequest.Filter\n   */\n  export class Filter implements GrpcMessage {\n    static id = 'armonik.api.grpc.v1.partitions.ListPartitionsRequest.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.id = _instance.id || '';\n      _instance.parentPartitionId = _instance.parentPartitionId || '';\n      _instance.podReserved = _instance.podReserved || 0;\n      _instance.podMax = _instance.podMax || 0;\n      _instance.preemptionPercentage = _instance.preemptionPercentage || 0;\n      _instance.priority = _instance.priority || 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: Filter,\n      _reader: BinaryReader\n    ) {\n      while (_reader.nextField()) {\n        if (_reader.isEndGroup()) break;\n\n        switch (_reader.getFieldNumber()) {\n          case 1:\n            _instance.id = _reader.readString();\n            break;\n          case 2:\n            _instance.parentPartitionId = _reader.readString();\n            break;\n          case 3:\n            _instance.podReserved = _reader.readInt32();\n            break;\n          case 4:\n            _instance.podMax = _reader.readInt32();\n            break;\n          case 5:\n            _instance.preemptionPercentage = _reader.readInt32();\n            break;\n          case 6:\n            _instance.priority = _reader.readInt32();\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.id) {\n        _writer.writeString(1, _instance.id);\n      }\n      if (_instance.parentPartitionId) {\n        _writer.writeString(2, _instance.parentPartitionId);\n      }\n      if (_instance.podReserved) {\n        _writer.writeInt32(3, _instance.podReserved);\n      }\n      if (_instance.podMax) {\n        _writer.writeInt32(4, _instance.podMax);\n      }\n      if (_instance.preemptionPercentage) {\n        _writer.writeInt32(5, _instance.preemptionPercentage);\n      }\n      if (_instance.priority) {\n        _writer.writeInt32(6, _instance.priority);\n      }\n    }\n\n    private _id: string;\n    private _parentPartitionId: string;\n    private _podReserved: number;\n    private _podMax: number;\n    private _preemptionPercentage: number;\n    private _priority: 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 Filter to deeply clone from\n     */\n    constructor(_value?: RecursivePartial<Filter.AsObject>) {\n      _value = _value || {};\n      this.id = _value.id;\n      this.parentPartitionId = _value.parentPartitionId;\n      this.podReserved = _value.podReserved;\n      this.podMax = _value.podMax;\n      this.preemptionPercentage = _value.preemptionPercentage;\n      this.priority = _value.priority;\n      Filter.refineValues(this);\n    }\n    get id(): string {\n      return this._id;\n    }\n    set id(value: string) {\n      this._id = value;\n    }\n    get parentPartitionId(): string {\n      return this._parentPartitionId;\n    }\n    set parentPartitionId(value: string) {\n      this._parentPartitionId = value;\n    }\n    get podReserved(): number {\n      return this._podReserved;\n    }\n    set podReserved(value: number) {\n      this._podReserved = value;\n    }\n    get podMax(): number {\n      return this._podMax;\n    }\n    set podMax(value: number) {\n      this._podMax = value;\n    }\n    get preemptionPercentage(): number {\n      return this._preemptionPercentage;\n    }\n    set preemptionPercentage(value: number) {\n      this._preemptionPercentage = value;\n    }\n    get priority(): number {\n      return this._priority;\n    }\n    set priority(value: number) {\n      this._priority = 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        id: this.id,\n        parentPartitionId: this.parentPartitionId,\n        podReserved: this.podReserved,\n        podMax: this.podMax,\n        preemptionPercentage: this.preemptionPercentage,\n        priority: this.priority\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        id: this.id,\n        parentPartitionId: this.parentPartitionId,\n        podReserved: this.podReserved,\n        podMax: this.podMax,\n        preemptionPercentage: this.preemptionPercentage,\n        priority: this.priority\n      };\n    }\n  }\n  export module Filter {\n    /**\n     * Standard JavaScript object representation for Filter\n     */\n    export interface AsObject {\n      id: string;\n      parentPartitionId: string;\n      podReserved: number;\n      podMax: number;\n      preemptionPercentage: number;\n      priority: number;\n    }\n\n    /**\n     * Protobuf JSON representation for Filter\n     */\n    export interface AsProtobufJSON {\n      id: string;\n      parentPartitionId: string;\n      podReserved: number;\n      podMax: number;\n      preemptionPercentage: number;\n      priority: number;\n    }\n  }\n\n  /**\n   * Message implementation for armonik.api.grpc.v1.partitions.ListPartitionsRequest.Sort\n   */\n  export class Sort implements GrpcMessage {\n    static id = 'armonik.api.grpc.v1.partitions.ListPartitionsRequest.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: ListPartitionsRequest.OrderByField;\n    private _direction: ListPartitionsRequest.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(): ListPartitionsRequest.OrderByField {\n      return this._field;\n    }\n    set field(value: ListPartitionsRequest.OrderByField) {\n      this._field = value;\n    }\n    get direction(): ListPartitionsRequest.OrderDirection {\n      return this._direction;\n    }\n    set direction(value: ListPartitionsRequest.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          ListPartitionsRequest.OrderByField[\n            this.field === null || this.field === undefined ? 0 : this.field\n          ],\n        direction:\n          ListPartitionsRequest.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: ListPartitionsRequest.OrderByField;\n      direction: ListPartitionsRequest.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.partitions.ListPartitionsResponse\n */\nexport class ListPartitionsResponse implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.partitions.ListPartitionsResponse';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new ListPartitionsResponse();\n    ListPartitionsResponse.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: ListPartitionsResponse) {\n    _instance.partitions = _instance.partitions || [];\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: ListPartitionsResponse,\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 PartitionRaw();\n          _reader.readMessage(\n            messageInitializer1,\n            PartitionRaw.deserializeBinaryFromReader\n          );\n          (_instance.partitions = _instance.partitions || []).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    ListPartitionsResponse.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: ListPartitionsResponse,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.partitions && _instance.partitions.length) {\n      _writer.writeRepeatedMessage(\n        1,\n        _instance.partitions as any,\n        PartitionRaw.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 _partitions?: PartitionRaw[];\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 ListPartitionsResponse to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<ListPartitionsResponse.AsObject>) {\n    _value = _value || {};\n    this.partitions = (_value.partitions || []).map(m => new PartitionRaw(m));\n    this.page = _value.page;\n    this.pageSize = _value.pageSize;\n    this.total = _value.total;\n    ListPartitionsResponse.refineValues(this);\n  }\n  get partitions(): PartitionRaw[] | undefined {\n    return this._partitions;\n  }\n  set partitions(value: PartitionRaw[] | undefined) {\n    this._partitions = 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    ListPartitionsResponse.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(): ListPartitionsResponse.AsObject {\n    return {\n      partitions: (this.partitions || []).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  ): ListPartitionsResponse.AsProtobufJSON {\n    return {\n      partitions: (this.partitions || []).map(m => m.toProtobufJSON(options)),\n      page: this.page,\n      pageSize: this.pageSize,\n      total: this.total\n    };\n  }\n}\nexport module ListPartitionsResponse {\n  /**\n   * Standard JavaScript object representation for ListPartitionsResponse\n   */\n  export interface AsObject {\n    partitions?: PartitionRaw.AsObject[];\n    page: number;\n    pageSize: number;\n    total: number;\n  }\n\n  /**\n   * Protobuf JSON representation for ListPartitionsResponse\n   */\n  export interface AsProtobufJSON {\n    partitions: PartitionRaw.AsProtobufJSON[] | null;\n    page: number;\n    pageSize: number;\n    total: number;\n  }\n}\n\n/**\n * Message implementation for armonik.api.grpc.v1.partitions.GetPartitionRequest\n */\nexport class GetPartitionRequest implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.partitions.GetPartitionRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new GetPartitionRequest();\n    GetPartitionRequest.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: GetPartitionRequest) {\n    _instance.id = _instance.id || '';\n  }\n\n  /**\n   * Deserializes / reads binary message into message instance using provided binary reader\n   * @param _instance message instance\n   * @param _reader binary reader instance\n   */\n  static deserializeBinaryFromReader(\n    _instance: GetPartitionRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.id = _reader.readString();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    GetPartitionRequest.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: GetPartitionRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.id) {\n      _writer.writeString(1, _instance.id);\n    }\n  }\n\n  private _id: string;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of GetPartitionRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<GetPartitionRequest.AsObject>) {\n    _value = _value || {};\n    this.id = _value.id;\n    GetPartitionRequest.refineValues(this);\n  }\n  get id(): string {\n    return this._id;\n  }\n  set id(value: string) {\n    this._id = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    GetPartitionRequest.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(): GetPartitionRequest.AsObject {\n    return {\n      id: this.id\n    };\n  }\n\n  /**\n   * Convenience method to support JSON.stringify(message), replicates the structure of toObject()\n   */\n  toJSON() {\n    return this.toObject();\n  }\n\n  /**\n   * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json\n   * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.\n   * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required\n   */\n  toProtobufJSON(\n    // @ts-ignore\n    options?: ToProtobufJSONOptions\n  ): GetPartitionRequest.AsProtobufJSON {\n    return {\n      id: this.id\n    };\n  }\n}\nexport module GetPartitionRequest {\n  /**\n   * Standard JavaScript object representation for GetPartitionRequest\n   */\n  export interface AsObject {\n    id: string;\n  }\n\n  /**\n   * Protobuf JSON representation for GetPartitionRequest\n   */\n  export interface AsProtobufJSON {\n    id: string;\n  }\n}\n\n/**\n * Message implementation for armonik.api.grpc.v1.partitions.GetPartitionResponse\n */\nexport class GetPartitionResponse implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.partitions.GetPartitionResponse';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new GetPartitionResponse();\n    GetPartitionResponse.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: GetPartitionResponse) {\n    _instance.partition = _instance.partition || 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: GetPartitionResponse,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.partition = new PartitionRaw();\n          _reader.readMessage(\n            _instance.partition,\n            PartitionRaw.deserializeBinaryFromReader\n          );\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    GetPartitionResponse.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: GetPartitionResponse,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.partition) {\n      _writer.writeMessage(\n        1,\n        _instance.partition as any,\n        PartitionRaw.serializeBinaryToWriter\n      );\n    }\n  }\n\n  private _partition?: PartitionRaw;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of GetPartitionResponse to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<GetPartitionResponse.AsObject>) {\n    _value = _value || {};\n    this.partition = _value.partition\n      ? new PartitionRaw(_value.partition)\n      : undefined;\n    GetPartitionResponse.refineValues(this);\n  }\n  get partition(): PartitionRaw | undefined {\n    return this._partition;\n  }\n  set partition(value: PartitionRaw | undefined) {\n    this._partition = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    GetPartitionResponse.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(): GetPartitionResponse.AsObject {\n    return {\n      partition: this.partition ? this.partition.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  ): GetPartitionResponse.AsProtobufJSON {\n    return {\n      partition: this.partition ? this.partition.toProtobufJSON(options) : null\n    };\n  }\n}\nexport module GetPartitionResponse {\n  /**\n   * Standard JavaScript object representation for GetPartitionResponse\n   */\n  export interface AsObject {\n    partition?: PartitionRaw.AsObject;\n  }\n\n  /**\n   * Protobuf JSON representation for GetPartitionResponse\n   */\n  export interface AsProtobufJSON {\n    partition: PartitionRaw.AsProtobufJSON | null;\n  }\n}\n"]}