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

package/esm2022/lib/generated/applications-fields.pb.mjs

@@ -0,0 +1,231 @@
+import { BinaryReader, BinaryWriter } from 'google-protobuf';
+export var ApplicationRawEnumField;
+(function (ApplicationRawEnumField) {
+    ApplicationRawEnumField[ApplicationRawEnumField["APPLICATION_RAW_ENUM_FIELD_UNSPECIFIED"] = 0] = "APPLICATION_RAW_ENUM_FIELD_UNSPECIFIED";
+    ApplicationRawEnumField[ApplicationRawEnumField["APPLICATION_RAW_ENUM_FIELD_NAME"] = 1] = "APPLICATION_RAW_ENUM_FIELD_NAME";
+    ApplicationRawEnumField[ApplicationRawEnumField["APPLICATION_RAW_ENUM_FIELD_VERSION"] = 2] = "APPLICATION_RAW_ENUM_FIELD_VERSION";
+    ApplicationRawEnumField[ApplicationRawEnumField["APPLICATION_RAW_ENUM_FIELD_NAMESPACE"] = 3] = "APPLICATION_RAW_ENUM_FIELD_NAMESPACE";
+    ApplicationRawEnumField[ApplicationRawEnumField["APPLICATION_RAW_ENUM_FIELD_SERVICE"] = 4] = "APPLICATION_RAW_ENUM_FIELD_SERVICE";
+})(ApplicationRawEnumField || (ApplicationRawEnumField = {}));
+/**
+ * Message implementation for armonik.api.grpc.v1.applications.ApplicationRawField
+ */
+export class ApplicationRawField {
+    static { this.id = 'armonik.api.grpc.v1.applications.ApplicationRawField'; }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new ApplicationRawField();
+        ApplicationRawField.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+        return instance;
+    }
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance) {
+        _instance.field = _instance.field || 0;
+    }
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance, _reader) {
+        while (_reader.nextField()) {
+            if (_reader.isEndGroup())
+                break;
+            switch (_reader.getFieldNumber()) {
+                case 1:
+                    _instance.field = _reader.readEnum();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        ApplicationRawField.refineValues(_instance);
+    }
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance, _writer) {
+        if (_instance.field) {
+            _writer.writeEnum(1, _instance.field);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of ApplicationRawField to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.field = _value.field;
+        ApplicationRawField.refineValues(this);
+    }
+    get field() {
+        return this._field;
+    }
+    set field(value) {
+        this._field = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        ApplicationRawField.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            field: this.field
+        };
+    }
+    /**
+     * 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: ApplicationRawEnumField[this.field === null || this.field === undefined ? 0 : this.field]
+        };
+    }
+}
+/**
+ * Message implementation for armonik.api.grpc.v1.applications.ApplicationField
+ */
+export class ApplicationField {
+    static { this.id = 'armonik.api.grpc.v1.applications.ApplicationField'; }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new ApplicationField();
+        ApplicationField.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+        return instance;
+    }
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance) { }
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance, _reader) {
+        while (_reader.nextField()) {
+            if (_reader.isEndGroup())
+                break;
+            switch (_reader.getFieldNumber()) {
+                case 1:
+                    _instance.applicationField = new ApplicationRawField();
+                    _reader.readMessage(_instance.applicationField, ApplicationRawField.deserializeBinaryFromReader);
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        ApplicationField.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.applicationField) {
+            _writer.writeMessage(1, _instance.applicationField, ApplicationRawField.serializeBinaryToWriter);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of ApplicationField to deeply clone from
+     */
+    constructor(_value) {
+        this._field = ApplicationField.FieldCase.none;
+        _value = _value || {};
+        this.applicationField = _value.applicationField
+            ? new ApplicationRawField(_value.applicationField)
+            : undefined;
+        ApplicationField.refineValues(this);
+    }
+    get applicationField() {
+        return this._applicationField;
+    }
+    set applicationField(value) {
+        if (value !== undefined && value !== null) {
+            this._field = ApplicationField.FieldCase.applicationField;
+        }
+        this._applicationField = value;
+    }
+    get field() {
+        return this._field;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        ApplicationField.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            applicationField: this.applicationField
+                ? this.applicationField.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 {
+            applicationField: this.applicationField
+                ? this.applicationField.toProtobufJSON(options)
+                : null
+        };
+    }
+}
+(function (ApplicationField) {
+    let FieldCase;
+    (function (FieldCase) {
+        FieldCase[FieldCase["none"] = 0] = "none";
+        FieldCase[FieldCase["applicationField"] = 1] = "applicationField";
+    })(FieldCase = ApplicationField.FieldCase || (ApplicationField.FieldCase = {}));
+})(ApplicationField || (ApplicationField = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"applications-fields.pb.js","sourceRoot":"","sources":["../../../../../../projects/aneoconsultingfr/armonik.api.angular/src/lib/generated/applications-fields.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';\nexport enum ApplicationRawEnumField {\n  APPLICATION_RAW_ENUM_FIELD_UNSPECIFIED = 0,\n  APPLICATION_RAW_ENUM_FIELD_NAME = 1,\n  APPLICATION_RAW_ENUM_FIELD_VERSION = 2,\n  APPLICATION_RAW_ENUM_FIELD_NAMESPACE = 3,\n  APPLICATION_RAW_ENUM_FIELD_SERVICE = 4\n}\n/**\n * Message implementation for armonik.api.grpc.v1.applications.ApplicationRawField\n */\nexport class ApplicationRawField implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.applications.ApplicationRawField';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new ApplicationRawField();\n    ApplicationRawField.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: ApplicationRawField) {\n    _instance.field = _instance.field || 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: ApplicationRawField,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.field = _reader.readEnum();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    ApplicationRawField.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: ApplicationRawField,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.field) {\n      _writer.writeEnum(1, _instance.field);\n    }\n  }\n\n  private _field: ApplicationRawEnumField;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of ApplicationRawField to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<ApplicationRawField.AsObject>) {\n    _value = _value || {};\n    this.field = _value.field;\n    ApplicationRawField.refineValues(this);\n  }\n  get field(): ApplicationRawEnumField {\n    return this._field;\n  }\n  set field(value: ApplicationRawEnumField) {\n    this._field = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    ApplicationRawField.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(): ApplicationRawField.AsObject {\n    return {\n      field: this.field\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  ): ApplicationRawField.AsProtobufJSON {\n    return {\n      field:\n        ApplicationRawEnumField[\n          this.field === null || this.field === undefined ? 0 : this.field\n        ]\n    };\n  }\n}\nexport module ApplicationRawField {\n  /**\n   * Standard JavaScript object representation for ApplicationRawField\n   */\n  export interface AsObject {\n    field: ApplicationRawEnumField;\n  }\n\n  /**\n   * Protobuf JSON representation for ApplicationRawField\n   */\n  export interface AsProtobufJSON {\n    field: string;\n  }\n}\n\n/**\n * Message implementation for armonik.api.grpc.v1.applications.ApplicationField\n */\nexport class ApplicationField implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.applications.ApplicationField';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new ApplicationField();\n    ApplicationField.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: ApplicationField) {}\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: ApplicationField,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.applicationField = new ApplicationRawField();\n          _reader.readMessage(\n            _instance.applicationField,\n            ApplicationRawField.deserializeBinaryFromReader\n          );\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    ApplicationField.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: ApplicationField,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.applicationField) {\n      _writer.writeMessage(\n        1,\n        _instance.applicationField as any,\n        ApplicationRawField.serializeBinaryToWriter\n      );\n    }\n  }\n\n  private _applicationField?: ApplicationRawField;\n\n  private _field: ApplicationField.FieldCase = ApplicationField.FieldCase.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 ApplicationField to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<ApplicationField.AsObject>) {\n    _value = _value || {};\n    this.applicationField = _value.applicationField\n      ? new ApplicationRawField(_value.applicationField)\n      : undefined;\n    ApplicationField.refineValues(this);\n  }\n  get applicationField(): ApplicationRawField | undefined {\n    return this._applicationField;\n  }\n  set applicationField(value: ApplicationRawField | undefined) {\n    if (value !== undefined && value !== null) {\n      this._field = ApplicationField.FieldCase.applicationField;\n    }\n    this._applicationField = value;\n  }\n  get field() {\n    return this._field;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    ApplicationField.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(): ApplicationField.AsObject {\n    return {\n      applicationField: this.applicationField\n        ? this.applicationField.toObject()\n        : undefined\n    };\n  }\n\n  /**\n   * Convenience method to support JSON.stringify(message), replicates the structure of toObject()\n   */\n  toJSON() {\n    return this.toObject();\n  }\n\n  /**\n   * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json\n   * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.\n   * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required\n   */\n  toProtobufJSON(\n    // @ts-ignore\n    options?: ToProtobufJSONOptions\n  ): ApplicationField.AsProtobufJSON {\n    return {\n      applicationField: this.applicationField\n        ? this.applicationField.toProtobufJSON(options)\n        : null\n    };\n  }\n}\nexport module ApplicationField {\n  /**\n   * Standard JavaScript object representation for ApplicationField\n   */\n  export interface AsObject {\n    applicationField?: ApplicationRawField.AsObject;\n  }\n\n  /**\n   * Protobuf JSON representation for ApplicationField\n   */\n  export interface AsProtobufJSON {\n    applicationField: ApplicationRawField.AsProtobufJSON | null;\n  }\n  export enum FieldCase {\n    none = 0,\n    applicationField = 1\n  }\n}\n"]}