@ondewo/csi-client-angular 2.3.1

package/esm2020/api/ondewo/nlu/project-statistics.pb.mjs

@@ -0,0 +1,460 @@
+import { BinaryReader, BinaryWriter } from 'google-protobuf';
+import * as ondewoNlu010 from '../../ondewo/nlu/intent.pb';
+import * as ondewoNlu011 from '../../ondewo/nlu/entity-type.pb';
+/**
+ * Message implementation for ondewo.nlu.GetIntentCountRequest
+ */
+export class GetIntentCountRequest {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of GetIntentCountRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.parent = _value.parent;
+        this.filterByCategory = _value.filterByCategory;
+        GetIntentCountRequest.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new GetIntentCountRequest();
+        GetIntentCountRequest.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.parent = _instance.parent || '';
+        _instance.filterByCategory = _instance.filterByCategory || 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.parent = _reader.readString();
+                    break;
+                case 2:
+                    _instance.filterByCategory = _reader.readEnum();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        GetIntentCountRequest.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.parent) {
+            _writer.writeString(1, _instance.parent);
+        }
+        if (_instance.filterByCategory) {
+            _writer.writeEnum(2, _instance.filterByCategory);
+        }
+    }
+    get parent() {
+        return this._parent;
+    }
+    set parent(value) {
+        this._parent = value;
+    }
+    get filterByCategory() {
+        return this._filterByCategory;
+    }
+    set filterByCategory(value) {
+        this._filterByCategory = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        GetIntentCountRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            parent: this.parent,
+            filterByCategory: this.filterByCategory
+        };
+    }
+    /**
+     * 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 {
+            parent: this.parent,
+            filterByCategory: ondewoNlu010.IntentCategory[this.filterByCategory === null || this.filterByCategory === undefined
+                ? 0
+                : this.filterByCategory]
+        };
+    }
+}
+GetIntentCountRequest.id = 'ondewo.nlu.GetIntentCountRequest';
+/**
+ * Message implementation for ondewo.nlu.GetEntityTypeCountRequest
+ */
+export class GetEntityTypeCountRequest {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of GetEntityTypeCountRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.parent = _value.parent;
+        this.filterByCategory = _value.filterByCategory;
+        GetEntityTypeCountRequest.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new GetEntityTypeCountRequest();
+        GetEntityTypeCountRequest.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.parent = _instance.parent || '';
+        _instance.filterByCategory = _instance.filterByCategory || 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.parent = _reader.readString();
+                    break;
+                case 2:
+                    _instance.filterByCategory = _reader.readEnum();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        GetEntityTypeCountRequest.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.parent) {
+            _writer.writeString(1, _instance.parent);
+        }
+        if (_instance.filterByCategory) {
+            _writer.writeEnum(2, _instance.filterByCategory);
+        }
+    }
+    get parent() {
+        return this._parent;
+    }
+    set parent(value) {
+        this._parent = value;
+    }
+    get filterByCategory() {
+        return this._filterByCategory;
+    }
+    set filterByCategory(value) {
+        this._filterByCategory = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        GetEntityTypeCountRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            parent: this.parent,
+            filterByCategory: this.filterByCategory
+        };
+    }
+    /**
+     * 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 {
+            parent: this.parent,
+            filterByCategory: ondewoNlu011.EntityTypeCategory[this.filterByCategory === null || this.filterByCategory === undefined
+                ? 0
+                : this.filterByCategory]
+        };
+    }
+}
+GetEntityTypeCountRequest.id = 'ondewo.nlu.GetEntityTypeCountRequest';
+/**
+ * Message implementation for ondewo.nlu.GetProjectStatRequest
+ */
+export class GetProjectStatRequest {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of GetProjectStatRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.parent = _value.parent;
+        GetProjectStatRequest.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new GetProjectStatRequest();
+        GetProjectStatRequest.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.parent = _instance.parent || '';
+    }
+    /**
+     * 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.parent = _reader.readString();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        GetProjectStatRequest.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.parent) {
+            _writer.writeString(1, _instance.parent);
+        }
+    }
+    get parent() {
+        return this._parent;
+    }
+    set parent(value) {
+        this._parent = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        GetProjectStatRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            parent: this.parent
+        };
+    }
+    /**
+     * 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 {
+            parent: this.parent
+        };
+    }
+}
+GetProjectStatRequest.id = 'ondewo.nlu.GetProjectStatRequest';
+/**
+ * Message implementation for ondewo.nlu.GetProjectElementStatRequest
+ */
+export class GetProjectElementStatRequest {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of GetProjectElementStatRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.name = _value.name;
+        this.languageCode = _value.languageCode;
+        GetProjectElementStatRequest.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new GetProjectElementStatRequest();
+        GetProjectElementStatRequest.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.languageCode = _instance.languageCode || '';
+    }
+    /**
+     * 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.languageCode = _reader.readString();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        GetProjectElementStatRequest.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.languageCode) {
+            _writer.writeString(2, _instance.languageCode);
+        }
+    }
+    get name() {
+        return this._name;
+    }
+    set name(value) {
+        this._name = value;
+    }
+    get languageCode() {
+        return this._languageCode;
+    }
+    set languageCode(value) {
+        this._languageCode = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        GetProjectElementStatRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            name: this.name,
+            languageCode: this.languageCode
+        };
+    }
+    /**
+     * 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,
+            languageCode: this.languageCode
+        };
+    }
+}
+GetProjectElementStatRequest.id = 'ondewo.nlu.GetProjectElementStatRequest';
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"project-statistics.pb.js","sourceRoot":"","sources":["../../../../../api/ondewo/nlu/project-statistics.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 googleApi000 from '../../google/api/http.pb';\nimport * as googleProtobuf001 from '@ngx-grpc/well-known-types';\nimport * as googleApi002 from '../../google/api/annotations.pb';\nimport * as ondewoNlu003 from '../../ondewo/nlu/context.pb';\nimport * as ondewoNlu004 from '../../ondewo/nlu/common.pb';\nimport * as ondewoNlu005 from '../../ondewo/nlu/operations.pb';\nimport * as googleProtobuf006 from '@ngx-grpc/well-known-types';\nimport * as googleProtobuf007 from '@ngx-grpc/well-known-types';\nimport * as googleProtobuf008 from '@ngx-grpc/well-known-types';\nimport * as googleProtobuf009 from '@ngx-grpc/well-known-types';\nimport * as ondewoNlu010 from '../../ondewo/nlu/intent.pb';\nimport * as ondewoNlu011 from '../../ondewo/nlu/entity-type.pb';\n/**\n * Message implementation for ondewo.nlu.GetIntentCountRequest\n */\nexport class GetIntentCountRequest implements GrpcMessage {\n  static id = 'ondewo.nlu.GetIntentCountRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new GetIntentCountRequest();\n    GetIntentCountRequest.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: GetIntentCountRequest) {\n    _instance.parent = _instance.parent || '';\n    _instance.filterByCategory = _instance.filterByCategory || 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: GetIntentCountRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.parent = _reader.readString();\n          break;\n        case 2:\n          _instance.filterByCategory = _reader.readEnum();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    GetIntentCountRequest.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: GetIntentCountRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.parent) {\n      _writer.writeString(1, _instance.parent);\n    }\n    if (_instance.filterByCategory) {\n      _writer.writeEnum(2, _instance.filterByCategory);\n    }\n  }\n\n  private _parent?: string;\n  private _filterByCategory?: ondewoNlu010.IntentCategory;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of GetIntentCountRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<GetIntentCountRequest.AsObject>) {\n    _value = _value || {};\n    this.parent = _value.parent;\n    this.filterByCategory = _value.filterByCategory;\n    GetIntentCountRequest.refineValues(this);\n  }\n  get parent(): string | undefined {\n    return this._parent;\n  }\n  set parent(value: string | undefined) {\n    this._parent = value;\n  }\n  get filterByCategory(): ondewoNlu010.IntentCategory | undefined {\n    return this._filterByCategory;\n  }\n  set filterByCategory(value: ondewoNlu010.IntentCategory | undefined) {\n    this._filterByCategory = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    GetIntentCountRequest.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(): GetIntentCountRequest.AsObject {\n    return {\n      parent: this.parent,\n      filterByCategory: this.filterByCategory\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  ): GetIntentCountRequest.AsProtobufJSON {\n    return {\n      parent: this.parent,\n      filterByCategory:\n        ondewoNlu010.IntentCategory[\n          this.filterByCategory === null || this.filterByCategory === undefined\n            ? 0\n            : this.filterByCategory\n        ]\n    };\n  }\n}\nexport module GetIntentCountRequest {\n  /**\n   * Standard JavaScript object representation for GetIntentCountRequest\n   */\n  export interface AsObject {\n    parent?: string;\n    filterByCategory?: ondewoNlu010.IntentCategory;\n  }\n\n  /**\n   * Protobuf JSON representation for GetIntentCountRequest\n   */\n  export interface AsProtobufJSON {\n    parent?: string;\n    filterByCategory?: string;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.GetEntityTypeCountRequest\n */\nexport class GetEntityTypeCountRequest implements GrpcMessage {\n  static id = 'ondewo.nlu.GetEntityTypeCountRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new GetEntityTypeCountRequest();\n    GetEntityTypeCountRequest.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: GetEntityTypeCountRequest) {\n    _instance.parent = _instance.parent || '';\n    _instance.filterByCategory = _instance.filterByCategory || 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: GetEntityTypeCountRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.parent = _reader.readString();\n          break;\n        case 2:\n          _instance.filterByCategory = _reader.readEnum();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    GetEntityTypeCountRequest.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: GetEntityTypeCountRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.parent) {\n      _writer.writeString(1, _instance.parent);\n    }\n    if (_instance.filterByCategory) {\n      _writer.writeEnum(2, _instance.filterByCategory);\n    }\n  }\n\n  private _parent?: string;\n  private _filterByCategory?: ondewoNlu011.EntityTypeCategory;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of GetEntityTypeCountRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<GetEntityTypeCountRequest.AsObject>) {\n    _value = _value || {};\n    this.parent = _value.parent;\n    this.filterByCategory = _value.filterByCategory;\n    GetEntityTypeCountRequest.refineValues(this);\n  }\n  get parent(): string | undefined {\n    return this._parent;\n  }\n  set parent(value: string | undefined) {\n    this._parent = value;\n  }\n  get filterByCategory(): ondewoNlu011.EntityTypeCategory | undefined {\n    return this._filterByCategory;\n  }\n  set filterByCategory(value: ondewoNlu011.EntityTypeCategory | undefined) {\n    this._filterByCategory = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    GetEntityTypeCountRequest.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(): GetEntityTypeCountRequest.AsObject {\n    return {\n      parent: this.parent,\n      filterByCategory: this.filterByCategory\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  ): GetEntityTypeCountRequest.AsProtobufJSON {\n    return {\n      parent: this.parent,\n      filterByCategory:\n        ondewoNlu011.EntityTypeCategory[\n          this.filterByCategory === null || this.filterByCategory === undefined\n            ? 0\n            : this.filterByCategory\n        ]\n    };\n  }\n}\nexport module GetEntityTypeCountRequest {\n  /**\n   * Standard JavaScript object representation for GetEntityTypeCountRequest\n   */\n  export interface AsObject {\n    parent?: string;\n    filterByCategory?: ondewoNlu011.EntityTypeCategory;\n  }\n\n  /**\n   * Protobuf JSON representation for GetEntityTypeCountRequest\n   */\n  export interface AsProtobufJSON {\n    parent?: string;\n    filterByCategory?: string;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.GetProjectStatRequest\n */\nexport class GetProjectStatRequest implements GrpcMessage {\n  static id = 'ondewo.nlu.GetProjectStatRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new GetProjectStatRequest();\n    GetProjectStatRequest.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: GetProjectStatRequest) {\n    _instance.parent = _instance.parent || '';\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: GetProjectStatRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.parent = _reader.readString();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    GetProjectStatRequest.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: GetProjectStatRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.parent) {\n      _writer.writeString(1, _instance.parent);\n    }\n  }\n\n  private _parent?: string;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of GetProjectStatRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<GetProjectStatRequest.AsObject>) {\n    _value = _value || {};\n    this.parent = _value.parent;\n    GetProjectStatRequest.refineValues(this);\n  }\n  get parent(): string | undefined {\n    return this._parent;\n  }\n  set parent(value: string | undefined) {\n    this._parent = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    GetProjectStatRequest.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(): GetProjectStatRequest.AsObject {\n    return {\n      parent: this.parent\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  ): GetProjectStatRequest.AsProtobufJSON {\n    return {\n      parent: this.parent\n    };\n  }\n}\nexport module GetProjectStatRequest {\n  /**\n   * Standard JavaScript object representation for GetProjectStatRequest\n   */\n  export interface AsObject {\n    parent?: string;\n  }\n\n  /**\n   * Protobuf JSON representation for GetProjectStatRequest\n   */\n  export interface AsProtobufJSON {\n    parent?: string;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.GetProjectElementStatRequest\n */\nexport class GetProjectElementStatRequest implements GrpcMessage {\n  static id = 'ondewo.nlu.GetProjectElementStatRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new GetProjectElementStatRequest();\n    GetProjectElementStatRequest.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: GetProjectElementStatRequest) {\n    _instance.name = _instance.name || '';\n    _instance.languageCode = _instance.languageCode || '';\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: GetProjectElementStatRequest,\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.languageCode = _reader.readString();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    GetProjectElementStatRequest.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: GetProjectElementStatRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.name) {\n      _writer.writeString(1, _instance.name);\n    }\n    if (_instance.languageCode) {\n      _writer.writeString(2, _instance.languageCode);\n    }\n  }\n\n  private _name?: string;\n  private _languageCode?: string;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of GetProjectElementStatRequest to deeply clone from\n   */\n  constructor(\n    _value?: RecursivePartial<GetProjectElementStatRequest.AsObject>\n  ) {\n    _value = _value || {};\n    this.name = _value.name;\n    this.languageCode = _value.languageCode;\n    GetProjectElementStatRequest.refineValues(this);\n  }\n  get name(): string | undefined {\n    return this._name;\n  }\n  set name(value: string | undefined) {\n    this._name = value;\n  }\n  get languageCode(): string | undefined {\n    return this._languageCode;\n  }\n  set languageCode(value: string | undefined) {\n    this._languageCode = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    GetProjectElementStatRequest.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(): GetProjectElementStatRequest.AsObject {\n    return {\n      name: this.name,\n      languageCode: this.languageCode\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  ): GetProjectElementStatRequest.AsProtobufJSON {\n    return {\n      name: this.name,\n      languageCode: this.languageCode\n    };\n  }\n}\nexport module GetProjectElementStatRequest {\n  /**\n   * Standard JavaScript object representation for GetProjectElementStatRequest\n   */\n  export interface AsObject {\n    name?: string;\n    languageCode?: string;\n  }\n\n  /**\n   * Protobuf JSON representation for GetProjectElementStatRequest\n   */\n  export interface AsProtobufJSON {\n    name?: string;\n    languageCode?: string;\n  }\n}\n"]}

package/esm2020/api/ondewo/nlu/project-statistics.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 ProjectStatistics.
+ * Use it only if your default settings are not set or the service requires other settings.
+ */
+export const GRPC_PROJECT_STATISTICS_CLIENT_SETTINGS = new InjectionToken('GRPC_PROJECT_STATISTICS_CLIENT_SETTINGS');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvamVjdC1zdGF0aXN0aWNzLnBiY29uZi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2FwaS9vbmRld28vbmx1L3Byb2plY3Qtc3RhdGlzdGljcy5wYmNvbmYudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsb0JBQW9CO0FBQ3BCLG9CQUFvQjtBQUNwQixjQUFjO0FBQ2QsRUFBRTtBQUNGLDJCQUEyQjtBQUMzQiw4Q0FBOEM7QUFDOUMsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUUvQzs7O0dBR0c7QUFDSCxNQUFNLENBQUMsTUFBTSx1Q0FBdUMsR0FBRyxJQUFJLGNBQWMsQ0FDdkUseUNBQXlDLENBQzFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKiB0c2xpbnQ6ZGlzYWJsZSAqL1xuLyogZXNsaW50LWRpc2FibGUgKi9cbi8vIEB0cy1ub2NoZWNrXG4vL1xuLy8gVEhJUyBJUyBBIEdFTkVSQVRFRCBGSUxFXG4vLyBETyBOT1QgTU9ESUZZIElUISBZT1VSIENIQU5HRVMgV0lMTCBCRSBMT1NUXG5pbXBvcnQgeyBJbmplY3Rpb25Ub2tlbiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG4vKipcbiAqIFNwZWNpZmljIEdycGNDbGllbnRTZXR0aW5ncyBmb3IgUHJvamVjdFN0YXRpc3RpY3MuXG4gKiBVc2UgaXQgb25seSBpZiB5b3VyIGRlZmF1bHQgc2V0dGluZ3MgYXJlIG5vdCBzZXQgb3IgdGhlIHNlcnZpY2UgcmVxdWlyZXMgb3RoZXIgc2V0dGluZ3MuXG4gKi9cbmV4cG9ydCBjb25zdCBHUlBDX1BST0pFQ1RfU1RBVElTVElDU19DTElFTlRfU0VUVElOR1MgPSBuZXcgSW5qZWN0aW9uVG9rZW48YW55PihcbiAgJ0dSUENfUFJPSkVDVF9TVEFUSVNUSUNTX0NMSUVOVF9TRVRUSU5HUydcbik7XG4iXX0=