@aneoconsultingfr/armonik.api.angular 3.15.0-edge.9.70e3bac → 3.15.1-edge.3.8082e78

package/esm2022/lib/generated/health-checks-common.pb.mjs

@@ -0,0 +1,331 @@
+import { BinaryReader, BinaryWriter } from 'google-protobuf';
+export var HealthStatusEnum;
+(function (HealthStatusEnum) {
+    HealthStatusEnum[HealthStatusEnum["HEALTH_STATUS_ENUM_UNSPECIFIED"] = 0] = "HEALTH_STATUS_ENUM_UNSPECIFIED";
+    HealthStatusEnum[HealthStatusEnum["HEALTH_STATUS_ENUM_HEALTHY"] = 1] = "HEALTH_STATUS_ENUM_HEALTHY";
+    HealthStatusEnum[HealthStatusEnum["HEALTH_STATUS_ENUM_DEGRADED"] = 2] = "HEALTH_STATUS_ENUM_DEGRADED";
+    HealthStatusEnum[HealthStatusEnum["HEALTH_STATUS_ENUM_UNHEALTHY"] = 3] = "HEALTH_STATUS_ENUM_UNHEALTHY";
+})(HealthStatusEnum || (HealthStatusEnum = {}));
+/**
+ * Message implementation for armonik.api.grpc.v1.health_checks.CheckHealthRequest
+ */
+export class CheckHealthRequest {
+    static { this.id = 'armonik.api.grpc.v1.health_checks.CheckHealthRequest'; }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new CheckHealthRequest();
+        CheckHealthRequest.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()) {
+                default:
+                    _reader.skipField();
+            }
+        }
+        CheckHealthRequest.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) { }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of CheckHealthRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        CheckHealthRequest.refineValues(this);
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        CheckHealthRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {};
+    }
+    /**
+     * 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 {};
+    }
+}
+/**
+ * Message implementation for armonik.api.grpc.v1.health_checks.CheckHealthResponse
+ */
+export class CheckHealthResponse {
+    static { this.id = 'armonik.api.grpc.v1.health_checks.CheckHealthResponse'; }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new CheckHealthResponse();
+        CheckHealthResponse.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.services = _instance.services || [];
+    }
+    /**
+     * 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 CheckHealthResponse.ServiceHealth();
+                    _reader.readMessage(messageInitializer1, CheckHealthResponse.ServiceHealth.deserializeBinaryFromReader);
+                    (_instance.services = _instance.services || []).push(messageInitializer1);
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        CheckHealthResponse.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.services && _instance.services.length) {
+            _writer.writeRepeatedMessage(1, _instance.services, CheckHealthResponse.ServiceHealth.serializeBinaryToWriter);
+        }
+    }
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of CheckHealthResponse to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.services = (_value.services || []).map(m => new CheckHealthResponse.ServiceHealth(m));
+        CheckHealthResponse.refineValues(this);
+    }
+    get services() {
+        return this._services;
+    }
+    set services(value) {
+        this._services = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        CheckHealthResponse.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            services: (this.services || []).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 {
+            services: (this.services || []).map(m => m.toProtobufJSON(options))
+        };
+    }
+}
+(function (CheckHealthResponse) {
+    /**
+     * Message implementation for armonik.api.grpc.v1.health_checks.CheckHealthResponse.ServiceHealth
+     */
+    class ServiceHealth {
+        static { this.id = 'armonik.api.grpc.v1.health_checks.CheckHealthResponse.ServiceHealth'; }
+        /**
+         * Deserialize binary data to message
+         * @param instance message instance
+         */
+        static deserializeBinary(bytes) {
+            const instance = new ServiceHealth();
+            ServiceHealth.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.name = _instance.name || '';
+            _instance.message = _instance.message || '';
+            _instance.healthy = _instance.healthy || 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.name = _reader.readString();
+                        break;
+                    case 2:
+                        _instance.message = _reader.readString();
+                        break;
+                    case 3:
+                        _instance.healthy = _reader.readEnum();
+                        break;
+                    default:
+                        _reader.skipField();
+                }
+            }
+            ServiceHealth.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.name) {
+                _writer.writeString(1, _instance.name);
+            }
+            if (_instance.message) {
+                _writer.writeString(2, _instance.message);
+            }
+            if (_instance.healthy) {
+                _writer.writeEnum(3, _instance.healthy);
+            }
+        }
+        /**
+         * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+         * @param _value initial values object or instance of ServiceHealth to deeply clone from
+         */
+        constructor(_value) {
+            _value = _value || {};
+            this.name = _value.name;
+            this.message = _value.message;
+            this.healthy = _value.healthy;
+            ServiceHealth.refineValues(this);
+        }
+        get name() {
+            return this._name;
+        }
+        set name(value) {
+            this._name = value;
+        }
+        get message() {
+            return this._message;
+        }
+        set message(value) {
+            this._message = value;
+        }
+        get healthy() {
+            return this._healthy;
+        }
+        set healthy(value) {
+            this._healthy = value;
+        }
+        /**
+         * Serialize message to binary data
+         * @param instance message instance
+         */
+        serializeBinary() {
+            const writer = new BinaryWriter();
+            ServiceHealth.serializeBinaryToWriter(this, writer);
+            return writer.getResultBuffer();
+        }
+        /**
+         * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+         */
+        toObject() {
+            return {
+                name: this.name,
+                message: this.message,
+                healthy: this.healthy
+            };
+        }
+        /**
+         * 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 {
+                name: this.name,
+                message: this.message,
+                healthy: HealthStatusEnum[this.healthy === null || this.healthy === undefined
+                    ? 0
+                    : this.healthy]
+            };
+        }
+    }
+    CheckHealthResponse.ServiceHealth = ServiceHealth;
+})(CheckHealthResponse || (CheckHealthResponse = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"health-checks-common.pb.js","sourceRoot":"","sources":["../../../../../../projects/aneoconsultingfr/armonik.api.angular/src/lib/generated/health-checks-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';\nexport enum HealthStatusEnum {\n  HEALTH_STATUS_ENUM_UNSPECIFIED = 0,\n  HEALTH_STATUS_ENUM_HEALTHY = 1,\n  HEALTH_STATUS_ENUM_DEGRADED = 2,\n  HEALTH_STATUS_ENUM_UNHEALTHY = 3\n}\n/**\n * Message implementation for armonik.api.grpc.v1.health_checks.CheckHealthRequest\n */\nexport class CheckHealthRequest implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.health_checks.CheckHealthRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new CheckHealthRequest();\n    CheckHealthRequest.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: CheckHealthRequest) {}\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: CheckHealthRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        default:\n          _reader.skipField();\n      }\n    }\n\n    CheckHealthRequest.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: CheckHealthRequest,\n    _writer: BinaryWriter\n  ) {}\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of CheckHealthRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<CheckHealthRequest.AsObject>) {\n    _value = _value || {};\n    CheckHealthRequest.refineValues(this);\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    CheckHealthRequest.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(): CheckHealthRequest.AsObject {\n    return {};\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  ): CheckHealthRequest.AsProtobufJSON {\n    return {};\n  }\n}\nexport module CheckHealthRequest {\n  /**\n   * Standard JavaScript object representation for CheckHealthRequest\n   */\n  export interface AsObject {}\n\n  /**\n   * Protobuf JSON representation for CheckHealthRequest\n   */\n  export interface AsProtobufJSON {}\n}\n\n/**\n * Message implementation for armonik.api.grpc.v1.health_checks.CheckHealthResponse\n */\nexport class CheckHealthResponse implements GrpcMessage {\n  static id = 'armonik.api.grpc.v1.health_checks.CheckHealthResponse';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new CheckHealthResponse();\n    CheckHealthResponse.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: CheckHealthResponse) {\n    _instance.services = _instance.services || [];\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: CheckHealthResponse,\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 CheckHealthResponse.ServiceHealth();\n          _reader.readMessage(\n            messageInitializer1,\n            CheckHealthResponse.ServiceHealth.deserializeBinaryFromReader\n          );\n          (_instance.services = _instance.services || []).push(\n            messageInitializer1\n          );\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    CheckHealthResponse.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: CheckHealthResponse,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.services && _instance.services.length) {\n      _writer.writeRepeatedMessage(\n        1,\n        _instance.services as any,\n        CheckHealthResponse.ServiceHealth.serializeBinaryToWriter\n      );\n    }\n  }\n\n  private _services?: CheckHealthResponse.ServiceHealth[];\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of CheckHealthResponse to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<CheckHealthResponse.AsObject>) {\n    _value = _value || {};\n    this.services = (_value.services || []).map(\n      m => new CheckHealthResponse.ServiceHealth(m)\n    );\n    CheckHealthResponse.refineValues(this);\n  }\n  get services(): CheckHealthResponse.ServiceHealth[] | undefined {\n    return this._services;\n  }\n  set services(value: CheckHealthResponse.ServiceHealth[] | undefined) {\n    this._services = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    CheckHealthResponse.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(): CheckHealthResponse.AsObject {\n    return {\n      services: (this.services || []).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  ): CheckHealthResponse.AsProtobufJSON {\n    return {\n      services: (this.services || []).map(m => m.toProtobufJSON(options))\n    };\n  }\n}\nexport module CheckHealthResponse {\n  /**\n   * Standard JavaScript object representation for CheckHealthResponse\n   */\n  export interface AsObject {\n    services?: CheckHealthResponse.ServiceHealth.AsObject[];\n  }\n\n  /**\n   * Protobuf JSON representation for CheckHealthResponse\n   */\n  export interface AsProtobufJSON {\n    services: CheckHealthResponse.ServiceHealth.AsProtobufJSON[] | null;\n  }\n\n  /**\n   * Message implementation for armonik.api.grpc.v1.health_checks.CheckHealthResponse.ServiceHealth\n   */\n  export class ServiceHealth implements GrpcMessage {\n    static id =\n      'armonik.api.grpc.v1.health_checks.CheckHealthResponse.ServiceHealth';\n\n    /**\n     * Deserialize binary data to message\n     * @param instance message instance\n     */\n    static deserializeBinary(bytes: ByteSource) {\n      const instance = new ServiceHealth();\n      ServiceHealth.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: ServiceHealth) {\n      _instance.name = _instance.name || '';\n      _instance.message = _instance.message || '';\n      _instance.healthy = _instance.healthy || 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: ServiceHealth,\n      _reader: BinaryReader\n    ) {\n      while (_reader.nextField()) {\n        if (_reader.isEndGroup()) break;\n\n        switch (_reader.getFieldNumber()) {\n          case 1:\n            _instance.name = _reader.readString();\n            break;\n          case 2:\n            _instance.message = _reader.readString();\n            break;\n          case 3:\n            _instance.healthy = _reader.readEnum();\n            break;\n          default:\n            _reader.skipField();\n        }\n      }\n\n      ServiceHealth.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: ServiceHealth,\n      _writer: BinaryWriter\n    ) {\n      if (_instance.name) {\n        _writer.writeString(1, _instance.name);\n      }\n      if (_instance.message) {\n        _writer.writeString(2, _instance.message);\n      }\n      if (_instance.healthy) {\n        _writer.writeEnum(3, _instance.healthy);\n      }\n    }\n\n    private _name: string;\n    private _message: string;\n    private _healthy: HealthStatusEnum;\n\n    /**\n     * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n     * @param _value initial values object or instance of ServiceHealth to deeply clone from\n     */\n    constructor(_value?: RecursivePartial<ServiceHealth.AsObject>) {\n      _value = _value || {};\n      this.name = _value.name;\n      this.message = _value.message;\n      this.healthy = _value.healthy;\n      ServiceHealth.refineValues(this);\n    }\n    get name(): string {\n      return this._name;\n    }\n    set name(value: string) {\n      this._name = value;\n    }\n    get message(): string {\n      return this._message;\n    }\n    set message(value: string) {\n      this._message = value;\n    }\n    get healthy(): HealthStatusEnum {\n      return this._healthy;\n    }\n    set healthy(value: HealthStatusEnum) {\n      this._healthy = value;\n    }\n\n    /**\n     * Serialize message to binary data\n     * @param instance message instance\n     */\n    serializeBinary() {\n      const writer = new BinaryWriter();\n      ServiceHealth.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(): ServiceHealth.AsObject {\n      return {\n        name: this.name,\n        message: this.message,\n        healthy: this.healthy\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    ): ServiceHealth.AsProtobufJSON {\n      return {\n        name: this.name,\n        message: this.message,\n        healthy:\n          HealthStatusEnum[\n            this.healthy === null || this.healthy === undefined\n              ? 0\n              : this.healthy\n          ]\n      };\n    }\n  }\n  export module ServiceHealth {\n    /**\n     * Standard JavaScript object representation for ServiceHealth\n     */\n    export interface AsObject {\n      name: string;\n      message: string;\n      healthy: HealthStatusEnum;\n    }\n\n    /**\n     * Protobuf JSON representation for ServiceHealth\n     */\n    export interface AsProtobufJSON {\n      name: string;\n      message: string;\n      healthy: string;\n    }\n  }\n}\n"]}

package/esm2022/lib/generated/health-checks-service.pb.mjs

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

package/esm2022/lib/generated/health-checks-service.pbconf.mjs

@@ -0,0 +1,13 @@
+/* tslint:disable */
+/* eslint-disable */
+// @ts-nocheck
+//
+// THIS IS A GENERATED FILE
+// DO NOT MODIFY IT! YOUR CHANGES WILL BE LOST
+import { InjectionToken } from '@angular/core';
+/**
+ * Specific GrpcClientSettings for HealthChecksService.
+ * Use it only if your default settings are not set or the service requires other settings.
+ */
+export const GRPC_HEALTH_CHECKS_SERVICE_CLIENT_SETTINGS = new InjectionToken('GRPC_HEALTH_CHECKS_SERVICE_CLIENT_SETTINGS');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGVhbHRoLWNoZWNrcy1zZXJ2aWNlLnBiY29uZi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2FuZW9jb25zdWx0aW5nZnIvYXJtb25pay5hcGkuYW5ndWxhci9zcmMvbGliL2dlbmVyYXRlZC9oZWFsdGgtY2hlY2tzLXNlcnZpY2UucGJjb25mLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLG9CQUFvQjtBQUNwQixvQkFBb0I7QUFDcEIsY0FBYztBQUNkLEVBQUU7QUFDRiwyQkFBMkI7QUFDM0IsOENBQThDO0FBQzlDLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFL0M7OztHQUdHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sMENBQTBDLEdBQUcsSUFBSSxjQUFjLENBRTFFLDRDQUE0QyxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKiB0c2xpbnQ6ZGlzYWJsZSAqL1xuLyogZXNsaW50LWRpc2FibGUgKi9cbi8vIEB0cy1ub2NoZWNrXG4vL1xuLy8gVEhJUyBJUyBBIEdFTkVSQVRFRCBGSUxFXG4vLyBETyBOT1QgTU9ESUZZIElUISBZT1VSIENIQU5HRVMgV0lMTCBCRSBMT1NUXG5pbXBvcnQgeyBJbmplY3Rpb25Ub2tlbiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG4vKipcbiAqIFNwZWNpZmljIEdycGNDbGllbnRTZXR0aW5ncyBmb3IgSGVhbHRoQ2hlY2tzU2VydmljZS5cbiAqIFVzZSBpdCBvbmx5IGlmIHlvdXIgZGVmYXVsdCBzZXR0aW5ncyBhcmUgbm90IHNldCBvciB0aGUgc2VydmljZSByZXF1aXJlcyBvdGhlciBzZXR0aW5ncy5cbiAqL1xuZXhwb3J0IGNvbnN0IEdSUENfSEVBTFRIX0NIRUNLU19TRVJWSUNFX0NMSUVOVF9TRVRUSU5HUyA9IG5ldyBJbmplY3Rpb25Ub2tlbjxcbiAgYW55XG4+KCdHUlBDX0hFQUxUSF9DSEVDS1NfU0VSVklDRV9DTElFTlRfU0VUVElOR1MnKTtcbiJdfQ==

package/esm2022/lib/generated/health-checks-service.pbsc.mjs

@@ -0,0 +1,74 @@
+/* tslint:disable */
+/* eslint-disable */
+// @ts-nocheck
+//
+// THIS IS A GENERATED FILE
+// DO NOT MODIFY IT! YOUR CHANGES WILL BE LOST
+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 armonikApiGrpcV1Health_checks000 from './health-checks-common.pb';
+import { GRPC_HEALTH_CHECKS_SERVICE_CLIENT_SETTINGS } from './health-checks-service.pbconf';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngx-grpc/core";
+/**
+ * Service client implementation for armonik.api.grpc.v1.health_checks.HealthChecksService
+ */
+export class HealthChecksServiceClient {
+    constructor(settings, clientFactory, handler) {
+        this.handler = handler;
+        /**
+         * Raw RPC implementation for each service client method.
+         * The raw methods provide more control on the incoming data and events. E.g. they can be useful to read status `OK` metadata.
+         * Attention: these methods do not throw errors when non-zero status codes are received.
+         */
+        this.$raw = {
+            /**
+             * Unary call: /armonik.api.grpc.v1.health_checks.HealthChecksService/CheckHealth
+             *
+             * @param requestMessage Request message
+             * @param requestMetadata Request metadata
+             * @returns Observable<GrpcEvent<armonikApiGrpcV1Health_checks000.CheckHealthResponse>>
+             */
+            checkHealth: (requestData, requestMetadata = new GrpcMetadata()) => {
+                return this.handler.handle({
+                    type: GrpcCallType.unary,
+                    client: this.client,
+                    path: '/armonik.api.grpc.v1.health_checks.HealthChecksService/CheckHealth',
+                    requestData,
+                    requestMetadata,
+                    requestClass: armonikApiGrpcV1Health_checks000.CheckHealthRequest,
+                    responseClass: armonikApiGrpcV1Health_checks000.CheckHealthResponse
+                });
+            }
+        };
+        this.client = clientFactory.createClient('armonik.api.grpc.v1.health_checks.HealthChecksService', settings);
+    }
+    /**
+     * Unary call @/armonik.api.grpc.v1.health_checks.HealthChecksService/CheckHealth
+     *
+     * @param requestMessage Request message
+     * @param requestMetadata Request metadata
+     * @returns Observable<armonikApiGrpcV1Health_checks000.CheckHealthResponse>
+     */
+    checkHealth(requestData, requestMetadata = new GrpcMetadata()) {
+        return this.$raw
+            .checkHealth(requestData, requestMetadata)
+            .pipe(throwStatusErrors(), takeMessages());
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.1", ngImport: i0, type: HealthChecksServiceClient, deps: [{ token: GRPC_HEALTH_CHECKS_SERVICE_CLIENT_SETTINGS, optional: true }, { token: GRPC_CLIENT_FACTORY }, { token: i1.GrpcHandler }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.1", ngImport: i0, type: HealthChecksServiceClient, providedIn: 'any' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.1", ngImport: i0, type: HealthChecksServiceClient, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'any' }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [GRPC_HEALTH_CHECKS_SERVICE_CLIENT_SETTINGS]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [GRPC_CLIENT_FACTORY]
+                }] }, { type: i1.GrpcHandler }]; } });
+//# sourceMappingURL=data:application/json;base64,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