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

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

@@ -0,0 +1,431 @@
+import { BinaryReader, BinaryWriter } from 'google-protobuf';
+import * as armonikApiGrpcV1001 from './filters-common.pb';
+import * as armonikApiGrpcV1Partitions002 from './partitions-fields.pb';
+/**
+ * Message implementation for armonik.api.grpc.v1.partitions.FilterField
+ */
+export class FilterField {
+    static { this.id = 'armonik.api.grpc.v1.partitions.FilterField'; }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new FilterField();
+        FilterField.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 || 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.field = new armonikApiGrpcV1Partitions002.PartitionField();
+                    _reader.readMessage(_instance.field, armonikApiGrpcV1Partitions002.PartitionField
+                        .deserializeBinaryFromReader);
+                    break;
+                case 2:
+                    _instance.filterString = new armonikApiGrpcV1001.FilterString();
+                    _reader.readMessage(_instance.filterString, armonikApiGrpcV1001.FilterString.deserializeBinaryFromReader);
+                    break;
+                case 3:
+                    _instance.filterNumber = new armonikApiGrpcV1001.FilterNumber();
+                    _reader.readMessage(_instance.filterNumber, armonikApiGrpcV1001.FilterNumber.deserializeBinaryFromReader);
+                    break;
+                case 4:
+                    _instance.filterBoolean = new armonikApiGrpcV1001.FilterBoolean();
+                    _reader.readMessage(_instance.filterBoolean, armonikApiGrpcV1001.FilterBoolean.deserializeBinaryFromReader);
+                    break;
+                case 5:
+                    _instance.filterArray = new armonikApiGrpcV1001.FilterArray();
+                    _reader.readMessage(_instance.filterArray, armonikApiGrpcV1001.FilterArray.deserializeBinaryFromReader);
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        FilterField.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.writeMessage(1, _instance.field, armonikApiGrpcV1Partitions002.PartitionField.serializeBinaryToWriter);
+        }
+        if (_instance.filterString) {
+            _writer.writeMessage(2, _instance.filterString, armonikApiGrpcV1001.FilterString.serializeBinaryToWriter);
+        }
+        if (_instance.filterNumber) {
+            _writer.writeMessage(3, _instance.filterNumber, armonikApiGrpcV1001.FilterNumber.serializeBinaryToWriter);
+        }
+        if (_instance.filterBoolean) {
+            _writer.writeMessage(4, _instance.filterBoolean, armonikApiGrpcV1001.FilterBoolean.serializeBinaryToWriter);
+        }
+        if (_instance.filterArray) {
+            _writer.writeMessage(5, _instance.filterArray, armonikApiGrpcV1001.FilterArray.serializeBinaryToWriter);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of FilterField to deeply clone from
+     */
+    constructor(_value) {
+        this._valueCondition = FilterField.ValueConditionCase.none;
+        _value = _value || {};
+        this.field = _value.field
+            ? new armonikApiGrpcV1Partitions002.PartitionField(_value.field)
+            : undefined;
+        this.filterString = _value.filterString
+            ? new armonikApiGrpcV1001.FilterString(_value.filterString)
+            : undefined;
+        this.filterNumber = _value.filterNumber
+            ? new armonikApiGrpcV1001.FilterNumber(_value.filterNumber)
+            : undefined;
+        this.filterBoolean = _value.filterBoolean
+            ? new armonikApiGrpcV1001.FilterBoolean(_value.filterBoolean)
+            : undefined;
+        this.filterArray = _value.filterArray
+            ? new armonikApiGrpcV1001.FilterArray(_value.filterArray)
+            : undefined;
+        FilterField.refineValues(this);
+    }
+    get field() {
+        return this._field;
+    }
+    set field(value) {
+        this._field = value;
+    }
+    get filterString() {
+        return this._filterString;
+    }
+    set filterString(value) {
+        if (value !== undefined && value !== null) {
+            this._filterNumber = this._filterBoolean = this._filterArray = undefined;
+            this._valueCondition = FilterField.ValueConditionCase.filterString;
+        }
+        this._filterString = value;
+    }
+    get filterNumber() {
+        return this._filterNumber;
+    }
+    set filterNumber(value) {
+        if (value !== undefined && value !== null) {
+            this._filterString = this._filterBoolean = this._filterArray = undefined;
+            this._valueCondition = FilterField.ValueConditionCase.filterNumber;
+        }
+        this._filterNumber = value;
+    }
+    get filterBoolean() {
+        return this._filterBoolean;
+    }
+    set filterBoolean(value) {
+        if (value !== undefined && value !== null) {
+            this._filterString = this._filterNumber = this._filterArray = undefined;
+            this._valueCondition = FilterField.ValueConditionCase.filterBoolean;
+        }
+        this._filterBoolean = value;
+    }
+    get filterArray() {
+        return this._filterArray;
+    }
+    set filterArray(value) {
+        if (value !== undefined && value !== null) {
+            this._filterString = this._filterNumber = this._filterBoolean = undefined;
+            this._valueCondition = FilterField.ValueConditionCase.filterArray;
+        }
+        this._filterArray = value;
+    }
+    get valueCondition() {
+        return this._valueCondition;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        FilterField.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            field: this.field ? this.field.toObject() : undefined,
+            filterString: this.filterString
+                ? this.filterString.toObject()
+                : undefined,
+            filterNumber: this.filterNumber
+                ? this.filterNumber.toObject()
+                : undefined,
+            filterBoolean: this.filterBoolean
+                ? this.filterBoolean.toObject()
+                : undefined,
+            filterArray: this.filterArray ? this.filterArray.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 {
+            field: this.field ? this.field.toProtobufJSON(options) : null,
+            filterString: this.filterString
+                ? this.filterString.toProtobufJSON(options)
+                : null,
+            filterNumber: this.filterNumber
+                ? this.filterNumber.toProtobufJSON(options)
+                : null,
+            filterBoolean: this.filterBoolean
+                ? this.filterBoolean.toProtobufJSON(options)
+                : null,
+            filterArray: this.filterArray
+                ? this.filterArray.toProtobufJSON(options)
+                : null
+        };
+    }
+}
+(function (FilterField) {
+    let ValueConditionCase;
+    (function (ValueConditionCase) {
+        ValueConditionCase[ValueConditionCase["none"] = 0] = "none";
+        ValueConditionCase[ValueConditionCase["filterString"] = 1] = "filterString";
+        ValueConditionCase[ValueConditionCase["filterNumber"] = 2] = "filterNumber";
+        ValueConditionCase[ValueConditionCase["filterBoolean"] = 3] = "filterBoolean";
+        ValueConditionCase[ValueConditionCase["filterArray"] = 4] = "filterArray";
+    })(ValueConditionCase = FilterField.ValueConditionCase || (FilterField.ValueConditionCase = {}));
+})(FilterField || (FilterField = {}));
+/**
+ * Message implementation for armonik.api.grpc.v1.partitions.FiltersAnd
+ */
+export class FiltersAnd {
+    static { this.id = 'armonik.api.grpc.v1.partitions.FiltersAnd'; }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new FiltersAnd();
+        FiltersAnd.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.and = _instance.and || [];
+    }
+    /**
+     * 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 FilterField();
+                    _reader.readMessage(messageInitializer1, FilterField.deserializeBinaryFromReader);
+                    (_instance.and = _instance.and || []).push(messageInitializer1);
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        FiltersAnd.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.and && _instance.and.length) {
+            _writer.writeRepeatedMessage(1, _instance.and, FilterField.serializeBinaryToWriter);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of FiltersAnd to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.and = (_value.and || []).map(m => new FilterField(m));
+        FiltersAnd.refineValues(this);
+    }
+    get and() {
+        return this._and;
+    }
+    set and(value) {
+        this._and = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        FiltersAnd.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            and: (this.and || []).map(m => m.toObject())
+        };
+    }
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON() {
+        return this.toObject();
+    }
+    /**
+     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+     */
+    toProtobufJSON(
+    // @ts-ignore
+    options) {
+        return {
+            and: (this.and || []).map(m => m.toProtobufJSON(options))
+        };
+    }
+}
+/**
+ * Message implementation for armonik.api.grpc.v1.partitions.Filters
+ */
+export class Filters {
+    static { this.id = 'armonik.api.grpc.v1.partitions.Filters'; }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new Filters();
+        Filters.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.or = _instance.or || [];
+    }
+    /**
+     * 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 FiltersAnd();
+                    _reader.readMessage(messageInitializer1, FiltersAnd.deserializeBinaryFromReader);
+                    (_instance.or = _instance.or || []).push(messageInitializer1);
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        Filters.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.or && _instance.or.length) {
+            _writer.writeRepeatedMessage(1, _instance.or, FiltersAnd.serializeBinaryToWriter);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of Filters to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.or = (_value.or || []).map(m => new FiltersAnd(m));
+        Filters.refineValues(this);
+    }
+    get or() {
+        return this._or;
+    }
+    set or(value) {
+        this._or = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        Filters.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            or: (this.or || []).map(m => m.toObject())
+        };
+    }
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON() {
+        return this.toObject();
+    }
+    /**
+     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+     */
+    toProtobufJSON(
+    // @ts-ignore
+    options) {
+        return {
+            or: (this.or || []).map(m => m.toProtobufJSON(options))
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"partitions-filters.pb.js","sourceRoot":"","sources":["../../../../../../projects/aneoconsultingfr/armonik.api.angular/src/lib/generated/partitions-filters.pb.ts"],"names":[],"mappings":"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","sourcesContent":["/* tslint:disable */\n/* eslint-disable */\n// @ts-nocheck\n//\n// THIS IS A GENERATED FILE\n// DO NOT MODIFY IT! YOUR CHANGES WILL BE LOST\nimport {\n  GrpcMessage,\n  RecursivePartial,\n  ToProtobufJSONOptions\n} from '@ngx-grpc/common';\nimport { BinaryReader, BinaryWriter, ByteSource } from 'google-protobuf';\nimport * as googleProtobuf000 from '@ngx-grpc/well-known-types';\nimport * as armonikApiGrpcV1001 from './filters-common.pb';\nimport * as armonikApiGrpcV1Partitions002 from './partitions-fields.pb';\n/**\n * Message implementation for armonik.api.grpc.v1.partitions.FilterField\n */\nexport class FilterField implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.partitions.FilterField';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new FilterField();\n    FilterField.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: FilterField) {\n    _instance.field = _instance.field || 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: FilterField,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.field = new armonikApiGrpcV1Partitions002.PartitionField();\n          _reader.readMessage(\n            _instance.field,\n            armonikApiGrpcV1Partitions002.PartitionField\n              .deserializeBinaryFromReader\n          );\n          break;\n        case 2:\n          _instance.filterString = new armonikApiGrpcV1001.FilterString();\n          _reader.readMessage(\n            _instance.filterString,\n            armonikApiGrpcV1001.FilterString.deserializeBinaryFromReader\n          );\n          break;\n        case 3:\n          _instance.filterNumber = new armonikApiGrpcV1001.FilterNumber();\n          _reader.readMessage(\n            _instance.filterNumber,\n            armonikApiGrpcV1001.FilterNumber.deserializeBinaryFromReader\n          );\n          break;\n        case 4:\n          _instance.filterBoolean = new armonikApiGrpcV1001.FilterBoolean();\n          _reader.readMessage(\n            _instance.filterBoolean,\n            armonikApiGrpcV1001.FilterBoolean.deserializeBinaryFromReader\n          );\n          break;\n        case 5:\n          _instance.filterArray = new armonikApiGrpcV1001.FilterArray();\n          _reader.readMessage(\n            _instance.filterArray,\n            armonikApiGrpcV1001.FilterArray.deserializeBinaryFromReader\n          );\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    FilterField.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: FilterField,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.field) {\n      _writer.writeMessage(\n        1,\n        _instance.field as any,\n        armonikApiGrpcV1Partitions002.PartitionField.serializeBinaryToWriter\n      );\n    }\n    if (_instance.filterString) {\n      _writer.writeMessage(\n        2,\n        _instance.filterString as any,\n        armonikApiGrpcV1001.FilterString.serializeBinaryToWriter\n      );\n    }\n    if (_instance.filterNumber) {\n      _writer.writeMessage(\n        3,\n        _instance.filterNumber as any,\n        armonikApiGrpcV1001.FilterNumber.serializeBinaryToWriter\n      );\n    }\n    if (_instance.filterBoolean) {\n      _writer.writeMessage(\n        4,\n        _instance.filterBoolean as any,\n        armonikApiGrpcV1001.FilterBoolean.serializeBinaryToWriter\n      );\n    }\n    if (_instance.filterArray) {\n      _writer.writeMessage(\n        5,\n        _instance.filterArray as any,\n        armonikApiGrpcV1001.FilterArray.serializeBinaryToWriter\n      );\n    }\n  }\n\n  private _field?: armonikApiGrpcV1Partitions002.PartitionField;\n  private _filterString?: armonikApiGrpcV1001.FilterString;\n  private _filterNumber?: armonikApiGrpcV1001.FilterNumber;\n  private _filterBoolean?: armonikApiGrpcV1001.FilterBoolean;\n  private _filterArray?: armonikApiGrpcV1001.FilterArray;\n\n  private _valueCondition: FilterField.ValueConditionCase =\n    FilterField.ValueConditionCase.none;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of FilterField to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<FilterField.AsObject>) {\n    _value = _value || {};\n    this.field = _value.field\n      ? new armonikApiGrpcV1Partitions002.PartitionField(_value.field)\n      : undefined;\n    this.filterString = _value.filterString\n      ? new armonikApiGrpcV1001.FilterString(_value.filterString)\n      : undefined;\n    this.filterNumber = _value.filterNumber\n      ? new armonikApiGrpcV1001.FilterNumber(_value.filterNumber)\n      : undefined;\n    this.filterBoolean = _value.filterBoolean\n      ? new armonikApiGrpcV1001.FilterBoolean(_value.filterBoolean)\n      : undefined;\n    this.filterArray = _value.filterArray\n      ? new armonikApiGrpcV1001.FilterArray(_value.filterArray)\n      : undefined;\n    FilterField.refineValues(this);\n  }\n  get field(): armonikApiGrpcV1Partitions002.PartitionField | undefined {\n    return this._field;\n  }\n  set field(value: armonikApiGrpcV1Partitions002.PartitionField | undefined) {\n    this._field = value;\n  }\n  get filterString(): armonikApiGrpcV1001.FilterString | undefined {\n    return this._filterString;\n  }\n  set filterString(value: armonikApiGrpcV1001.FilterString | undefined) {\n    if (value !== undefined && value !== null) {\n      this._filterNumber = this._filterBoolean = this._filterArray = undefined;\n      this._valueCondition = FilterField.ValueConditionCase.filterString;\n    }\n    this._filterString = value;\n  }\n  get filterNumber(): armonikApiGrpcV1001.FilterNumber | undefined {\n    return this._filterNumber;\n  }\n  set filterNumber(value: armonikApiGrpcV1001.FilterNumber | undefined) {\n    if (value !== undefined && value !== null) {\n      this._filterString = this._filterBoolean = this._filterArray = undefined;\n      this._valueCondition = FilterField.ValueConditionCase.filterNumber;\n    }\n    this._filterNumber = value;\n  }\n  get filterBoolean(): armonikApiGrpcV1001.FilterBoolean | undefined {\n    return this._filterBoolean;\n  }\n  set filterBoolean(value: armonikApiGrpcV1001.FilterBoolean | undefined) {\n    if (value !== undefined && value !== null) {\n      this._filterString = this._filterNumber = this._filterArray = undefined;\n      this._valueCondition = FilterField.ValueConditionCase.filterBoolean;\n    }\n    this._filterBoolean = value;\n  }\n  get filterArray(): armonikApiGrpcV1001.FilterArray | undefined {\n    return this._filterArray;\n  }\n  set filterArray(value: armonikApiGrpcV1001.FilterArray | undefined) {\n    if (value !== undefined && value !== null) {\n      this._filterString = this._filterNumber = this._filterBoolean = undefined;\n      this._valueCondition = FilterField.ValueConditionCase.filterArray;\n    }\n    this._filterArray = value;\n  }\n  get valueCondition() {\n    return this._valueCondition;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    FilterField.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(): FilterField.AsObject {\n    return {\n      field: this.field ? this.field.toObject() : undefined,\n      filterString: this.filterString\n        ? this.filterString.toObject()\n        : undefined,\n      filterNumber: this.filterNumber\n        ? this.filterNumber.toObject()\n        : undefined,\n      filterBoolean: this.filterBoolean\n        ? this.filterBoolean.toObject()\n        : undefined,\n      filterArray: this.filterArray ? this.filterArray.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  ): FilterField.AsProtobufJSON {\n    return {\n      field: this.field ? this.field.toProtobufJSON(options) : null,\n      filterString: this.filterString\n        ? this.filterString.toProtobufJSON(options)\n        : null,\n      filterNumber: this.filterNumber\n        ? this.filterNumber.toProtobufJSON(options)\n        : null,\n      filterBoolean: this.filterBoolean\n        ? this.filterBoolean.toProtobufJSON(options)\n        : null,\n      filterArray: this.filterArray\n        ? this.filterArray.toProtobufJSON(options)\n        : null\n    };\n  }\n}\nexport module FilterField {\n  /**\n   * Standard JavaScript object representation for FilterField\n   */\n  export interface AsObject {\n    field?: armonikApiGrpcV1Partitions002.PartitionField.AsObject;\n    filterString?: armonikApiGrpcV1001.FilterString.AsObject;\n    filterNumber?: armonikApiGrpcV1001.FilterNumber.AsObject;\n    filterBoolean?: armonikApiGrpcV1001.FilterBoolean.AsObject;\n    filterArray?: armonikApiGrpcV1001.FilterArray.AsObject;\n  }\n\n  /**\n   * Protobuf JSON representation for FilterField\n   */\n  export interface AsProtobufJSON {\n    field: armonikApiGrpcV1Partitions002.PartitionField.AsProtobufJSON | null;\n    filterString: armonikApiGrpcV1001.FilterString.AsProtobufJSON | null;\n    filterNumber: armonikApiGrpcV1001.FilterNumber.AsProtobufJSON | null;\n    filterBoolean: armonikApiGrpcV1001.FilterBoolean.AsProtobufJSON | null;\n    filterArray: armonikApiGrpcV1001.FilterArray.AsProtobufJSON | null;\n  }\n  export enum ValueConditionCase {\n    none = 0,\n    filterString = 1,\n    filterNumber = 2,\n    filterBoolean = 3,\n    filterArray = 4\n  }\n}\n\n/**\n * Message implementation for armonik.api.grpc.v1.partitions.FiltersAnd\n */\nexport class FiltersAnd implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.partitions.FiltersAnd';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new FiltersAnd();\n    FiltersAnd.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: FiltersAnd) {\n    _instance.and = _instance.and || [];\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: FiltersAnd,\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 FilterField();\n          _reader.readMessage(\n            messageInitializer1,\n            FilterField.deserializeBinaryFromReader\n          );\n          (_instance.and = _instance.and || []).push(messageInitializer1);\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    FiltersAnd.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: FiltersAnd, _writer: BinaryWriter) {\n    if (_instance.and && _instance.and.length) {\n      _writer.writeRepeatedMessage(\n        1,\n        _instance.and as any,\n        FilterField.serializeBinaryToWriter\n      );\n    }\n  }\n\n  private _and?: FilterField[];\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of FiltersAnd to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<FiltersAnd.AsObject>) {\n    _value = _value || {};\n    this.and = (_value.and || []).map(m => new FilterField(m));\n    FiltersAnd.refineValues(this);\n  }\n  get and(): FilterField[] | undefined {\n    return this._and;\n  }\n  set and(value: FilterField[] | undefined) {\n    this._and = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    FiltersAnd.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(): FiltersAnd.AsObject {\n    return {\n      and: (this.and || []).map(m => m.toObject())\n    };\n  }\n\n  /**\n   * Convenience method to support JSON.stringify(message), replicates the structure of toObject()\n   */\n  toJSON() {\n    return this.toObject();\n  }\n\n  /**\n   * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json\n   * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.\n   * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required\n   */\n  toProtobufJSON(\n    // @ts-ignore\n    options?: ToProtobufJSONOptions\n  ): FiltersAnd.AsProtobufJSON {\n    return {\n      and: (this.and || []).map(m => m.toProtobufJSON(options))\n    };\n  }\n}\nexport module FiltersAnd {\n  /**\n   * Standard JavaScript object representation for FiltersAnd\n   */\n  export interface AsObject {\n    and?: FilterField.AsObject[];\n  }\n\n  /**\n   * Protobuf JSON representation for FiltersAnd\n   */\n  export interface AsProtobufJSON {\n    and: FilterField.AsProtobufJSON[] | null;\n  }\n}\n\n/**\n * Message implementation for armonik.api.grpc.v1.partitions.Filters\n */\nexport class Filters implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.partitions.Filters';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new Filters();\n    Filters.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: Filters) {\n    _instance.or = _instance.or || [];\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: Filters,\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 FiltersAnd();\n          _reader.readMessage(\n            messageInitializer1,\n            FiltersAnd.deserializeBinaryFromReader\n          );\n          (_instance.or = _instance.or || []).push(messageInitializer1);\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    Filters.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: Filters, _writer: BinaryWriter) {\n    if (_instance.or && _instance.or.length) {\n      _writer.writeRepeatedMessage(\n        1,\n        _instance.or as any,\n        FiltersAnd.serializeBinaryToWriter\n      );\n    }\n  }\n\n  private _or?: FiltersAnd[];\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of Filters to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<Filters.AsObject>) {\n    _value = _value || {};\n    this.or = (_value.or || []).map(m => new FiltersAnd(m));\n    Filters.refineValues(this);\n  }\n  get or(): FiltersAnd[] | undefined {\n    return this._or;\n  }\n  set or(value: FiltersAnd[] | undefined) {\n    this._or = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    Filters.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(): Filters.AsObject {\n    return {\n      or: (this.or || []).map(m => m.toObject())\n    };\n  }\n\n  /**\n   * Convenience method to support JSON.stringify(message), replicates the structure of toObject()\n   */\n  toJSON() {\n    return this.toObject();\n  }\n\n  /**\n   * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json\n   * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.\n   * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required\n   */\n  toProtobufJSON(\n    // @ts-ignore\n    options?: ToProtobufJSONOptions\n  ): Filters.AsProtobufJSON {\n    return {\n      or: (this.or || []).map(m => m.toProtobufJSON(options))\n    };\n  }\n}\nexport module Filters {\n  /**\n   * Standard JavaScript object representation for Filters\n   */\n  export interface AsObject {\n    or?: FiltersAnd.AsObject[];\n  }\n\n  /**\n   * Protobuf JSON representation for Filters\n   */\n  export interface AsProtobufJSON {\n    or: FiltersAnd.AsProtobufJSON[] | null;\n  }\n}\n"]}

package/esm2022/lib/generated/partitions-service.pb.mjs

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFydGl0aW9ucy1zZXJ2aWNlLnBiLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvYW5lb2NvbnN1bHRpbmdmci9hcm1vbmlrLmFwaS5hbmd1bGFyL3NyYy9saWIvZ2VuZXJhdGVkL3BhcnRpdGlvbnMtc2VydmljZS5wYi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiLyogdHNsaW50OmRpc2FibGUgKi9cbi8qIGVzbGludC1kaXNhYmxlICovXG4vLyBAdHMtbm9jaGVja1xuLy9cbi8vIFRISVMgSVMgQSBHRU5FUkFURUQgRklMRVxuLy8gRE8gTk9UIE1PRElGWSBJVCEgWU9VUiBDSEFOR0VTIFdJTEwgQkUgTE9TVFxuaW1wb3J0ICogYXMgYXJtb25pa0FwaUdycGNWMVNvcnRfZGlyZWN0aW9uMDAwIGZyb20gJy4vc29ydC1kaXJlY3Rpb24ucGInO1xuaW1wb3J0ICogYXMgYXJtb25pa0FwaUdycGNWMVBhcnRpdGlvbnMwMDEgZnJvbSAnLi9wYXJ0aXRpb25zLWNvbW1vbi5wYic7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFydGl0aW9ucy1zZXJ2aWNlLnBiLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvYW5lb2NvbnN1bHRpbmdmci9hcm1vbmlrLmFwaS5hbmd1bGFyL3NyYy9saWIvZ2VuZXJhdGVkL3BhcnRpdGlvbnMtc2VydmljZS5wYi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiLyogdHNsaW50OmRpc2FibGUgKi9cbi8qIGVzbGludC1kaXNhYmxlICovXG4vLyBAdHMtbm9jaGVja1xuLy9cbi8vIFRISVMgSVMgQSBHRU5FUkFURUQgRklMRVxuLy8gRE8gTk9UIE1PRElGWSBJVCEgWU9VUiBDSEFOR0VTIFdJTEwgQkUgTE9TVFxuaW1wb3J0ICogYXMgYXJtb25pa0FwaUdycGNWMVBhcnRpdGlvbnMwMDAgZnJvbSAnLi9wYXJ0aXRpb25zLWZpZWxkcy5wYic7XG5pbXBvcnQgKiBhcyBhcm1vbmlrQXBpR3JwY1YxUGFydGl0aW9uczAwMSBmcm9tICcuL3BhcnRpdGlvbnMtZmlsdGVycy5wYic7XG5pbXBvcnQgKiBhcyBhcm1vbmlrQXBpR3JwY1YxU29ydF9kaXJlY3Rpb24wMDIgZnJvbSAnLi9zb3J0LWRpcmVjdGlvbi5wYic7XG5pbXBvcnQgKiBhcyBhcm1vbmlrQXBpR3JwY1YxUGFydGl0aW9uczAwMyBmcm9tICcuL3BhcnRpdGlvbnMtY29tbW9uLnBiJztcbiJdfQ==

package/esm2022/lib/generated/partitions-service.pbsc.mjs

@@ -7,7 +7,7 @@
 import { Inject, Injectable, Optional } from '@angular/core';
 import { GrpcCallType, GrpcMetadata } from '@ngx-grpc/common';
 import { GRPC_CLIENT_FACTORY, takeMessages, throwStatusErrors } from '@ngx-grpc/core';
-import * as armonikApiGrpcV1Partitions001 from './partitions-common.pb';
+import * as armonikApiGrpcV1Partitions003 from './partitions-common.pb';
 import { GRPC_PARTITIONS_CLIENT_SETTINGS } from './partitions-service.pbconf';
 import * as i0 from "@angular/core";
 import * as i1 from "@ngx-grpc/core";
@@ -28,7 +28,7 @@ export class PartitionsClient {
              *
              * @param requestMessage Request message
              * @param requestMetadata Request metadata
-             * @returns Observable<GrpcEvent<armonikApiGrpcV1Partitions001.ListPartitionsResponse>>
+             * @returns Observable<GrpcEvent<armonikApiGrpcV1Partitions003.ListPartitionsResponse>>
              */
             listPartitions: (requestData, requestMetadata = new GrpcMetadata()) => {
                 return this.handler.handle({
@@ -37,8 +37,8 @@ export class PartitionsClient {
                     path: '/armonik.api.grpc.v1.partitions.Partitions/ListPartitions',
                     requestData,
                     requestMetadata,
-                    requestClass: armonikApiGrpcV1Partitions001.ListPartitionsRequest,
-                    responseClass: armonikApiGrpcV1Partitions001.ListPartitionsResponse
+                    requestClass: armonikApiGrpcV1Partitions003.ListPartitionsRequest,
+                    responseClass: armonikApiGrpcV1Partitions003.ListPartitionsResponse
                 });
             },
             /**
@@ -46,7 +46,7 @@ export class PartitionsClient {
              *
              * @param requestMessage Request message
              * @param requestMetadata Request metadata
-             * @returns Observable<GrpcEvent<armonikApiGrpcV1Partitions001.GetPartitionResponse>>
+             * @returns Observable<GrpcEvent<armonikApiGrpcV1Partitions003.GetPartitionResponse>>
              */
             getPartition: (requestData, requestMetadata = new GrpcMetadata()) => {
                 return this.handler.handle({
@@ -55,8 +55,8 @@ export class PartitionsClient {
                     path: '/armonik.api.grpc.v1.partitions.Partitions/GetPartition',
                     requestData,
                     requestMetadata,
-                    requestClass: armonikApiGrpcV1Partitions001.GetPartitionRequest,
-                    responseClass: armonikApiGrpcV1Partitions001.GetPartitionResponse
+                    requestClass: armonikApiGrpcV1Partitions003.GetPartitionRequest,
+                    responseClass: armonikApiGrpcV1Partitions003.GetPartitionResponse
                 });
             }
         };
@@ -67,7 +67,7 @@ export class PartitionsClient {
      *
      * @param requestMessage Request message
      * @param requestMetadata Request metadata
-     * @returns Observable<armonikApiGrpcV1Partitions001.ListPartitionsResponse>
+     * @returns Observable<armonikApiGrpcV1Partitions003.ListPartitionsResponse>
      */
     listPartitions(requestData, requestMetadata = new GrpcMetadata()) {
         return this.$raw
@@ -79,7 +79,7 @@ export class PartitionsClient {
      *
      * @param requestMessage Request message
      * @param requestMetadata Request metadata
-     * @returns Observable<armonikApiGrpcV1Partitions001.GetPartitionResponse>
+     * @returns Observable<armonikApiGrpcV1Partitions003.GetPartitionResponse>
      */
     getPartition(requestData, requestMetadata = new GrpcMetadata()) {
         return this.$raw
@@ -101,4 +101,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.1.6", ngImpor
                     type: Inject,
                     args: [GRPC_CLIENT_FACTORY]
                 }] }, { type: i1.GrpcHandler }]; } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"partitions-service.pbsc.js","sourceRoot":"","sources":["../../../../../../projects/aneoconsultingfr/armonik.api.angular/src/lib/generated/partitions-service.pbsc.ts"],"names":[],"mappings":"AAAA,oBAAoB;AACpB,oBAAoB;AACpB,cAAc;AACd,EAAE;AACF,2BAA2B;AAC3B,8CAA8C;AAC9C,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC7D,OAAO,EACL,YAAY,EAIZ,YAAY,EACb,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,mBAAmB,EAEnB,YAAY,EACZ,iBAAiB,EAClB,MAAM,gBAAgB,CAAC;AAIxB,OAAO,KAAK,6BAA6B,MAAM,wBAAwB,CAAC;AACxE,OAAO,EAAE,+BAA+B,EAAE,MAAM,6BAA6B,CAAC;;;AAC9E;;GAEG;AAEH,MAAM,OAAO,gBAAgB;IAyD3B,YACuD,QAAa,EACrC,aAAqC,EAC1D,OAAoB;QAApB,YAAO,GAAP,OAAO,CAAa;QAzD9B;;;;WAIG;QACH,SAAI,GAAG;YACL;;;;;;eAMG;YACH,cAAc,EAAE,CACd,WAAgE,EAChE,eAAe,GAAG,IAAI,YAAY,EAAE,EAGpC,EAAE;gBACF,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC;oBACzB,IAAI,EAAE,YAAY,CAAC,KAAK;oBACxB,MAAM,EAAE,IAAI,CAAC,MAAM;oBACnB,IAAI,EAAE,2DAA2D;oBACjE,WAAW;oBACX,eAAe;oBACf,YAAY,EAAE,6BAA6B,CAAC,qBAAqB;oBACjE,aAAa,EAAE,6BAA6B,CAAC,sBAAsB;iBACpE,CAAC,CAAC;YACL,CAAC;YACD;;;;;;eAMG;YACH,YAAY,EAAE,CACZ,WAA8D,EAC9D,eAAe,GAAG,IAAI,YAAY,EAAE,EAGpC,EAAE;gBACF,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC;oBACzB,IAAI,EAAE,YAAY,CAAC,KAAK;oBACxB,MAAM,EAAE,IAAI,CAAC,MAAM;oBACnB,IAAI,EAAE,yDAAyD;oBAC/D,WAAW;oBACX,eAAe;oBACf,YAAY,EAAE,6BAA6B,CAAC,mBAAmB;oBAC/D,aAAa,EAAE,6BAA6B,CAAC,oBAAoB;iBAClE,CAAC,CAAC;YACL,CAAC;SACF,CAAC;QAOA,IAAI,CAAC,MAAM,GAAG,aAAa,CAAC,YAAY,CACtC,2CAA2C,EAC3C,QAAQ,CACT,CAAC;IACJ,CAAC;IAED;;;;;;OAMG;IACH,cAAc,CACZ,WAAgE,EAChE,eAAe,GAAG,IAAI,YAAY,EAAE;QAEpC,OAAO,IAAI,CAAC,IAAI;aACb,cAAc,CAAC,WAAW,EAAE,eAAe,CAAC;aAC5C,IAAI,CAAC,iBAAiB,EAAE,EAAE,YAAY,EAAE,CAAC,CAAC;IAC/C,CAAC;IAED;;;;;;OAMG;IACH,YAAY,CACV,WAA8D,EAC9D,eAAe,GAAG,IAAI,YAAY,EAAE;QAEpC,OAAO,IAAI,CAAC,IAAI;aACb,YAAY,CAAC,WAAW,EAAE,eAAe,CAAC;aAC1C,IAAI,CAAC,iBAAiB,EAAE,EAAE,YAAY,EAAE,CAAC,CAAC;IAC/C,CAAC;8GAlGU,gBAAgB,kBA0DL,+BAA+B,6BAC3C,mBAAmB;kHA3DlB,gBAAgB,cADH,KAAK;;2FAClB,gBAAgB;kBAD5B,UAAU;mBAAC,EAAE,UAAU,EAAE,KAAK,EAAE;;0BA2D5B,QAAQ;;0BAAI,MAAM;2BAAC,+BAA+B;;0BAClD,MAAM;2BAAC,mBAAmB","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 { Inject, Injectable, Optional } from '@angular/core';\nimport {\n  GrpcCallType,\n  GrpcClient,\n  GrpcClientFactory,\n  GrpcEvent,\n  GrpcMetadata\n} from '@ngx-grpc/common';\nimport {\n  GRPC_CLIENT_FACTORY,\n  GrpcHandler,\n  takeMessages,\n  throwStatusErrors\n} from '@ngx-grpc/core';\nimport { Observable } from 'rxjs';\nimport * as thisProto from './partitions-service.pb';\nimport * as armonikApiGrpcV1Sort_direction000 from './sort-direction.pb';\nimport * as armonikApiGrpcV1Partitions001 from './partitions-common.pb';\nimport { GRPC_PARTITIONS_CLIENT_SETTINGS } from './partitions-service.pbconf';\n/**\n * Service client implementation for armonik.api.grpc.v1.partitions.Partitions\n */\n@Injectable({ providedIn: 'any' })\nexport class PartitionsClient {\n  private client: GrpcClient<any>;\n\n  /**\n   * Raw RPC implementation for each service client method.\n   * The raw methods provide more control on the incoming data and events. E.g. they can be useful to read status `OK` metadata.\n   * Attention: these methods do not throw errors when non-zero status codes are received.\n   */\n  $raw = {\n    /**\n     * Unary call: /armonik.api.grpc.v1.partitions.Partitions/ListPartitions\n     *\n     * @param requestMessage Request message\n     * @param requestMetadata Request metadata\n     * @returns Observable<GrpcEvent<armonikApiGrpcV1Partitions001.ListPartitionsResponse>>\n     */\n    listPartitions: (\n      requestData: armonikApiGrpcV1Partitions001.ListPartitionsRequest,\n      requestMetadata = new GrpcMetadata()\n    ): Observable<\n      GrpcEvent<armonikApiGrpcV1Partitions001.ListPartitionsResponse>\n    > => {\n      return this.handler.handle({\n        type: GrpcCallType.unary,\n        client: this.client,\n        path: '/armonik.api.grpc.v1.partitions.Partitions/ListPartitions',\n        requestData,\n        requestMetadata,\n        requestClass: armonikApiGrpcV1Partitions001.ListPartitionsRequest,\n        responseClass: armonikApiGrpcV1Partitions001.ListPartitionsResponse\n      });\n    },\n    /**\n     * Unary call: /armonik.api.grpc.v1.partitions.Partitions/GetPartition\n     *\n     * @param requestMessage Request message\n     * @param requestMetadata Request metadata\n     * @returns Observable<GrpcEvent<armonikApiGrpcV1Partitions001.GetPartitionResponse>>\n     */\n    getPartition: (\n      requestData: armonikApiGrpcV1Partitions001.GetPartitionRequest,\n      requestMetadata = new GrpcMetadata()\n    ): Observable<\n      GrpcEvent<armonikApiGrpcV1Partitions001.GetPartitionResponse>\n    > => {\n      return this.handler.handle({\n        type: GrpcCallType.unary,\n        client: this.client,\n        path: '/armonik.api.grpc.v1.partitions.Partitions/GetPartition',\n        requestData,\n        requestMetadata,\n        requestClass: armonikApiGrpcV1Partitions001.GetPartitionRequest,\n        responseClass: armonikApiGrpcV1Partitions001.GetPartitionResponse\n      });\n    }\n  };\n\n  constructor(\n    @Optional() @Inject(GRPC_PARTITIONS_CLIENT_SETTINGS) settings: any,\n    @Inject(GRPC_CLIENT_FACTORY) clientFactory: GrpcClientFactory<any>,\n    private handler: GrpcHandler\n  ) {\n    this.client = clientFactory.createClient(\n      'armonik.api.grpc.v1.partitions.Partitions',\n      settings\n    );\n  }\n\n  /**\n   * Unary call @/armonik.api.grpc.v1.partitions.Partitions/ListPartitions\n   *\n   * @param requestMessage Request message\n   * @param requestMetadata Request metadata\n   * @returns Observable<armonikApiGrpcV1Partitions001.ListPartitionsResponse>\n   */\n  listPartitions(\n    requestData: armonikApiGrpcV1Partitions001.ListPartitionsRequest,\n    requestMetadata = new GrpcMetadata()\n  ): Observable<armonikApiGrpcV1Partitions001.ListPartitionsResponse> {\n    return this.$raw\n      .listPartitions(requestData, requestMetadata)\n      .pipe(throwStatusErrors(), takeMessages());\n  }\n\n  /**\n   * Unary call @/armonik.api.grpc.v1.partitions.Partitions/GetPartition\n   *\n   * @param requestMessage Request message\n   * @param requestMetadata Request metadata\n   * @returns Observable<armonikApiGrpcV1Partitions001.GetPartitionResponse>\n   */\n  getPartition(\n    requestData: armonikApiGrpcV1Partitions001.GetPartitionRequest,\n    requestMetadata = new GrpcMetadata()\n  ): Observable<armonikApiGrpcV1Partitions001.GetPartitionResponse> {\n    return this.$raw\n      .getPartition(requestData, requestMetadata)\n      .pipe(throwStatusErrors(), takeMessages());\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"partitions-service.pbsc.js","sourceRoot":"","sources":["../../../../../../projects/aneoconsultingfr/armonik.api.angular/src/lib/generated/partitions-service.pbsc.ts"],"names":[],"mappings":"AAAA,oBAAoB;AACpB,oBAAoB;AACpB,cAAc;AACd,EAAE;AACF,2BAA2B;AAC3B,8CAA8C;AAC9C,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC7D,OAAO,EACL,YAAY,EAIZ,YAAY,EACb,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,mBAAmB,EAEnB,YAAY,EACZ,iBAAiB,EAClB,MAAM,gBAAgB,CAAC;AAMxB,OAAO,KAAK,6BAA6B,MAAM,wBAAwB,CAAC;AACxE,OAAO,EAAE,+BAA+B,EAAE,MAAM,6BAA6B,CAAC;;;AAC9E;;GAEG;AAEH,MAAM,OAAO,gBAAgB;IAyD3B,YACuD,QAAa,EACrC,aAAqC,EAC1D,OAAoB;QAApB,YAAO,GAAP,OAAO,CAAa;QAzD9B;;;;WAIG;QACH,SAAI,GAAG;YACL;;;;;;eAMG;YACH,cAAc,EAAE,CACd,WAAgE,EAChE,eAAe,GAAG,IAAI,YAAY,EAAE,EAGpC,EAAE;gBACF,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC;oBACzB,IAAI,EAAE,YAAY,CAAC,KAAK;oBACxB,MAAM,EAAE,IAAI,CAAC,MAAM;oBACnB,IAAI,EAAE,2DAA2D;oBACjE,WAAW;oBACX,eAAe;oBACf,YAAY,EAAE,6BAA6B,CAAC,qBAAqB;oBACjE,aAAa,EAAE,6BAA6B,CAAC,sBAAsB;iBACpE,CAAC,CAAC;YACL,CAAC;YACD;;;;;;eAMG;YACH,YAAY,EAAE,CACZ,WAA8D,EAC9D,eAAe,GAAG,IAAI,YAAY,EAAE,EAGpC,EAAE;gBACF,OAAO,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC;oBACzB,IAAI,EAAE,YAAY,CAAC,KAAK;oBACxB,MAAM,EAAE,IAAI,CAAC,MAAM;oBACnB,IAAI,EAAE,yDAAyD;oBAC/D,WAAW;oBACX,eAAe;oBACf,YAAY,EAAE,6BAA6B,CAAC,mBAAmB;oBAC/D,aAAa,EAAE,6BAA6B,CAAC,oBAAoB;iBAClE,CAAC,CAAC;YACL,CAAC;SACF,CAAC;QAOA,IAAI,CAAC,MAAM,GAAG,aAAa,CAAC,YAAY,CACtC,2CAA2C,EAC3C,QAAQ,CACT,CAAC;IACJ,CAAC;IAED;;;;;;OAMG;IACH,cAAc,CACZ,WAAgE,EAChE,eAAe,GAAG,IAAI,YAAY,EAAE;QAEpC,OAAO,IAAI,CAAC,IAAI;aACb,cAAc,CAAC,WAAW,EAAE,eAAe,CAAC;aAC5C,IAAI,CAAC,iBAAiB,EAAE,EAAE,YAAY,EAAE,CAAC,CAAC;IAC/C,CAAC;IAED;;;;;;OAMG;IACH,YAAY,CACV,WAA8D,EAC9D,eAAe,GAAG,IAAI,YAAY,EAAE;QAEpC,OAAO,IAAI,CAAC,IAAI;aACb,YAAY,CAAC,WAAW,EAAE,eAAe,CAAC;aAC1C,IAAI,CAAC,iBAAiB,EAAE,EAAE,YAAY,EAAE,CAAC,CAAC;IAC/C,CAAC;8GAlGU,gBAAgB,kBA0DL,+BAA+B,6BAC3C,mBAAmB;kHA3DlB,gBAAgB,cADH,KAAK;;2FAClB,gBAAgB;kBAD5B,UAAU;mBAAC,EAAE,UAAU,EAAE,KAAK,EAAE;;0BA2D5B,QAAQ;;0BAAI,MAAM;2BAAC,+BAA+B;;0BAClD,MAAM;2BAAC,mBAAmB","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 { Inject, Injectable, Optional } from '@angular/core';\nimport {\n  GrpcCallType,\n  GrpcClient,\n  GrpcClientFactory,\n  GrpcEvent,\n  GrpcMetadata\n} from '@ngx-grpc/common';\nimport {\n  GRPC_CLIENT_FACTORY,\n  GrpcHandler,\n  takeMessages,\n  throwStatusErrors\n} from '@ngx-grpc/core';\nimport { Observable } from 'rxjs';\nimport * as thisProto from './partitions-service.pb';\nimport * as armonikApiGrpcV1Partitions000 from './partitions-fields.pb';\nimport * as armonikApiGrpcV1Partitions001 from './partitions-filters.pb';\nimport * as armonikApiGrpcV1Sort_direction002 from './sort-direction.pb';\nimport * as armonikApiGrpcV1Partitions003 from './partitions-common.pb';\nimport { GRPC_PARTITIONS_CLIENT_SETTINGS } from './partitions-service.pbconf';\n/**\n * Service client implementation for armonik.api.grpc.v1.partitions.Partitions\n */\n@Injectable({ providedIn: 'any' })\nexport class PartitionsClient {\n  private client: GrpcClient<any>;\n\n  /**\n   * Raw RPC implementation for each service client method.\n   * The raw methods provide more control on the incoming data and events. E.g. they can be useful to read status `OK` metadata.\n   * Attention: these methods do not throw errors when non-zero status codes are received.\n   */\n  $raw = {\n    /**\n     * Unary call: /armonik.api.grpc.v1.partitions.Partitions/ListPartitions\n     *\n     * @param requestMessage Request message\n     * @param requestMetadata Request metadata\n     * @returns Observable<GrpcEvent<armonikApiGrpcV1Partitions003.ListPartitionsResponse>>\n     */\n    listPartitions: (\n      requestData: armonikApiGrpcV1Partitions003.ListPartitionsRequest,\n      requestMetadata = new GrpcMetadata()\n    ): Observable<\n      GrpcEvent<armonikApiGrpcV1Partitions003.ListPartitionsResponse>\n    > => {\n      return this.handler.handle({\n        type: GrpcCallType.unary,\n        client: this.client,\n        path: '/armonik.api.grpc.v1.partitions.Partitions/ListPartitions',\n        requestData,\n        requestMetadata,\n        requestClass: armonikApiGrpcV1Partitions003.ListPartitionsRequest,\n        responseClass: armonikApiGrpcV1Partitions003.ListPartitionsResponse\n      });\n    },\n    /**\n     * Unary call: /armonik.api.grpc.v1.partitions.Partitions/GetPartition\n     *\n     * @param requestMessage Request message\n     * @param requestMetadata Request metadata\n     * @returns Observable<GrpcEvent<armonikApiGrpcV1Partitions003.GetPartitionResponse>>\n     */\n    getPartition: (\n      requestData: armonikApiGrpcV1Partitions003.GetPartitionRequest,\n      requestMetadata = new GrpcMetadata()\n    ): Observable<\n      GrpcEvent<armonikApiGrpcV1Partitions003.GetPartitionResponse>\n    > => {\n      return this.handler.handle({\n        type: GrpcCallType.unary,\n        client: this.client,\n        path: '/armonik.api.grpc.v1.partitions.Partitions/GetPartition',\n        requestData,\n        requestMetadata,\n        requestClass: armonikApiGrpcV1Partitions003.GetPartitionRequest,\n        responseClass: armonikApiGrpcV1Partitions003.GetPartitionResponse\n      });\n    }\n  };\n\n  constructor(\n    @Optional() @Inject(GRPC_PARTITIONS_CLIENT_SETTINGS) settings: any,\n    @Inject(GRPC_CLIENT_FACTORY) clientFactory: GrpcClientFactory<any>,\n    private handler: GrpcHandler\n  ) {\n    this.client = clientFactory.createClient(\n      'armonik.api.grpc.v1.partitions.Partitions',\n      settings\n    );\n  }\n\n  /**\n   * Unary call @/armonik.api.grpc.v1.partitions.Partitions/ListPartitions\n   *\n   * @param requestMessage Request message\n   * @param requestMetadata Request metadata\n   * @returns Observable<armonikApiGrpcV1Partitions003.ListPartitionsResponse>\n   */\n  listPartitions(\n    requestData: armonikApiGrpcV1Partitions003.ListPartitionsRequest,\n    requestMetadata = new GrpcMetadata()\n  ): Observable<armonikApiGrpcV1Partitions003.ListPartitionsResponse> {\n    return this.$raw\n      .listPartitions(requestData, requestMetadata)\n      .pipe(throwStatusErrors(), takeMessages());\n  }\n\n  /**\n   * Unary call @/armonik.api.grpc.v1.partitions.Partitions/GetPartition\n   *\n   * @param requestMessage Request message\n   * @param requestMetadata Request metadata\n   * @returns Observable<armonikApiGrpcV1Partitions003.GetPartitionResponse>\n   */\n  getPartition(\n    requestData: armonikApiGrpcV1Partitions003.GetPartitionRequest,\n    requestMetadata = new GrpcMetadata()\n  ): Observable<armonikApiGrpcV1Partitions003.GetPartitionResponse> {\n    return this.$raw\n      .getPartition(requestData, requestMetadata)\n      .pipe(throwStatusErrors(), takeMessages());\n  }\n}\n"]}