@aneoconsultingfr/armonik.api.angular 3.11.0-edge.89.ab31d7c → 3.11.0

package/esm2022/lib/generated/filters-common.pb.mjs

@@ -0,0 +1,642 @@
+import { BinaryReader, BinaryWriter } from 'google-protobuf';
+import * as googleProtobuf000 from '@ngx-grpc/well-known-types';
+export var FilterStringOperator;
+(function (FilterStringOperator) {
+    FilterStringOperator[FilterStringOperator["FILTER_STRING_OPERATOR_EQUAL"] = 0] = "FILTER_STRING_OPERATOR_EQUAL";
+    FilterStringOperator[FilterStringOperator["FILTER_STRING_OPERATOR_NOT_EQUAL"] = 1] = "FILTER_STRING_OPERATOR_NOT_EQUAL";
+    FilterStringOperator[FilterStringOperator["FILTER_STRING_OPERATOR_CONTAINS"] = 2] = "FILTER_STRING_OPERATOR_CONTAINS";
+    FilterStringOperator[FilterStringOperator["FILTER_STRING_OPERATOR_NOT_CONTAINS"] = 3] = "FILTER_STRING_OPERATOR_NOT_CONTAINS";
+    FilterStringOperator[FilterStringOperator["FILTER_STRING_OPERATOR_STARTS_WITH"] = 4] = "FILTER_STRING_OPERATOR_STARTS_WITH";
+    FilterStringOperator[FilterStringOperator["FILTER_STRING_OPERATOR_ENDS_WITH"] = 5] = "FILTER_STRING_OPERATOR_ENDS_WITH";
+})(FilterStringOperator || (FilterStringOperator = {}));
+export var FilterNumberOperator;
+(function (FilterNumberOperator) {
+    FilterNumberOperator[FilterNumberOperator["FILTER_NUMBER_OPERATOR_EQUAL"] = 0] = "FILTER_NUMBER_OPERATOR_EQUAL";
+    FilterNumberOperator[FilterNumberOperator["FILTER_NUMBER_OPERATOR_NOT_EQUAL"] = 1] = "FILTER_NUMBER_OPERATOR_NOT_EQUAL";
+    FilterNumberOperator[FilterNumberOperator["FILTER_NUMBER_OPERATOR_LESS_THAN"] = 2] = "FILTER_NUMBER_OPERATOR_LESS_THAN";
+    FilterNumberOperator[FilterNumberOperator["FILTER_NUMBER_OPERATOR_LESS_THAN_OR_EQUAL"] = 3] = "FILTER_NUMBER_OPERATOR_LESS_THAN_OR_EQUAL";
+    FilterNumberOperator[FilterNumberOperator["FILTER_NUMBER_OPERATOR_GREATER_THAN_OR_EQUAL"] = 4] = "FILTER_NUMBER_OPERATOR_GREATER_THAN_OR_EQUAL";
+    FilterNumberOperator[FilterNumberOperator["FILTER_NUMBER_OPERATOR_GREATER_THAN"] = 5] = "FILTER_NUMBER_OPERATOR_GREATER_THAN";
+})(FilterNumberOperator || (FilterNumberOperator = {}));
+export var FilterDateOperator;
+(function (FilterDateOperator) {
+    FilterDateOperator[FilterDateOperator["FILTER_DATE_OPERATOR_EQUAL"] = 0] = "FILTER_DATE_OPERATOR_EQUAL";
+    FilterDateOperator[FilterDateOperator["FILTER_DATE_OPERATOR_NOT_EQUAL"] = 1] = "FILTER_DATE_OPERATOR_NOT_EQUAL";
+    FilterDateOperator[FilterDateOperator["FILTER_DATE_OPERATOR_BEFORE"] = 2] = "FILTER_DATE_OPERATOR_BEFORE";
+    FilterDateOperator[FilterDateOperator["FILTER_DATE_OPERATOR_BEFORE_OR_EQUAL"] = 3] = "FILTER_DATE_OPERATOR_BEFORE_OR_EQUAL";
+    FilterDateOperator[FilterDateOperator["FILTER_DATE_OPERATOR_AFTER_OR_EQUAL"] = 4] = "FILTER_DATE_OPERATOR_AFTER_OR_EQUAL";
+    FilterDateOperator[FilterDateOperator["FILTER_DATE_OPERATOR_AFTER"] = 5] = "FILTER_DATE_OPERATOR_AFTER";
+})(FilterDateOperator || (FilterDateOperator = {}));
+export var FilterArrayOperator;
+(function (FilterArrayOperator) {
+    FilterArrayOperator[FilterArrayOperator["FILTER_ARRAY_OPERATOR_CONTAINS"] = 0] = "FILTER_ARRAY_OPERATOR_CONTAINS";
+    FilterArrayOperator[FilterArrayOperator["FILTER_ARRAY_OPERATOR_NOT_CONTAINS"] = 1] = "FILTER_ARRAY_OPERATOR_NOT_CONTAINS";
+})(FilterArrayOperator || (FilterArrayOperator = {}));
+export var FilterStatusOperator;
+(function (FilterStatusOperator) {
+    FilterStatusOperator[FilterStatusOperator["FILTER_STATUS_OPERATOR_EQUAL"] = 0] = "FILTER_STATUS_OPERATOR_EQUAL";
+    FilterStatusOperator[FilterStatusOperator["FILTER_STATUS_OPERATOR_NOT_EQUAL"] = 1] = "FILTER_STATUS_OPERATOR_NOT_EQUAL";
+})(FilterStatusOperator || (FilterStatusOperator = {}));
+export var FilterBooleanOperator;
+(function (FilterBooleanOperator) {
+    FilterBooleanOperator[FilterBooleanOperator["FILTER_BOOLEAN_OPERATOR_IS"] = 0] = "FILTER_BOOLEAN_OPERATOR_IS";
+})(FilterBooleanOperator || (FilterBooleanOperator = {}));
+/**
+ * Message implementation for armonik.api.grpc.v1.FilterString
+ */
+export class FilterString {
+    static { this.id = 'armonik.api.grpc.v1.FilterString'; }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new FilterString();
+        FilterString.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.value = _instance.value || '';
+        _instance.operator = _instance.operator || 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.value = _reader.readString();
+                    break;
+                case 2:
+                    _instance.operator = _reader.readEnum();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        FilterString.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.value) {
+            _writer.writeString(1, _instance.value);
+        }
+        if (_instance.operator) {
+            _writer.writeEnum(2, _instance.operator);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of FilterString to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.value = _value.value;
+        this.operator = _value.operator;
+        FilterString.refineValues(this);
+    }
+    get value() {
+        return this._value;
+    }
+    set value(value) {
+        this._value = value;
+    }
+    get operator() {
+        return this._operator;
+    }
+    set operator(value) {
+        this._operator = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        FilterString.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            value: this.value,
+            operator: this.operator
+        };
+    }
+    /**
+     * 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 {
+            value: this.value,
+            operator: FilterStringOperator[this.operator === null || this.operator === undefined
+                ? 0
+                : this.operator]
+        };
+    }
+}
+/**
+ * Message implementation for armonik.api.grpc.v1.FilterNumber
+ */
+export class FilterNumber {
+    static { this.id = 'armonik.api.grpc.v1.FilterNumber'; }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new FilterNumber();
+        FilterNumber.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.value = _instance.value || '0';
+        _instance.operator = _instance.operator || 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.value = _reader.readInt64String();
+                    break;
+                case 2:
+                    _instance.operator = _reader.readEnum();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        FilterNumber.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.value) {
+            _writer.writeInt64String(1, _instance.value);
+        }
+        if (_instance.operator) {
+            _writer.writeEnum(2, _instance.operator);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of FilterNumber to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.value = _value.value;
+        this.operator = _value.operator;
+        FilterNumber.refineValues(this);
+    }
+    get value() {
+        return this._value;
+    }
+    set value(value) {
+        this._value = value;
+    }
+    get operator() {
+        return this._operator;
+    }
+    set operator(value) {
+        this._operator = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        FilterNumber.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            value: this.value,
+            operator: this.operator
+        };
+    }
+    /**
+     * 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 {
+            value: this.value,
+            operator: FilterNumberOperator[this.operator === null || this.operator === undefined
+                ? 0
+                : this.operator]
+        };
+    }
+}
+/**
+ * Message implementation for armonik.api.grpc.v1.FilterDate
+ */
+export class FilterDate {
+    static { this.id = 'armonik.api.grpc.v1.FilterDate'; }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new FilterDate();
+        FilterDate.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.value = _instance.value || undefined;
+        _instance.operator = _instance.operator || 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.value = new googleProtobuf000.Timestamp();
+                    _reader.readMessage(_instance.value, googleProtobuf000.Timestamp.deserializeBinaryFromReader);
+                    break;
+                case 2:
+                    _instance.operator = _reader.readEnum();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        FilterDate.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.value) {
+            _writer.writeMessage(1, _instance.value, googleProtobuf000.Timestamp.serializeBinaryToWriter);
+        }
+        if (_instance.operator) {
+            _writer.writeEnum(2, _instance.operator);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of FilterDate to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.value = _value.value
+            ? new googleProtobuf000.Timestamp(_value.value)
+            : undefined;
+        this.operator = _value.operator;
+        FilterDate.refineValues(this);
+    }
+    get value() {
+        return this._value;
+    }
+    set value(value) {
+        this._value = value;
+    }
+    get operator() {
+        return this._operator;
+    }
+    set operator(value) {
+        this._operator = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        FilterDate.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            value: this.value ? this.value.toObject() : undefined,
+            operator: this.operator
+        };
+    }
+    /**
+     * 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 {
+            value: this.value ? this.value.toProtobufJSON(options) : null,
+            operator: FilterDateOperator[this.operator === null || this.operator === undefined
+                ? 0
+                : this.operator]
+        };
+    }
+}
+/**
+ * Message implementation for armonik.api.grpc.v1.FilterArray
+ */
+export class FilterArray {
+    static { this.id = 'armonik.api.grpc.v1.FilterArray'; }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new FilterArray();
+        FilterArray.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.value = _instance.value || '';
+        _instance.operator = _instance.operator || 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.value = _reader.readString();
+                    break;
+                case 2:
+                    _instance.operator = _reader.readEnum();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        FilterArray.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.value) {
+            _writer.writeString(1, _instance.value);
+        }
+        if (_instance.operator) {
+            _writer.writeEnum(2, _instance.operator);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of FilterArray to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.value = _value.value;
+        this.operator = _value.operator;
+        FilterArray.refineValues(this);
+    }
+    get value() {
+        return this._value;
+    }
+    set value(value) {
+        this._value = value;
+    }
+    get operator() {
+        return this._operator;
+    }
+    set operator(value) {
+        this._operator = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        FilterArray.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            value: this.value,
+            operator: this.operator
+        };
+    }
+    /**
+     * 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 {
+            value: this.value,
+            operator: FilterArrayOperator[this.operator === null || this.operator === undefined
+                ? 0
+                : this.operator]
+        };
+    }
+}
+/**
+ * Message implementation for armonik.api.grpc.v1.FilterBoolean
+ */
+export class FilterBoolean {
+    static { this.id = 'armonik.api.grpc.v1.FilterBoolean'; }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new FilterBoolean();
+        FilterBoolean.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.value = _instance.value || false;
+        _instance.operator = _instance.operator || 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.value = _reader.readBool();
+                    break;
+                case 2:
+                    _instance.operator = _reader.readEnum();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        FilterBoolean.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.value) {
+            _writer.writeBool(1, _instance.value);
+        }
+        if (_instance.operator) {
+            _writer.writeEnum(2, _instance.operator);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of FilterBoolean to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.value = _value.value;
+        this.operator = _value.operator;
+        FilterBoolean.refineValues(this);
+    }
+    get value() {
+        return this._value;
+    }
+    set value(value) {
+        this._value = value;
+    }
+    get operator() {
+        return this._operator;
+    }
+    set operator(value) {
+        this._operator = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        FilterBoolean.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            value: this.value,
+            operator: this.operator
+        };
+    }
+    /**
+     * 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 {
+            value: this.value,
+            operator: FilterBooleanOperator[this.operator === null || this.operator === undefined
+                ? 0
+                : this.operator]
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"filters-common.pb.js","sourceRoot":"","sources":["../../../../../../projects/aneoconsultingfr/armonik.api.angular/src/lib/generated/filters-common.pb.ts"],"names":[],"mappings":"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","sourcesContent":["/* tslint:disable */\n/* eslint-disable */\n// @ts-nocheck\n//\n// THIS IS A GENERATED FILE\n// DO NOT MODIFY IT! YOUR CHANGES WILL BE LOST\nimport {\n  GrpcMessage,\n  RecursivePartial,\n  ToProtobufJSONOptions\n} from '@ngx-grpc/common';\nimport { BinaryReader, BinaryWriter, ByteSource } from 'google-protobuf';\nimport * as googleProtobuf000 from '@ngx-grpc/well-known-types';\nexport enum FilterStringOperator {\n  FILTER_STRING_OPERATOR_EQUAL = 0,\n  FILTER_STRING_OPERATOR_NOT_EQUAL = 1,\n  FILTER_STRING_OPERATOR_CONTAINS = 2,\n  FILTER_STRING_OPERATOR_NOT_CONTAINS = 3,\n  FILTER_STRING_OPERATOR_STARTS_WITH = 4,\n  FILTER_STRING_OPERATOR_ENDS_WITH = 5\n}\nexport enum FilterNumberOperator {\n  FILTER_NUMBER_OPERATOR_EQUAL = 0,\n  FILTER_NUMBER_OPERATOR_NOT_EQUAL = 1,\n  FILTER_NUMBER_OPERATOR_LESS_THAN = 2,\n  FILTER_NUMBER_OPERATOR_LESS_THAN_OR_EQUAL = 3,\n  FILTER_NUMBER_OPERATOR_GREATER_THAN_OR_EQUAL = 4,\n  FILTER_NUMBER_OPERATOR_GREATER_THAN = 5\n}\nexport enum FilterDateOperator {\n  FILTER_DATE_OPERATOR_EQUAL = 0,\n  FILTER_DATE_OPERATOR_NOT_EQUAL = 1,\n  FILTER_DATE_OPERATOR_BEFORE = 2,\n  FILTER_DATE_OPERATOR_BEFORE_OR_EQUAL = 3,\n  FILTER_DATE_OPERATOR_AFTER_OR_EQUAL = 4,\n  FILTER_DATE_OPERATOR_AFTER = 5\n}\nexport enum FilterArrayOperator {\n  FILTER_ARRAY_OPERATOR_CONTAINS = 0,\n  FILTER_ARRAY_OPERATOR_NOT_CONTAINS = 1\n}\nexport enum FilterStatusOperator {\n  FILTER_STATUS_OPERATOR_EQUAL = 0,\n  FILTER_STATUS_OPERATOR_NOT_EQUAL = 1\n}\nexport enum FilterBooleanOperator {\n  FILTER_BOOLEAN_OPERATOR_IS = 0\n}\n/**\n * Message implementation for armonik.api.grpc.v1.FilterString\n */\nexport class FilterString implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.FilterString';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new FilterString();\n    FilterString.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: FilterString) {\n    _instance.value = _instance.value || '';\n    _instance.operator = _instance.operator || 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: FilterString,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.value = _reader.readString();\n          break;\n        case 2:\n          _instance.operator = _reader.readEnum();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    FilterString.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: FilterString,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.value) {\n      _writer.writeString(1, _instance.value);\n    }\n    if (_instance.operator) {\n      _writer.writeEnum(2, _instance.operator);\n    }\n  }\n\n  private _value: string;\n  private _operator: FilterStringOperator;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of FilterString to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<FilterString.AsObject>) {\n    _value = _value || {};\n    this.value = _value.value;\n    this.operator = _value.operator;\n    FilterString.refineValues(this);\n  }\n  get value(): string {\n    return this._value;\n  }\n  set value(value: string) {\n    this._value = value;\n  }\n  get operator(): FilterStringOperator {\n    return this._operator;\n  }\n  set operator(value: FilterStringOperator) {\n    this._operator = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    FilterString.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(): FilterString.AsObject {\n    return {\n      value: this.value,\n      operator: this.operator\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  ): FilterString.AsProtobufJSON {\n    return {\n      value: this.value,\n      operator:\n        FilterStringOperator[\n          this.operator === null || this.operator === undefined\n            ? 0\n            : this.operator\n        ]\n    };\n  }\n}\nexport module FilterString {\n  /**\n   * Standard JavaScript object representation for FilterString\n   */\n  export interface AsObject {\n    value: string;\n    operator: FilterStringOperator;\n  }\n\n  /**\n   * Protobuf JSON representation for FilterString\n   */\n  export interface AsProtobufJSON {\n    value: string;\n    operator: string;\n  }\n}\n\n/**\n * Message implementation for armonik.api.grpc.v1.FilterNumber\n */\nexport class FilterNumber implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.FilterNumber';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new FilterNumber();\n    FilterNumber.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: FilterNumber) {\n    _instance.value = _instance.value || '0';\n    _instance.operator = _instance.operator || 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: FilterNumber,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.value = _reader.readInt64String();\n          break;\n        case 2:\n          _instance.operator = _reader.readEnum();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    FilterNumber.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: FilterNumber,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.value) {\n      _writer.writeInt64String(1, _instance.value);\n    }\n    if (_instance.operator) {\n      _writer.writeEnum(2, _instance.operator);\n    }\n  }\n\n  private _value: string;\n  private _operator: FilterNumberOperator;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of FilterNumber to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<FilterNumber.AsObject>) {\n    _value = _value || {};\n    this.value = _value.value;\n    this.operator = _value.operator;\n    FilterNumber.refineValues(this);\n  }\n  get value(): string {\n    return this._value;\n  }\n  set value(value: string) {\n    this._value = value;\n  }\n  get operator(): FilterNumberOperator {\n    return this._operator;\n  }\n  set operator(value: FilterNumberOperator) {\n    this._operator = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    FilterNumber.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(): FilterNumber.AsObject {\n    return {\n      value: this.value,\n      operator: this.operator\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  ): FilterNumber.AsProtobufJSON {\n    return {\n      value: this.value,\n      operator:\n        FilterNumberOperator[\n          this.operator === null || this.operator === undefined\n            ? 0\n            : this.operator\n        ]\n    };\n  }\n}\nexport module FilterNumber {\n  /**\n   * Standard JavaScript object representation for FilterNumber\n   */\n  export interface AsObject {\n    value: string;\n    operator: FilterNumberOperator;\n  }\n\n  /**\n   * Protobuf JSON representation for FilterNumber\n   */\n  export interface AsProtobufJSON {\n    value: string;\n    operator: string;\n  }\n}\n\n/**\n * Message implementation for armonik.api.grpc.v1.FilterDate\n */\nexport class FilterDate implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.FilterDate';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new FilterDate();\n    FilterDate.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: FilterDate) {\n    _instance.value = _instance.value || undefined;\n    _instance.operator = _instance.operator || 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: FilterDate,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.value = new googleProtobuf000.Timestamp();\n          _reader.readMessage(\n            _instance.value,\n            googleProtobuf000.Timestamp.deserializeBinaryFromReader\n          );\n          break;\n        case 2:\n          _instance.operator = _reader.readEnum();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    FilterDate.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: FilterDate, _writer: BinaryWriter) {\n    if (_instance.value) {\n      _writer.writeMessage(\n        1,\n        _instance.value as any,\n        googleProtobuf000.Timestamp.serializeBinaryToWriter\n      );\n    }\n    if (_instance.operator) {\n      _writer.writeEnum(2, _instance.operator);\n    }\n  }\n\n  private _value?: googleProtobuf000.Timestamp;\n  private _operator: FilterDateOperator;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of FilterDate to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<FilterDate.AsObject>) {\n    _value = _value || {};\n    this.value = _value.value\n      ? new googleProtobuf000.Timestamp(_value.value)\n      : undefined;\n    this.operator = _value.operator;\n    FilterDate.refineValues(this);\n  }\n  get value(): googleProtobuf000.Timestamp | undefined {\n    return this._value;\n  }\n  set value(value: googleProtobuf000.Timestamp | undefined) {\n    this._value = value;\n  }\n  get operator(): FilterDateOperator {\n    return this._operator;\n  }\n  set operator(value: FilterDateOperator) {\n    this._operator = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    FilterDate.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(): FilterDate.AsObject {\n    return {\n      value: this.value ? this.value.toObject() : undefined,\n      operator: this.operator\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  ): FilterDate.AsProtobufJSON {\n    return {\n      value: this.value ? this.value.toProtobufJSON(options) : null,\n      operator:\n        FilterDateOperator[\n          this.operator === null || this.operator === undefined\n            ? 0\n            : this.operator\n        ]\n    };\n  }\n}\nexport module FilterDate {\n  /**\n   * Standard JavaScript object representation for FilterDate\n   */\n  export interface AsObject {\n    value?: googleProtobuf000.Timestamp.AsObject;\n    operator: FilterDateOperator;\n  }\n\n  /**\n   * Protobuf JSON representation for FilterDate\n   */\n  export interface AsProtobufJSON {\n    value: googleProtobuf000.Timestamp.AsProtobufJSON | null;\n    operator: string;\n  }\n}\n\n/**\n * Message implementation for armonik.api.grpc.v1.FilterArray\n */\nexport class FilterArray implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.FilterArray';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new FilterArray();\n    FilterArray.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: FilterArray) {\n    _instance.value = _instance.value || '';\n    _instance.operator = _instance.operator || 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: FilterArray,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.value = _reader.readString();\n          break;\n        case 2:\n          _instance.operator = _reader.readEnum();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    FilterArray.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: FilterArray,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.value) {\n      _writer.writeString(1, _instance.value);\n    }\n    if (_instance.operator) {\n      _writer.writeEnum(2, _instance.operator);\n    }\n  }\n\n  private _value: string;\n  private _operator: FilterArrayOperator;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of FilterArray to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<FilterArray.AsObject>) {\n    _value = _value || {};\n    this.value = _value.value;\n    this.operator = _value.operator;\n    FilterArray.refineValues(this);\n  }\n  get value(): string {\n    return this._value;\n  }\n  set value(value: string) {\n    this._value = value;\n  }\n  get operator(): FilterArrayOperator {\n    return this._operator;\n  }\n  set operator(value: FilterArrayOperator) {\n    this._operator = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    FilterArray.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(): FilterArray.AsObject {\n    return {\n      value: this.value,\n      operator: this.operator\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  ): FilterArray.AsProtobufJSON {\n    return {\n      value: this.value,\n      operator:\n        FilterArrayOperator[\n          this.operator === null || this.operator === undefined\n            ? 0\n            : this.operator\n        ]\n    };\n  }\n}\nexport module FilterArray {\n  /**\n   * Standard JavaScript object representation for FilterArray\n   */\n  export interface AsObject {\n    value: string;\n    operator: FilterArrayOperator;\n  }\n\n  /**\n   * Protobuf JSON representation for FilterArray\n   */\n  export interface AsProtobufJSON {\n    value: string;\n    operator: string;\n  }\n}\n\n/**\n * Message implementation for armonik.api.grpc.v1.FilterBoolean\n */\nexport class FilterBoolean implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.FilterBoolean';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new FilterBoolean();\n    FilterBoolean.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: FilterBoolean) {\n    _instance.value = _instance.value || false;\n    _instance.operator = _instance.operator || 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: FilterBoolean,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.value = _reader.readBool();\n          break;\n        case 2:\n          _instance.operator = _reader.readEnum();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    FilterBoolean.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: FilterBoolean,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.value) {\n      _writer.writeBool(1, _instance.value);\n    }\n    if (_instance.operator) {\n      _writer.writeEnum(2, _instance.operator);\n    }\n  }\n\n  private _value: boolean;\n  private _operator: FilterBooleanOperator;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of FilterBoolean to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<FilterBoolean.AsObject>) {\n    _value = _value || {};\n    this.value = _value.value;\n    this.operator = _value.operator;\n    FilterBoolean.refineValues(this);\n  }\n  get value(): boolean {\n    return this._value;\n  }\n  set value(value: boolean) {\n    this._value = value;\n  }\n  get operator(): FilterBooleanOperator {\n    return this._operator;\n  }\n  set operator(value: FilterBooleanOperator) {\n    this._operator = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    FilterBoolean.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(): FilterBoolean.AsObject {\n    return {\n      value: this.value,\n      operator: this.operator\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  ): FilterBoolean.AsProtobufJSON {\n    return {\n      value: this.value,\n      operator:\n        FilterBooleanOperator[\n          this.operator === null || this.operator === undefined\n            ? 0\n            : this.operator\n        ]\n    };\n  }\n}\nexport module FilterBoolean {\n  /**\n   * Standard JavaScript object representation for FilterBoolean\n   */\n  export interface AsObject {\n    value: boolean;\n    operator: FilterBooleanOperator;\n  }\n\n  /**\n   * Protobuf JSON representation for FilterBoolean\n   */\n  export interface AsProtobufJSON {\n    value: boolean;\n    operator: string;\n  }\n}\n"]}