@ondewo/csi-client-angular 2.3.1

package/esm2020/api/ondewo/nlu/utility.pb.mjs

@@ -0,0 +1,3302 @@
+/* tslint:disable */
+/* eslint-disable */
+// @ts-nocheck
+//
+// THIS IS A GENERATED FILE
+// DO NOT MODIFY IT! YOUR CHANGES WILL BE LOST
+import { uint8ArrayToBase64 } from '@ngx-grpc/common';
+import { BinaryReader, BinaryWriter } from 'google-protobuf';
+import * as ondewoNlu008 from '../../ondewo/nlu/intent.pb';
+import * as ondewoNlu009 from '../../ondewo/nlu/entity-type.pb';
+export var ReannotateEntitiesOptions;
+(function (ReannotateEntitiesOptions) {
+    ReannotateEntitiesOptions[ReannotateEntitiesOptions["REANNOTATE_NEVER"] = 0] = "REANNOTATE_NEVER";
+    ReannotateEntitiesOptions[ReannotateEntitiesOptions["REANNOTATE_ALWAYS"] = 1] = "REANNOTATE_ALWAYS";
+    ReannotateEntitiesOptions[ReannotateEntitiesOptions["REANNOTATE_IF_EMPTY"] = 2] = "REANNOTATE_IF_EMPTY";
+    ReannotateEntitiesOptions[ReannotateEntitiesOptions["REANNOTATE_AFTER_DELETION"] = 3] = "REANNOTATE_AFTER_DELETION";
+    ReannotateEntitiesOptions[ReannotateEntitiesOptions["REANNOTATE_IF_EMPTY_OR_AFTER_DELETION"] = 4] = "REANNOTATE_IF_EMPTY_OR_AFTER_DELETION";
+})(ReannotateEntitiesOptions || (ReannotateEntitiesOptions = {}));
+/**
+ * Message implementation for ondewo.nlu.ValidateRegexRequest
+ */
+export class ValidateRegexRequest {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of ValidateRegexRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.regex = _value.regex;
+        ValidateRegexRequest.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new ValidateRegexRequest();
+        ValidateRegexRequest.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.regex = _instance.regex || '';
+    }
+    /**
+     * 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.regex = _reader.readString();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        ValidateRegexRequest.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.regex) {
+            _writer.writeString(1, _instance.regex);
+        }
+    }
+    get regex() {
+        return this._regex;
+    }
+    set regex(value) {
+        this._regex = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        ValidateRegexRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            regex: this.regex
+        };
+    }
+    /**
+     * 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 {
+            regex: this.regex
+        };
+    }
+}
+ValidateRegexRequest.id = 'ondewo.nlu.ValidateRegexRequest';
+/**
+ * Message implementation for ondewo.nlu.ValidateRegexResponse
+ */
+export class ValidateRegexResponse {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of ValidateRegexResponse to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.errorMessages = (_value.errorMessages || []).slice();
+        ValidateRegexResponse.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new ValidateRegexResponse();
+        ValidateRegexResponse.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.errorMessages = _instance.errorMessages || [];
+    }
+    /**
+     * 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.errorMessages = _instance.errorMessages || []).push(_reader.readString());
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        ValidateRegexResponse.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.errorMessages && _instance.errorMessages.length) {
+            _writer.writeRepeatedString(1, _instance.errorMessages);
+        }
+    }
+    get errorMessages() {
+        return this._errorMessages;
+    }
+    set errorMessages(value) {
+        this._errorMessages = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        ValidateRegexResponse.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            errorMessages: (this.errorMessages || []).slice()
+        };
+    }
+    /**
+     * 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 {
+            errorMessages: (this.errorMessages || []).slice()
+        };
+    }
+}
+ValidateRegexResponse.id = 'ondewo.nlu.ValidateRegexResponse';
+/**
+ * Message implementation for ondewo.nlu.ValidateEmbeddedRegexRequest
+ */
+export class ValidateEmbeddedRegexRequest {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of ValidateEmbeddedRegexRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.entityType = _value.entityType
+            ? new ondewoNlu009.EntityType.Entity(_value.entityType)
+            : undefined;
+        ValidateEmbeddedRegexRequest.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new ValidateEmbeddedRegexRequest();
+        ValidateEmbeddedRegexRequest.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.entityType = _instance.entityType || 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.entityType = new ondewoNlu009.EntityType.Entity();
+                    _reader.readMessage(_instance.entityType, ondewoNlu009.EntityType.Entity.deserializeBinaryFromReader);
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        ValidateEmbeddedRegexRequest.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.entityType) {
+            _writer.writeMessage(1, _instance.entityType, ondewoNlu009.EntityType.Entity.serializeBinaryToWriter);
+        }
+    }
+    get entityType() {
+        return this._entityType;
+    }
+    set entityType(value) {
+        this._entityType = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        ValidateEmbeddedRegexRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            entityType: this.entityType ? this.entityType.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 {
+            entityType: this.entityType
+                ? this.entityType.toProtobufJSON(options)
+                : null
+        };
+    }
+}
+ValidateEmbeddedRegexRequest.id = 'ondewo.nlu.ValidateEmbeddedRegexRequest';
+/**
+ * Message implementation for ondewo.nlu.ValidateEmbeddedRegexResponse
+ */
+export class ValidateEmbeddedRegexResponse {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of ValidateEmbeddedRegexResponse to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.errorMessages = (_value.errorMessages || []).slice();
+        ValidateEmbeddedRegexResponse.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new ValidateEmbeddedRegexResponse();
+        ValidateEmbeddedRegexResponse.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.errorMessages = _instance.errorMessages || [];
+    }
+    /**
+     * 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.errorMessages = _instance.errorMessages || []).push(_reader.readString());
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        ValidateEmbeddedRegexResponse.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.errorMessages && _instance.errorMessages.length) {
+            _writer.writeRepeatedString(1, _instance.errorMessages);
+        }
+    }
+    get errorMessages() {
+        return this._errorMessages;
+    }
+    set errorMessages(value) {
+        this._errorMessages = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        ValidateEmbeddedRegexResponse.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            errorMessages: (this.errorMessages || []).slice()
+        };
+    }
+    /**
+     * 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 {
+            errorMessages: (this.errorMessages || []).slice()
+        };
+    }
+}
+ValidateEmbeddedRegexResponse.id = 'ondewo.nlu.ValidateEmbeddedRegexResponse';
+/**
+ * Message implementation for ondewo.nlu.CleanAllIntentsRequest
+ */
+export class CleanAllIntentsRequest {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of CleanAllIntentsRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.parent = _value.parent;
+        this.languageCode = _value.languageCode;
+        this.specialCharacters = _value.specialCharacters;
+        this.substringWhiteList = (_value.substringWhiteList || []).slice();
+        this.dryRun = _value.dryRun;
+        this.trainingPhraseCleanerOptions = _value.trainingPhraseCleanerOptions
+            ? new TrainingPhraseCleanerOptions(_value.trainingPhraseCleanerOptions)
+            : undefined;
+        this.reannotateEntitiesOptions = _value.reannotateEntitiesOptions;
+        this.numberOfWorkers = _value.numberOfWorkers;
+        CleanAllIntentsRequest.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new CleanAllIntentsRequest();
+        CleanAllIntentsRequest.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.languageCode = _instance.languageCode || '';
+        _instance.specialCharacters = _instance.specialCharacters || '';
+        _instance.substringWhiteList = _instance.substringWhiteList || [];
+        _instance.dryRun = _instance.dryRun || false;
+        _instance.trainingPhraseCleanerOptions =
+            _instance.trainingPhraseCleanerOptions || undefined;
+        _instance.reannotateEntitiesOptions =
+            _instance.reannotateEntitiesOptions || 0;
+        _instance.numberOfWorkers = _instance.numberOfWorkers || 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.languageCode = _reader.readString();
+                    break;
+                case 3:
+                    _instance.specialCharacters = _reader.readString();
+                    break;
+                case 4:
+                    (_instance.substringWhiteList =
+                        _instance.substringWhiteList || []).push(_reader.readString());
+                    break;
+                case 5:
+                    _instance.dryRun = _reader.readBool();
+                    break;
+                case 6:
+                    _instance.trainingPhraseCleanerOptions = new TrainingPhraseCleanerOptions();
+                    _reader.readMessage(_instance.trainingPhraseCleanerOptions, TrainingPhraseCleanerOptions.deserializeBinaryFromReader);
+                    break;
+                case 7:
+                    _instance.reannotateEntitiesOptions = _reader.readEnum();
+                    break;
+                case 8:
+                    _instance.numberOfWorkers = _reader.readInt32();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        CleanAllIntentsRequest.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.languageCode) {
+            _writer.writeString(2, _instance.languageCode);
+        }
+        if (_instance.specialCharacters) {
+            _writer.writeString(3, _instance.specialCharacters);
+        }
+        if (_instance.substringWhiteList && _instance.substringWhiteList.length) {
+            _writer.writeRepeatedString(4, _instance.substringWhiteList);
+        }
+        if (_instance.dryRun) {
+            _writer.writeBool(5, _instance.dryRun);
+        }
+        if (_instance.trainingPhraseCleanerOptions) {
+            _writer.writeMessage(6, _instance.trainingPhraseCleanerOptions, TrainingPhraseCleanerOptions.serializeBinaryToWriter);
+        }
+        if (_instance.reannotateEntitiesOptions) {
+            _writer.writeEnum(7, _instance.reannotateEntitiesOptions);
+        }
+        if (_instance.numberOfWorkers) {
+            _writer.writeInt32(8, _instance.numberOfWorkers);
+        }
+    }
+    get parent() {
+        return this._parent;
+    }
+    set parent(value) {
+        this._parent = value;
+    }
+    get languageCode() {
+        return this._languageCode;
+    }
+    set languageCode(value) {
+        this._languageCode = value;
+    }
+    get specialCharacters() {
+        return this._specialCharacters;
+    }
+    set specialCharacters(value) {
+        this._specialCharacters = value;
+    }
+    get substringWhiteList() {
+        return this._substringWhiteList;
+    }
+    set substringWhiteList(value) {
+        this._substringWhiteList = value;
+    }
+    get dryRun() {
+        return this._dryRun;
+    }
+    set dryRun(value) {
+        this._dryRun = value;
+    }
+    get trainingPhraseCleanerOptions() {
+        return this._trainingPhraseCleanerOptions;
+    }
+    set trainingPhraseCleanerOptions(value) {
+        this._trainingPhraseCleanerOptions = value;
+    }
+    get reannotateEntitiesOptions() {
+        return this._reannotateEntitiesOptions;
+    }
+    set reannotateEntitiesOptions(value) {
+        this._reannotateEntitiesOptions = value;
+    }
+    get numberOfWorkers() {
+        return this._numberOfWorkers;
+    }
+    set numberOfWorkers(value) {
+        this._numberOfWorkers = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        CleanAllIntentsRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            parent: this.parent,
+            languageCode: this.languageCode,
+            specialCharacters: this.specialCharacters,
+            substringWhiteList: (this.substringWhiteList || []).slice(),
+            dryRun: this.dryRun,
+            trainingPhraseCleanerOptions: this.trainingPhraseCleanerOptions
+                ? this.trainingPhraseCleanerOptions.toObject()
+                : undefined,
+            reannotateEntitiesOptions: this.reannotateEntitiesOptions,
+            numberOfWorkers: this.numberOfWorkers
+        };
+    }
+    /**
+     * 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,
+            languageCode: this.languageCode,
+            specialCharacters: this.specialCharacters,
+            substringWhiteList: (this.substringWhiteList || []).slice(),
+            dryRun: this.dryRun,
+            trainingPhraseCleanerOptions: this.trainingPhraseCleanerOptions
+                ? this.trainingPhraseCleanerOptions.toProtobufJSON(options)
+                : null,
+            reannotateEntitiesOptions: ReannotateEntitiesOptions[this.reannotateEntitiesOptions === null ||
+                this.reannotateEntitiesOptions === undefined
+                ? 0
+                : this.reannotateEntitiesOptions],
+            numberOfWorkers: this.numberOfWorkers
+        };
+    }
+}
+CleanAllIntentsRequest.id = 'ondewo.nlu.CleanAllIntentsRequest';
+/**
+ * Message implementation for ondewo.nlu.CleanAllIntentsResponse
+ */
+export class CleanAllIntentsResponse {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of CleanAllIntentsResponse to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.cleanedIntents = (_value.cleanedIntents || []).map(m => new ondewoNlu008.Intent(m));
+        this.intentUpdateList = (_value.intentUpdateList || []).map(m => new IntentUpdate(m));
+        CleanAllIntentsResponse.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new CleanAllIntentsResponse();
+        CleanAllIntentsResponse.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.cleanedIntents = _instance.cleanedIntents || [];
+        _instance.intentUpdateList = _instance.intentUpdateList || [];
+    }
+    /**
+     * 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 ondewoNlu008.Intent();
+                    _reader.readMessage(messageInitializer1, ondewoNlu008.Intent.deserializeBinaryFromReader);
+                    (_instance.cleanedIntents = _instance.cleanedIntents || []).push(messageInitializer1);
+                    break;
+                case 2:
+                    const messageInitializer2 = new IntentUpdate();
+                    _reader.readMessage(messageInitializer2, IntentUpdate.deserializeBinaryFromReader);
+                    (_instance.intentUpdateList = _instance.intentUpdateList || []).push(messageInitializer2);
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        CleanAllIntentsResponse.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.cleanedIntents && _instance.cleanedIntents.length) {
+            _writer.writeRepeatedMessage(1, _instance.cleanedIntents, ondewoNlu008.Intent.serializeBinaryToWriter);
+        }
+        if (_instance.intentUpdateList && _instance.intentUpdateList.length) {
+            _writer.writeRepeatedMessage(2, _instance.intentUpdateList, IntentUpdate.serializeBinaryToWriter);
+        }
+    }
+    get cleanedIntents() {
+        return this._cleanedIntents;
+    }
+    set cleanedIntents(value) {
+        this._cleanedIntents = value;
+    }
+    get intentUpdateList() {
+        return this._intentUpdateList;
+    }
+    set intentUpdateList(value) {
+        this._intentUpdateList = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        CleanAllIntentsResponse.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            cleanedIntents: (this.cleanedIntents || []).map(m => m.toObject()),
+            intentUpdateList: (this.intentUpdateList || []).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 {
+            cleanedIntents: (this.cleanedIntents || []).map(m => m.toProtobufJSON(options)),
+            intentUpdateList: (this.intentUpdateList || []).map(m => m.toProtobufJSON(options))
+        };
+    }
+}
+CleanAllIntentsResponse.id = 'ondewo.nlu.CleanAllIntentsResponse';
+/**
+ * Message implementation for ondewo.nlu.CleanIntentRequest
+ */
+export class CleanIntentRequest {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of CleanIntentRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.parent = _value.parent;
+        this.intentName = _value.intentName;
+        this.languageCode = _value.languageCode;
+        this.specialCharacters = _value.specialCharacters;
+        this.substringWhiteList = (_value.substringWhiteList || []).slice();
+        this.dryRun = _value.dryRun;
+        this.trainingPhraseCleanerOptions = _value.trainingPhraseCleanerOptions
+            ? new TrainingPhraseCleanerOptions(_value.trainingPhraseCleanerOptions)
+            : undefined;
+        this.reannotateEntitiesOptions = _value.reannotateEntitiesOptions;
+        CleanIntentRequest.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new CleanIntentRequest();
+        CleanIntentRequest.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.intentName = _instance.intentName || '';
+        _instance.languageCode = _instance.languageCode || '';
+        _instance.specialCharacters = _instance.specialCharacters || '';
+        _instance.substringWhiteList = _instance.substringWhiteList || [];
+        _instance.dryRun = _instance.dryRun || false;
+        _instance.trainingPhraseCleanerOptions =
+            _instance.trainingPhraseCleanerOptions || undefined;
+        _instance.reannotateEntitiesOptions =
+            _instance.reannotateEntitiesOptions || 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.intentName = _reader.readString();
+                    break;
+                case 3:
+                    _instance.languageCode = _reader.readString();
+                    break;
+                case 4:
+                    _instance.specialCharacters = _reader.readString();
+                    break;
+                case 5:
+                    (_instance.substringWhiteList =
+                        _instance.substringWhiteList || []).push(_reader.readString());
+                    break;
+                case 6:
+                    _instance.dryRun = _reader.readBool();
+                    break;
+                case 7:
+                    _instance.trainingPhraseCleanerOptions = new TrainingPhraseCleanerOptions();
+                    _reader.readMessage(_instance.trainingPhraseCleanerOptions, TrainingPhraseCleanerOptions.deserializeBinaryFromReader);
+                    break;
+                case 8:
+                    _instance.reannotateEntitiesOptions = _reader.readEnum();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        CleanIntentRequest.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.intentName) {
+            _writer.writeString(2, _instance.intentName);
+        }
+        if (_instance.languageCode) {
+            _writer.writeString(3, _instance.languageCode);
+        }
+        if (_instance.specialCharacters) {
+            _writer.writeString(4, _instance.specialCharacters);
+        }
+        if (_instance.substringWhiteList && _instance.substringWhiteList.length) {
+            _writer.writeRepeatedString(5, _instance.substringWhiteList);
+        }
+        if (_instance.dryRun) {
+            _writer.writeBool(6, _instance.dryRun);
+        }
+        if (_instance.trainingPhraseCleanerOptions) {
+            _writer.writeMessage(7, _instance.trainingPhraseCleanerOptions, TrainingPhraseCleanerOptions.serializeBinaryToWriter);
+        }
+        if (_instance.reannotateEntitiesOptions) {
+            _writer.writeEnum(8, _instance.reannotateEntitiesOptions);
+        }
+    }
+    get parent() {
+        return this._parent;
+    }
+    set parent(value) {
+        this._parent = value;
+    }
+    get intentName() {
+        return this._intentName;
+    }
+    set intentName(value) {
+        this._intentName = value;
+    }
+    get languageCode() {
+        return this._languageCode;
+    }
+    set languageCode(value) {
+        this._languageCode = value;
+    }
+    get specialCharacters() {
+        return this._specialCharacters;
+    }
+    set specialCharacters(value) {
+        this._specialCharacters = value;
+    }
+    get substringWhiteList() {
+        return this._substringWhiteList;
+    }
+    set substringWhiteList(value) {
+        this._substringWhiteList = value;
+    }
+    get dryRun() {
+        return this._dryRun;
+    }
+    set dryRun(value) {
+        this._dryRun = value;
+    }
+    get trainingPhraseCleanerOptions() {
+        return this._trainingPhraseCleanerOptions;
+    }
+    set trainingPhraseCleanerOptions(value) {
+        this._trainingPhraseCleanerOptions = value;
+    }
+    get reannotateEntitiesOptions() {
+        return this._reannotateEntitiesOptions;
+    }
+    set reannotateEntitiesOptions(value) {
+        this._reannotateEntitiesOptions = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        CleanIntentRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            parent: this.parent,
+            intentName: this.intentName,
+            languageCode: this.languageCode,
+            specialCharacters: this.specialCharacters,
+            substringWhiteList: (this.substringWhiteList || []).slice(),
+            dryRun: this.dryRun,
+            trainingPhraseCleanerOptions: this.trainingPhraseCleanerOptions
+                ? this.trainingPhraseCleanerOptions.toObject()
+                : undefined,
+            reannotateEntitiesOptions: this.reannotateEntitiesOptions
+        };
+    }
+    /**
+     * 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,
+            intentName: this.intentName,
+            languageCode: this.languageCode,
+            specialCharacters: this.specialCharacters,
+            substringWhiteList: (this.substringWhiteList || []).slice(),
+            dryRun: this.dryRun,
+            trainingPhraseCleanerOptions: this.trainingPhraseCleanerOptions
+                ? this.trainingPhraseCleanerOptions.toProtobufJSON(options)
+                : null,
+            reannotateEntitiesOptions: ReannotateEntitiesOptions[this.reannotateEntitiesOptions === null ||
+                this.reannotateEntitiesOptions === undefined
+                ? 0
+                : this.reannotateEntitiesOptions]
+        };
+    }
+}
+CleanIntentRequest.id = 'ondewo.nlu.CleanIntentRequest';
+/**
+ * Message implementation for ondewo.nlu.CleanIntentResponse
+ */
+export class CleanIntentResponse {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of CleanIntentResponse to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.cleanedIntent = _value.cleanedIntent
+            ? new ondewoNlu008.Intent(_value.cleanedIntent)
+            : undefined;
+        this.intentUpdate = _value.intentUpdate
+            ? new IntentUpdate(_value.intentUpdate)
+            : undefined;
+        CleanIntentResponse.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new CleanIntentResponse();
+        CleanIntentResponse.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.cleanedIntent = _instance.cleanedIntent || undefined;
+        _instance.intentUpdate = _instance.intentUpdate || 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.cleanedIntent = new ondewoNlu008.Intent();
+                    _reader.readMessage(_instance.cleanedIntent, ondewoNlu008.Intent.deserializeBinaryFromReader);
+                    break;
+                case 2:
+                    _instance.intentUpdate = new IntentUpdate();
+                    _reader.readMessage(_instance.intentUpdate, IntentUpdate.deserializeBinaryFromReader);
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        CleanIntentResponse.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.cleanedIntent) {
+            _writer.writeMessage(1, _instance.cleanedIntent, ondewoNlu008.Intent.serializeBinaryToWriter);
+        }
+        if (_instance.intentUpdate) {
+            _writer.writeMessage(2, _instance.intentUpdate, IntentUpdate.serializeBinaryToWriter);
+        }
+    }
+    get cleanedIntent() {
+        return this._cleanedIntent;
+    }
+    set cleanedIntent(value) {
+        this._cleanedIntent = value;
+    }
+    get intentUpdate() {
+        return this._intentUpdate;
+    }
+    set intentUpdate(value) {
+        this._intentUpdate = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        CleanIntentResponse.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            cleanedIntent: this.cleanedIntent
+                ? this.cleanedIntent.toObject()
+                : undefined,
+            intentUpdate: this.intentUpdate ? this.intentUpdate.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 {
+            cleanedIntent: this.cleanedIntent
+                ? this.cleanedIntent.toProtobufJSON(options)
+                : null,
+            intentUpdate: this.intentUpdate
+                ? this.intentUpdate.toProtobufJSON(options)
+                : null
+        };
+    }
+}
+CleanIntentResponse.id = 'ondewo.nlu.CleanIntentResponse';
+/**
+ * Message implementation for ondewo.nlu.TrainingPhraseCleanerOptions
+ */
+export class TrainingPhraseCleanerOptions {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of TrainingPhraseCleanerOptions to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.deleteRepeatedWhitespaces = _value.deleteRepeatedWhitespaces;
+        this.deleteLeadingSpecialCharacters = _value.deleteLeadingSpecialCharacters;
+        this.deleteTrailingSpecialCharacters =
+            _value.deleteTrailingSpecialCharacters;
+        TrainingPhraseCleanerOptions.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new TrainingPhraseCleanerOptions();
+        TrainingPhraseCleanerOptions.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.deleteRepeatedWhitespaces =
+            _instance.deleteRepeatedWhitespaces || false;
+        _instance.deleteLeadingSpecialCharacters =
+            _instance.deleteLeadingSpecialCharacters || false;
+        _instance.deleteTrailingSpecialCharacters =
+            _instance.deleteTrailingSpecialCharacters || false;
+    }
+    /**
+     * 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.deleteRepeatedWhitespaces = _reader.readBool();
+                    break;
+                case 2:
+                    _instance.deleteLeadingSpecialCharacters = _reader.readBool();
+                    break;
+                case 3:
+                    _instance.deleteTrailingSpecialCharacters = _reader.readBool();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        TrainingPhraseCleanerOptions.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.deleteRepeatedWhitespaces) {
+            _writer.writeBool(1, _instance.deleteRepeatedWhitespaces);
+        }
+        if (_instance.deleteLeadingSpecialCharacters) {
+            _writer.writeBool(2, _instance.deleteLeadingSpecialCharacters);
+        }
+        if (_instance.deleteTrailingSpecialCharacters) {
+            _writer.writeBool(3, _instance.deleteTrailingSpecialCharacters);
+        }
+    }
+    get deleteRepeatedWhitespaces() {
+        return this._deleteRepeatedWhitespaces;
+    }
+    set deleteRepeatedWhitespaces(value) {
+        this._deleteRepeatedWhitespaces = value;
+    }
+    get deleteLeadingSpecialCharacters() {
+        return this._deleteLeadingSpecialCharacters;
+    }
+    set deleteLeadingSpecialCharacters(value) {
+        this._deleteLeadingSpecialCharacters = value;
+    }
+    get deleteTrailingSpecialCharacters() {
+        return this._deleteTrailingSpecialCharacters;
+    }
+    set deleteTrailingSpecialCharacters(value) {
+        this._deleteTrailingSpecialCharacters = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        TrainingPhraseCleanerOptions.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            deleteRepeatedWhitespaces: this.deleteRepeatedWhitespaces,
+            deleteLeadingSpecialCharacters: this.deleteLeadingSpecialCharacters,
+            deleteTrailingSpecialCharacters: this.deleteTrailingSpecialCharacters
+        };
+    }
+    /**
+     * 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 {
+            deleteRepeatedWhitespaces: this.deleteRepeatedWhitespaces,
+            deleteLeadingSpecialCharacters: this.deleteLeadingSpecialCharacters,
+            deleteTrailingSpecialCharacters: this.deleteTrailingSpecialCharacters
+        };
+    }
+}
+TrainingPhraseCleanerOptions.id = 'ondewo.nlu.TrainingPhraseCleanerOptions';
+/**
+ * Message implementation for ondewo.nlu.StringUpdate
+ */
+export class StringUpdate {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of StringUpdate to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.new = _value.new;
+        this.old = _value.old;
+        StringUpdate.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new StringUpdate();
+        StringUpdate.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.new = _instance.new || '';
+        _instance.old = _instance.old || '';
+    }
+    /**
+     * 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.new = _reader.readString();
+                    break;
+                case 2:
+                    _instance.old = _reader.readString();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        StringUpdate.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.new) {
+            _writer.writeString(1, _instance.new);
+        }
+        if (_instance.old) {
+            _writer.writeString(2, _instance.old);
+        }
+    }
+    get new() {
+        return this._new;
+    }
+    set new(value) {
+        this._new = value;
+    }
+    get old() {
+        return this._old;
+    }
+    set old(value) {
+        this._old = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        StringUpdate.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            new: this.new,
+            old: this.old
+        };
+    }
+    /**
+     * 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 {
+            new: this.new,
+            old: this.old
+        };
+    }
+}
+StringUpdate.id = 'ondewo.nlu.StringUpdate';
+/**
+ * Message implementation for ondewo.nlu.IntentUpdate
+ */
+export class IntentUpdate {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of IntentUpdate to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.intentDisplayName = _value.intentDisplayName;
+        this.trainingPhraseUpdateList = (_value.trainingPhraseUpdateList || []).map(m => new IntentUpdate.TrainingPhraseUpdate(m));
+        this.deletedParameters = (_value.deletedParameters || []).slice();
+        IntentUpdate.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new IntentUpdate();
+        IntentUpdate.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.intentDisplayName = _instance.intentDisplayName || '';
+        _instance.trainingPhraseUpdateList =
+            _instance.trainingPhraseUpdateList || [];
+        _instance.deletedParameters = _instance.deletedParameters || [];
+    }
+    /**
+     * 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.intentDisplayName = _reader.readString();
+                    break;
+                case 2:
+                    const messageInitializer2 = new IntentUpdate.TrainingPhraseUpdate();
+                    _reader.readMessage(messageInitializer2, IntentUpdate.TrainingPhraseUpdate.deserializeBinaryFromReader);
+                    (_instance.trainingPhraseUpdateList =
+                        _instance.trainingPhraseUpdateList || []).push(messageInitializer2);
+                    break;
+                case 3:
+                    (_instance.deletedParameters =
+                        _instance.deletedParameters || []).push(_reader.readString());
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        IntentUpdate.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.intentDisplayName) {
+            _writer.writeString(1, _instance.intentDisplayName);
+        }
+        if (_instance.trainingPhraseUpdateList &&
+            _instance.trainingPhraseUpdateList.length) {
+            _writer.writeRepeatedMessage(2, _instance.trainingPhraseUpdateList, IntentUpdate.TrainingPhraseUpdate.serializeBinaryToWriter);
+        }
+        if (_instance.deletedParameters && _instance.deletedParameters.length) {
+            _writer.writeRepeatedString(3, _instance.deletedParameters);
+        }
+    }
+    get intentDisplayName() {
+        return this._intentDisplayName;
+    }
+    set intentDisplayName(value) {
+        this._intentDisplayName = value;
+    }
+    get trainingPhraseUpdateList() {
+        return this._trainingPhraseUpdateList;
+    }
+    set trainingPhraseUpdateList(value) {
+        this._trainingPhraseUpdateList = value;
+    }
+    get deletedParameters() {
+        return this._deletedParameters;
+    }
+    set deletedParameters(value) {
+        this._deletedParameters = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        IntentUpdate.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            intentDisplayName: this.intentDisplayName,
+            trainingPhraseUpdateList: (this.trainingPhraseUpdateList || []).map(m => m.toObject()),
+            deletedParameters: (this.deletedParameters || []).slice()
+        };
+    }
+    /**
+     * 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 {
+            intentDisplayName: this.intentDisplayName,
+            trainingPhraseUpdateList: (this.trainingPhraseUpdateList || []).map(m => m.toProtobufJSON(options)),
+            deletedParameters: (this.deletedParameters || []).slice()
+        };
+    }
+}
+IntentUpdate.id = 'ondewo.nlu.IntentUpdate';
+(function (IntentUpdate) {
+    /**
+     * Message implementation for ondewo.nlu.TrainingPhraseUpdate
+     */
+    class TrainingPhraseUpdate {
+        /**
+         * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+         * @param _value initial values object or instance of TrainingPhraseUpdate to deeply clone from
+         */
+        constructor(_value) {
+            _value = _value || {};
+            this.trainingPhraseUpdate = _value.trainingPhraseUpdate
+                ? new StringUpdate(_value.trainingPhraseUpdate)
+                : undefined;
+            this.entityUpdates = (_value.entityUpdates || []).map(m => new StringUpdate(m));
+            this.entitiesReannotated = (_value.entitiesReannotated || []).slice();
+            this.containsUpdateVariable = _value.containsUpdateVariable;
+            TrainingPhraseUpdate.refineValues(this);
+        }
+        /**
+         * Deserialize binary data to message
+         * @param instance message instance
+         */
+        static deserializeBinary(bytes) {
+            const instance = new TrainingPhraseUpdate();
+            TrainingPhraseUpdate.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.trainingPhraseUpdate =
+                _instance.trainingPhraseUpdate || undefined;
+            _instance.entityUpdates = _instance.entityUpdates || [];
+            _instance.entitiesReannotated = _instance.entitiesReannotated || [];
+            _instance.containsUpdateVariable =
+                _instance.containsUpdateVariable || false;
+        }
+        /**
+         * 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.trainingPhraseUpdate = new StringUpdate();
+                        _reader.readMessage(_instance.trainingPhraseUpdate, StringUpdate.deserializeBinaryFromReader);
+                        break;
+                    case 2:
+                        const messageInitializer2 = new StringUpdate();
+                        _reader.readMessage(messageInitializer2, StringUpdate.deserializeBinaryFromReader);
+                        (_instance.entityUpdates = _instance.entityUpdates || []).push(messageInitializer2);
+                        break;
+                    case 3:
+                        (_instance.entitiesReannotated =
+                            _instance.entitiesReannotated || []).push(_reader.readString());
+                        break;
+                    case 4:
+                        _instance.containsUpdateVariable = _reader.readBool();
+                        break;
+                    default:
+                        _reader.skipField();
+                }
+            }
+            TrainingPhraseUpdate.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.trainingPhraseUpdate) {
+                _writer.writeMessage(1, _instance.trainingPhraseUpdate, StringUpdate.serializeBinaryToWriter);
+            }
+            if (_instance.entityUpdates && _instance.entityUpdates.length) {
+                _writer.writeRepeatedMessage(2, _instance.entityUpdates, StringUpdate.serializeBinaryToWriter);
+            }
+            if (_instance.entitiesReannotated &&
+                _instance.entitiesReannotated.length) {
+                _writer.writeRepeatedString(3, _instance.entitiesReannotated);
+            }
+            if (_instance.containsUpdateVariable) {
+                _writer.writeBool(4, _instance.containsUpdateVariable);
+            }
+        }
+        get trainingPhraseUpdate() {
+            return this._trainingPhraseUpdate;
+        }
+        set trainingPhraseUpdate(value) {
+            this._trainingPhraseUpdate = value;
+        }
+        get entityUpdates() {
+            return this._entityUpdates;
+        }
+        set entityUpdates(value) {
+            this._entityUpdates = value;
+        }
+        get entitiesReannotated() {
+            return this._entitiesReannotated;
+        }
+        set entitiesReannotated(value) {
+            this._entitiesReannotated = value;
+        }
+        get containsUpdateVariable() {
+            return this._containsUpdateVariable;
+        }
+        set containsUpdateVariable(value) {
+            this._containsUpdateVariable = value;
+        }
+        /**
+         * Serialize message to binary data
+         * @param instance message instance
+         */
+        serializeBinary() {
+            const writer = new BinaryWriter();
+            TrainingPhraseUpdate.serializeBinaryToWriter(this, writer);
+            return writer.getResultBuffer();
+        }
+        /**
+         * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+         */
+        toObject() {
+            return {
+                trainingPhraseUpdate: this.trainingPhraseUpdate
+                    ? this.trainingPhraseUpdate.toObject()
+                    : undefined,
+                entityUpdates: (this.entityUpdates || []).map(m => m.toObject()),
+                entitiesReannotated: (this.entitiesReannotated || []).slice(),
+                containsUpdateVariable: this.containsUpdateVariable
+            };
+        }
+        /**
+         * 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 {
+                trainingPhraseUpdate: this.trainingPhraseUpdate
+                    ? this.trainingPhraseUpdate.toProtobufJSON(options)
+                    : null,
+                entityUpdates: (this.entityUpdates || []).map(m => m.toProtobufJSON(options)),
+                entitiesReannotated: (this.entitiesReannotated || []).slice(),
+                containsUpdateVariable: this.containsUpdateVariable
+            };
+        }
+    }
+    TrainingPhraseUpdate.id = 'ondewo.nlu.TrainingPhraseUpdate';
+    IntentUpdate.TrainingPhraseUpdate = TrainingPhraseUpdate;
+})(IntentUpdate || (IntentUpdate = {}));
+/**
+ * Message implementation for ondewo.nlu.EntityTypeUpdate
+ */
+export class EntityTypeUpdate {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of EntityTypeUpdate to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.entityTypeName = _value.entityTypeName;
+        this.valuesUpdateList = (_value.valuesUpdateList || []).map(m => new EntityTypeUpdate.EntityUpdate(m));
+        EntityTypeUpdate.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new EntityTypeUpdate();
+        EntityTypeUpdate.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.entityTypeName = _instance.entityTypeName || '';
+        _instance.valuesUpdateList = _instance.valuesUpdateList || [];
+    }
+    /**
+     * 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.entityTypeName = _reader.readString();
+                    break;
+                case 2:
+                    const messageInitializer2 = new EntityTypeUpdate.EntityUpdate();
+                    _reader.readMessage(messageInitializer2, EntityTypeUpdate.EntityUpdate.deserializeBinaryFromReader);
+                    (_instance.valuesUpdateList = _instance.valuesUpdateList || []).push(messageInitializer2);
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        EntityTypeUpdate.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.entityTypeName) {
+            _writer.writeString(1, _instance.entityTypeName);
+        }
+        if (_instance.valuesUpdateList && _instance.valuesUpdateList.length) {
+            _writer.writeRepeatedMessage(2, _instance.valuesUpdateList, EntityTypeUpdate.EntityUpdate.serializeBinaryToWriter);
+        }
+    }
+    get entityTypeName() {
+        return this._entityTypeName;
+    }
+    set entityTypeName(value) {
+        this._entityTypeName = value;
+    }
+    get valuesUpdateList() {
+        return this._valuesUpdateList;
+    }
+    set valuesUpdateList(value) {
+        this._valuesUpdateList = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        EntityTypeUpdate.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            entityTypeName: this.entityTypeName,
+            valuesUpdateList: (this.valuesUpdateList || []).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 {
+            entityTypeName: this.entityTypeName,
+            valuesUpdateList: (this.valuesUpdateList || []).map(m => m.toProtobufJSON(options))
+        };
+    }
+}
+EntityTypeUpdate.id = 'ondewo.nlu.EntityTypeUpdate';
+(function (EntityTypeUpdate) {
+    /**
+     * Message implementation for ondewo.nlu.EntityUpdate
+     */
+    class EntityUpdate {
+        /**
+         * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+         * @param _value initial values object or instance of EntityUpdate to deeply clone from
+         */
+        constructor(_value) {
+            _value = _value || {};
+            this.entityValueUpdate = _value.entityValueUpdate
+                ? new StringUpdate(_value.entityValueUpdate)
+                : undefined;
+            this.entitySynonymUpdates = (_value.entitySynonymUpdates || []).map(m => new StringUpdate(m));
+            EntityUpdate.refineValues(this);
+        }
+        /**
+         * Deserialize binary data to message
+         * @param instance message instance
+         */
+        static deserializeBinary(bytes) {
+            const instance = new EntityUpdate();
+            EntityUpdate.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.entityValueUpdate = _instance.entityValueUpdate || undefined;
+            _instance.entitySynonymUpdates = _instance.entitySynonymUpdates || [];
+        }
+        /**
+         * 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.entityValueUpdate = new StringUpdate();
+                        _reader.readMessage(_instance.entityValueUpdate, StringUpdate.deserializeBinaryFromReader);
+                        break;
+                    case 2:
+                        const messageInitializer2 = new StringUpdate();
+                        _reader.readMessage(messageInitializer2, StringUpdate.deserializeBinaryFromReader);
+                        (_instance.entitySynonymUpdates =
+                            _instance.entitySynonymUpdates || []).push(messageInitializer2);
+                        break;
+                    default:
+                        _reader.skipField();
+                }
+            }
+            EntityUpdate.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.entityValueUpdate) {
+                _writer.writeMessage(1, _instance.entityValueUpdate, StringUpdate.serializeBinaryToWriter);
+            }
+            if (_instance.entitySynonymUpdates &&
+                _instance.entitySynonymUpdates.length) {
+                _writer.writeRepeatedMessage(2, _instance.entitySynonymUpdates, StringUpdate.serializeBinaryToWriter);
+            }
+        }
+        get entityValueUpdate() {
+            return this._entityValueUpdate;
+        }
+        set entityValueUpdate(value) {
+            this._entityValueUpdate = value;
+        }
+        get entitySynonymUpdates() {
+            return this._entitySynonymUpdates;
+        }
+        set entitySynonymUpdates(value) {
+            this._entitySynonymUpdates = value;
+        }
+        /**
+         * Serialize message to binary data
+         * @param instance message instance
+         */
+        serializeBinary() {
+            const writer = new BinaryWriter();
+            EntityUpdate.serializeBinaryToWriter(this, writer);
+            return writer.getResultBuffer();
+        }
+        /**
+         * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+         */
+        toObject() {
+            return {
+                entityValueUpdate: this.entityValueUpdate
+                    ? this.entityValueUpdate.toObject()
+                    : undefined,
+                entitySynonymUpdates: (this.entitySynonymUpdates || []).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 {
+                entityValueUpdate: this.entityValueUpdate
+                    ? this.entityValueUpdate.toProtobufJSON(options)
+                    : null,
+                entitySynonymUpdates: (this.entitySynonymUpdates || []).map(m => m.toProtobufJSON(options))
+            };
+        }
+    }
+    EntityUpdate.id = 'ondewo.nlu.EntityUpdate';
+    EntityTypeUpdate.EntityUpdate = EntityUpdate;
+})(EntityTypeUpdate || (EntityTypeUpdate = {}));
+/**
+ * Message implementation for ondewo.nlu.CleanAllEntityTypesRequest
+ */
+export class CleanAllEntityTypesRequest {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of CleanAllEntityTypesRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.parent = _value.parent;
+        this.languageCode = _value.languageCode;
+        this.specialCharacters = _value.specialCharacters;
+        this.substringWhiteList = (_value.substringWhiteList || []).slice();
+        this.maxEntityCountUpdate = _value.maxEntityCountUpdate;
+        this.forbiddenEntityTypePatterns = (_value.forbiddenEntityTypePatterns || []).slice();
+        this.dryRun = _value.dryRun;
+        this.numberOfWorkers = _value.numberOfWorkers;
+        CleanAllEntityTypesRequest.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new CleanAllEntityTypesRequest();
+        CleanAllEntityTypesRequest.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.languageCode = _instance.languageCode || '';
+        _instance.specialCharacters = _instance.specialCharacters || '';
+        _instance.substringWhiteList = _instance.substringWhiteList || [];
+        _instance.maxEntityCountUpdate = _instance.maxEntityCountUpdate || 0;
+        _instance.forbiddenEntityTypePatterns =
+            _instance.forbiddenEntityTypePatterns || [];
+        _instance.dryRun = _instance.dryRun || false;
+        _instance.numberOfWorkers = _instance.numberOfWorkers || 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.languageCode = _reader.readString();
+                    break;
+                case 3:
+                    _instance.specialCharacters = _reader.readString();
+                    break;
+                case 4:
+                    (_instance.substringWhiteList =
+                        _instance.substringWhiteList || []).push(_reader.readString());
+                    break;
+                case 5:
+                    _instance.maxEntityCountUpdate = _reader.readInt32();
+                    break;
+                case 6:
+                    (_instance.forbiddenEntityTypePatterns =
+                        _instance.forbiddenEntityTypePatterns || []).push(_reader.readString());
+                    break;
+                case 7:
+                    _instance.dryRun = _reader.readBool();
+                    break;
+                case 8:
+                    _instance.numberOfWorkers = _reader.readInt32();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        CleanAllEntityTypesRequest.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.languageCode) {
+            _writer.writeString(2, _instance.languageCode);
+        }
+        if (_instance.specialCharacters) {
+            _writer.writeString(3, _instance.specialCharacters);
+        }
+        if (_instance.substringWhiteList && _instance.substringWhiteList.length) {
+            _writer.writeRepeatedString(4, _instance.substringWhiteList);
+        }
+        if (_instance.maxEntityCountUpdate) {
+            _writer.writeInt32(5, _instance.maxEntityCountUpdate);
+        }
+        if (_instance.forbiddenEntityTypePatterns &&
+            _instance.forbiddenEntityTypePatterns.length) {
+            _writer.writeRepeatedString(6, _instance.forbiddenEntityTypePatterns);
+        }
+        if (_instance.dryRun) {
+            _writer.writeBool(7, _instance.dryRun);
+        }
+        if (_instance.numberOfWorkers) {
+            _writer.writeInt32(8, _instance.numberOfWorkers);
+        }
+    }
+    get parent() {
+        return this._parent;
+    }
+    set parent(value) {
+        this._parent = value;
+    }
+    get languageCode() {
+        return this._languageCode;
+    }
+    set languageCode(value) {
+        this._languageCode = value;
+    }
+    get specialCharacters() {
+        return this._specialCharacters;
+    }
+    set specialCharacters(value) {
+        this._specialCharacters = value;
+    }
+    get substringWhiteList() {
+        return this._substringWhiteList;
+    }
+    set substringWhiteList(value) {
+        this._substringWhiteList = value;
+    }
+    get maxEntityCountUpdate() {
+        return this._maxEntityCountUpdate;
+    }
+    set maxEntityCountUpdate(value) {
+        this._maxEntityCountUpdate = value;
+    }
+    get forbiddenEntityTypePatterns() {
+        return this._forbiddenEntityTypePatterns;
+    }
+    set forbiddenEntityTypePatterns(value) {
+        this._forbiddenEntityTypePatterns = value;
+    }
+    get dryRun() {
+        return this._dryRun;
+    }
+    set dryRun(value) {
+        this._dryRun = value;
+    }
+    get numberOfWorkers() {
+        return this._numberOfWorkers;
+    }
+    set numberOfWorkers(value) {
+        this._numberOfWorkers = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        CleanAllEntityTypesRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            parent: this.parent,
+            languageCode: this.languageCode,
+            specialCharacters: this.specialCharacters,
+            substringWhiteList: (this.substringWhiteList || []).slice(),
+            maxEntityCountUpdate: this.maxEntityCountUpdate,
+            forbiddenEntityTypePatterns: (this.forbiddenEntityTypePatterns || []).slice(),
+            dryRun: this.dryRun,
+            numberOfWorkers: this.numberOfWorkers
+        };
+    }
+    /**
+     * 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,
+            languageCode: this.languageCode,
+            specialCharacters: this.specialCharacters,
+            substringWhiteList: (this.substringWhiteList || []).slice(),
+            maxEntityCountUpdate: this.maxEntityCountUpdate,
+            forbiddenEntityTypePatterns: (this.forbiddenEntityTypePatterns || []).slice(),
+            dryRun: this.dryRun,
+            numberOfWorkers: this.numberOfWorkers
+        };
+    }
+}
+CleanAllEntityTypesRequest.id = 'ondewo.nlu.CleanAllEntityTypesRequest';
+/**
+ * Message implementation for ondewo.nlu.CleanAllEntityTypesResponse
+ */
+export class CleanAllEntityTypesResponse {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of CleanAllEntityTypesResponse to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.cleanedEntityTypes = (_value.cleanedEntityTypes || []).map(m => new ondewoNlu009.EntityType(m));
+        this.deletedEntityTypes = (_value.deletedEntityTypes || []).map(m => new ondewoNlu009.EntityType(m));
+        this.entityTypeUpdates = (_value.entityTypeUpdates || []).map(m => new EntityTypeUpdate(m));
+        this.entityTypeDeletions = (_value.entityTypeDeletions || []).map(m => new EntityTypeUpdate(m));
+        CleanAllEntityTypesResponse.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new CleanAllEntityTypesResponse();
+        CleanAllEntityTypesResponse.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.cleanedEntityTypes = _instance.cleanedEntityTypes || [];
+        _instance.deletedEntityTypes = _instance.deletedEntityTypes || [];
+        _instance.entityTypeUpdates = _instance.entityTypeUpdates || [];
+        _instance.entityTypeDeletions = _instance.entityTypeDeletions || [];
+    }
+    /**
+     * 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 ondewoNlu009.EntityType();
+                    _reader.readMessage(messageInitializer1, ondewoNlu009.EntityType.deserializeBinaryFromReader);
+                    (_instance.cleanedEntityTypes =
+                        _instance.cleanedEntityTypes || []).push(messageInitializer1);
+                    break;
+                case 2:
+                    const messageInitializer2 = new ondewoNlu009.EntityType();
+                    _reader.readMessage(messageInitializer2, ondewoNlu009.EntityType.deserializeBinaryFromReader);
+                    (_instance.deletedEntityTypes =
+                        _instance.deletedEntityTypes || []).push(messageInitializer2);
+                    break;
+                case 3:
+                    const messageInitializer3 = new EntityTypeUpdate();
+                    _reader.readMessage(messageInitializer3, EntityTypeUpdate.deserializeBinaryFromReader);
+                    (_instance.entityTypeUpdates =
+                        _instance.entityTypeUpdates || []).push(messageInitializer3);
+                    break;
+                case 4:
+                    const messageInitializer4 = new EntityTypeUpdate();
+                    _reader.readMessage(messageInitializer4, EntityTypeUpdate.deserializeBinaryFromReader);
+                    (_instance.entityTypeDeletions =
+                        _instance.entityTypeDeletions || []).push(messageInitializer4);
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        CleanAllEntityTypesResponse.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.cleanedEntityTypes && _instance.cleanedEntityTypes.length) {
+            _writer.writeRepeatedMessage(1, _instance.cleanedEntityTypes, ondewoNlu009.EntityType.serializeBinaryToWriter);
+        }
+        if (_instance.deletedEntityTypes && _instance.deletedEntityTypes.length) {
+            _writer.writeRepeatedMessage(2, _instance.deletedEntityTypes, ondewoNlu009.EntityType.serializeBinaryToWriter);
+        }
+        if (_instance.entityTypeUpdates && _instance.entityTypeUpdates.length) {
+            _writer.writeRepeatedMessage(3, _instance.entityTypeUpdates, EntityTypeUpdate.serializeBinaryToWriter);
+        }
+        if (_instance.entityTypeDeletions && _instance.entityTypeDeletions.length) {
+            _writer.writeRepeatedMessage(4, _instance.entityTypeDeletions, EntityTypeUpdate.serializeBinaryToWriter);
+        }
+    }
+    get cleanedEntityTypes() {
+        return this._cleanedEntityTypes;
+    }
+    set cleanedEntityTypes(value) {
+        this._cleanedEntityTypes = value;
+    }
+    get deletedEntityTypes() {
+        return this._deletedEntityTypes;
+    }
+    set deletedEntityTypes(value) {
+        this._deletedEntityTypes = value;
+    }
+    get entityTypeUpdates() {
+        return this._entityTypeUpdates;
+    }
+    set entityTypeUpdates(value) {
+        this._entityTypeUpdates = value;
+    }
+    get entityTypeDeletions() {
+        return this._entityTypeDeletions;
+    }
+    set entityTypeDeletions(value) {
+        this._entityTypeDeletions = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        CleanAllEntityTypesResponse.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            cleanedEntityTypes: (this.cleanedEntityTypes || []).map(m => m.toObject()),
+            deletedEntityTypes: (this.deletedEntityTypes || []).map(m => m.toObject()),
+            entityTypeUpdates: (this.entityTypeUpdates || []).map(m => m.toObject()),
+            entityTypeDeletions: (this.entityTypeDeletions || []).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 {
+            cleanedEntityTypes: (this.cleanedEntityTypes || []).map(m => m.toProtobufJSON(options)),
+            deletedEntityTypes: (this.deletedEntityTypes || []).map(m => m.toProtobufJSON(options)),
+            entityTypeUpdates: (this.entityTypeUpdates || []).map(m => m.toProtobufJSON(options)),
+            entityTypeDeletions: (this.entityTypeDeletions || []).map(m => m.toProtobufJSON(options))
+        };
+    }
+}
+CleanAllEntityTypesResponse.id = 'ondewo.nlu.CleanAllEntityTypesResponse';
+/**
+ * Message implementation for ondewo.nlu.CleanEntityTypeRequest
+ */
+export class CleanEntityTypeRequest {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of CleanEntityTypeRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.parent = _value.parent;
+        this.entityTypeName = _value.entityTypeName;
+        this.languageCode = _value.languageCode;
+        this.specialCharacters = _value.specialCharacters;
+        this.substringWhiteList = (_value.substringWhiteList || []).slice();
+        this.maxEntityCountUpdate = _value.maxEntityCountUpdate;
+        this.dryRun = _value.dryRun;
+        CleanEntityTypeRequest.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new CleanEntityTypeRequest();
+        CleanEntityTypeRequest.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.entityTypeName = _instance.entityTypeName || '';
+        _instance.languageCode = _instance.languageCode || '';
+        _instance.specialCharacters = _instance.specialCharacters || '';
+        _instance.substringWhiteList = _instance.substringWhiteList || [];
+        _instance.maxEntityCountUpdate = _instance.maxEntityCountUpdate || 0;
+        _instance.dryRun = _instance.dryRun || false;
+    }
+    /**
+     * 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.entityTypeName = _reader.readString();
+                    break;
+                case 3:
+                    _instance.languageCode = _reader.readString();
+                    break;
+                case 4:
+                    _instance.specialCharacters = _reader.readString();
+                    break;
+                case 5:
+                    (_instance.substringWhiteList =
+                        _instance.substringWhiteList || []).push(_reader.readString());
+                    break;
+                case 6:
+                    _instance.maxEntityCountUpdate = _reader.readInt32();
+                    break;
+                case 7:
+                    _instance.dryRun = _reader.readBool();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        CleanEntityTypeRequest.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.entityTypeName) {
+            _writer.writeString(2, _instance.entityTypeName);
+        }
+        if (_instance.languageCode) {
+            _writer.writeString(3, _instance.languageCode);
+        }
+        if (_instance.specialCharacters) {
+            _writer.writeString(4, _instance.specialCharacters);
+        }
+        if (_instance.substringWhiteList && _instance.substringWhiteList.length) {
+            _writer.writeRepeatedString(5, _instance.substringWhiteList);
+        }
+        if (_instance.maxEntityCountUpdate) {
+            _writer.writeInt32(6, _instance.maxEntityCountUpdate);
+        }
+        if (_instance.dryRun) {
+            _writer.writeBool(7, _instance.dryRun);
+        }
+    }
+    get parent() {
+        return this._parent;
+    }
+    set parent(value) {
+        this._parent = value;
+    }
+    get entityTypeName() {
+        return this._entityTypeName;
+    }
+    set entityTypeName(value) {
+        this._entityTypeName = value;
+    }
+    get languageCode() {
+        return this._languageCode;
+    }
+    set languageCode(value) {
+        this._languageCode = value;
+    }
+    get specialCharacters() {
+        return this._specialCharacters;
+    }
+    set specialCharacters(value) {
+        this._specialCharacters = value;
+    }
+    get substringWhiteList() {
+        return this._substringWhiteList;
+    }
+    set substringWhiteList(value) {
+        this._substringWhiteList = value;
+    }
+    get maxEntityCountUpdate() {
+        return this._maxEntityCountUpdate;
+    }
+    set maxEntityCountUpdate(value) {
+        this._maxEntityCountUpdate = value;
+    }
+    get dryRun() {
+        return this._dryRun;
+    }
+    set dryRun(value) {
+        this._dryRun = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        CleanEntityTypeRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            parent: this.parent,
+            entityTypeName: this.entityTypeName,
+            languageCode: this.languageCode,
+            specialCharacters: this.specialCharacters,
+            substringWhiteList: (this.substringWhiteList || []).slice(),
+            maxEntityCountUpdate: this.maxEntityCountUpdate,
+            dryRun: this.dryRun
+        };
+    }
+    /**
+     * 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,
+            entityTypeName: this.entityTypeName,
+            languageCode: this.languageCode,
+            specialCharacters: this.specialCharacters,
+            substringWhiteList: (this.substringWhiteList || []).slice(),
+            maxEntityCountUpdate: this.maxEntityCountUpdate,
+            dryRun: this.dryRun
+        };
+    }
+}
+CleanEntityTypeRequest.id = 'ondewo.nlu.CleanEntityTypeRequest';
+/**
+ * Message implementation for ondewo.nlu.CleanEntityTypeResponse
+ */
+export class CleanEntityTypeResponse {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of CleanEntityTypeResponse to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.cleanedEntityType = _value.cleanedEntityType
+            ? new ondewoNlu009.EntityType(_value.cleanedEntityType)
+            : undefined;
+        this.entityTypeUpdate = _value.entityTypeUpdate
+            ? new EntityTypeUpdate(_value.entityTypeUpdate)
+            : undefined;
+        CleanEntityTypeResponse.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new CleanEntityTypeResponse();
+        CleanEntityTypeResponse.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.cleanedEntityType = _instance.cleanedEntityType || undefined;
+        _instance.entityTypeUpdate = _instance.entityTypeUpdate || 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.cleanedEntityType = new ondewoNlu009.EntityType();
+                    _reader.readMessage(_instance.cleanedEntityType, ondewoNlu009.EntityType.deserializeBinaryFromReader);
+                    break;
+                case 2:
+                    _instance.entityTypeUpdate = new EntityTypeUpdate();
+                    _reader.readMessage(_instance.entityTypeUpdate, EntityTypeUpdate.deserializeBinaryFromReader);
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        CleanEntityTypeResponse.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.cleanedEntityType) {
+            _writer.writeMessage(1, _instance.cleanedEntityType, ondewoNlu009.EntityType.serializeBinaryToWriter);
+        }
+        if (_instance.entityTypeUpdate) {
+            _writer.writeMessage(2, _instance.entityTypeUpdate, EntityTypeUpdate.serializeBinaryToWriter);
+        }
+    }
+    get cleanedEntityType() {
+        return this._cleanedEntityType;
+    }
+    set cleanedEntityType(value) {
+        this._cleanedEntityType = value;
+    }
+    get entityTypeUpdate() {
+        return this._entityTypeUpdate;
+    }
+    set entityTypeUpdate(value) {
+        this._entityTypeUpdate = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        CleanEntityTypeResponse.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            cleanedEntityType: this.cleanedEntityType
+                ? this.cleanedEntityType.toObject()
+                : undefined,
+            entityTypeUpdate: this.entityTypeUpdate
+                ? this.entityTypeUpdate.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 {
+            cleanedEntityType: this.cleanedEntityType
+                ? this.cleanedEntityType.toProtobufJSON(options)
+                : null,
+            entityTypeUpdate: this.entityTypeUpdate
+                ? this.entityTypeUpdate.toProtobufJSON(options)
+                : null
+        };
+    }
+}
+CleanEntityTypeResponse.id = 'ondewo.nlu.CleanEntityTypeResponse';
+/**
+ * Message implementation for ondewo.nlu.AddTrainingPhrasesRequest
+ */
+export class AddTrainingPhrasesRequest {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of AddTrainingPhrasesRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.parent = _value.parent;
+        this.languageCode = _value.languageCode;
+        this.trainingPhraseList = (_value.trainingPhraseList || []).map(m => new AddTrainingPhrasesRequest.TrainingPhraseForIntent(m));
+        this.extractEntities = _value.extractEntities;
+        this.specialCharacters = _value.specialCharacters;
+        this.trainingPhraseCleanerOptions = _value.trainingPhraseCleanerOptions
+            ? new TrainingPhraseCleanerOptions(_value.trainingPhraseCleanerOptions)
+            : undefined;
+        this.numberOfWorkers = _value.numberOfWorkers;
+        AddTrainingPhrasesRequest.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new AddTrainingPhrasesRequest();
+        AddTrainingPhrasesRequest.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.languageCode = _instance.languageCode || '';
+        _instance.trainingPhraseList = _instance.trainingPhraseList || [];
+        _instance.extractEntities = _instance.extractEntities || false;
+        _instance.specialCharacters = _instance.specialCharacters || '';
+        _instance.trainingPhraseCleanerOptions =
+            _instance.trainingPhraseCleanerOptions || undefined;
+        _instance.numberOfWorkers = _instance.numberOfWorkers || 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.languageCode = _reader.readString();
+                    break;
+                case 3:
+                    const messageInitializer3 = new AddTrainingPhrasesRequest.TrainingPhraseForIntent();
+                    _reader.readMessage(messageInitializer3, AddTrainingPhrasesRequest.TrainingPhraseForIntent
+                        .deserializeBinaryFromReader);
+                    (_instance.trainingPhraseList =
+                        _instance.trainingPhraseList || []).push(messageInitializer3);
+                    break;
+                case 4:
+                    _instance.extractEntities = _reader.readBool();
+                    break;
+                case 5:
+                    _instance.specialCharacters = _reader.readString();
+                    break;
+                case 6:
+                    _instance.trainingPhraseCleanerOptions = new TrainingPhraseCleanerOptions();
+                    _reader.readMessage(_instance.trainingPhraseCleanerOptions, TrainingPhraseCleanerOptions.deserializeBinaryFromReader);
+                    break;
+                case 7:
+                    _instance.numberOfWorkers = _reader.readInt32();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        AddTrainingPhrasesRequest.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.languageCode) {
+            _writer.writeString(2, _instance.languageCode);
+        }
+        if (_instance.trainingPhraseList && _instance.trainingPhraseList.length) {
+            _writer.writeRepeatedMessage(3, _instance.trainingPhraseList, AddTrainingPhrasesRequest.TrainingPhraseForIntent
+                .serializeBinaryToWriter);
+        }
+        if (_instance.extractEntities) {
+            _writer.writeBool(4, _instance.extractEntities);
+        }
+        if (_instance.specialCharacters) {
+            _writer.writeString(5, _instance.specialCharacters);
+        }
+        if (_instance.trainingPhraseCleanerOptions) {
+            _writer.writeMessage(6, _instance.trainingPhraseCleanerOptions, TrainingPhraseCleanerOptions.serializeBinaryToWriter);
+        }
+        if (_instance.numberOfWorkers) {
+            _writer.writeInt32(7, _instance.numberOfWorkers);
+        }
+    }
+    get parent() {
+        return this._parent;
+    }
+    set parent(value) {
+        this._parent = value;
+    }
+    get languageCode() {
+        return this._languageCode;
+    }
+    set languageCode(value) {
+        this._languageCode = value;
+    }
+    get trainingPhraseList() {
+        return this._trainingPhraseList;
+    }
+    set trainingPhraseList(value) {
+        this._trainingPhraseList = value;
+    }
+    get extractEntities() {
+        return this._extractEntities;
+    }
+    set extractEntities(value) {
+        this._extractEntities = value;
+    }
+    get specialCharacters() {
+        return this._specialCharacters;
+    }
+    set specialCharacters(value) {
+        this._specialCharacters = value;
+    }
+    get trainingPhraseCleanerOptions() {
+        return this._trainingPhraseCleanerOptions;
+    }
+    set trainingPhraseCleanerOptions(value) {
+        this._trainingPhraseCleanerOptions = value;
+    }
+    get numberOfWorkers() {
+        return this._numberOfWorkers;
+    }
+    set numberOfWorkers(value) {
+        this._numberOfWorkers = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        AddTrainingPhrasesRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            parent: this.parent,
+            languageCode: this.languageCode,
+            trainingPhraseList: (this.trainingPhraseList || []).map(m => m.toObject()),
+            extractEntities: this.extractEntities,
+            specialCharacters: this.specialCharacters,
+            trainingPhraseCleanerOptions: this.trainingPhraseCleanerOptions
+                ? this.trainingPhraseCleanerOptions.toObject()
+                : undefined,
+            numberOfWorkers: this.numberOfWorkers
+        };
+    }
+    /**
+     * 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,
+            languageCode: this.languageCode,
+            trainingPhraseList: (this.trainingPhraseList || []).map(m => m.toProtobufJSON(options)),
+            extractEntities: this.extractEntities,
+            specialCharacters: this.specialCharacters,
+            trainingPhraseCleanerOptions: this.trainingPhraseCleanerOptions
+                ? this.trainingPhraseCleanerOptions.toProtobufJSON(options)
+                : null,
+            numberOfWorkers: this.numberOfWorkers
+        };
+    }
+}
+AddTrainingPhrasesRequest.id = 'ondewo.nlu.AddTrainingPhrasesRequest';
+(function (AddTrainingPhrasesRequest) {
+    /**
+     * Message implementation for ondewo.nlu.TrainingPhraseForIntent
+     */
+    class TrainingPhraseForIntent {
+        /**
+         * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+         * @param _value initial values object or instance of TrainingPhraseForIntent to deeply clone from
+         */
+        constructor(_value) {
+            _value = _value || {};
+            this.trainingPhrase = _value.trainingPhrase;
+            this.intentDisplayName = _value.intentDisplayName;
+            this.entities = (_value.entities || []).map(m => new ondewoNlu008.Intent.TrainingPhrase.Entity(m));
+            TrainingPhraseForIntent.refineValues(this);
+        }
+        /**
+         * Deserialize binary data to message
+         * @param instance message instance
+         */
+        static deserializeBinary(bytes) {
+            const instance = new TrainingPhraseForIntent();
+            TrainingPhraseForIntent.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.trainingPhrase = _instance.trainingPhrase || '';
+            _instance.intentDisplayName = _instance.intentDisplayName || '';
+            _instance.entities = _instance.entities || [];
+        }
+        /**
+         * 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.trainingPhrase = _reader.readString();
+                        break;
+                    case 2:
+                        _instance.intentDisplayName = _reader.readString();
+                        break;
+                    case 3:
+                        const messageInitializer3 = new ondewoNlu008.Intent.TrainingPhrase.Entity();
+                        _reader.readMessage(messageInitializer3, ondewoNlu008.Intent.TrainingPhrase.Entity
+                            .deserializeBinaryFromReader);
+                        (_instance.entities = _instance.entities || []).push(messageInitializer3);
+                        break;
+                    default:
+                        _reader.skipField();
+                }
+            }
+            TrainingPhraseForIntent.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.trainingPhrase) {
+                _writer.writeString(1, _instance.trainingPhrase);
+            }
+            if (_instance.intentDisplayName) {
+                _writer.writeString(2, _instance.intentDisplayName);
+            }
+            if (_instance.entities && _instance.entities.length) {
+                _writer.writeRepeatedMessage(3, _instance.entities, ondewoNlu008.Intent.TrainingPhrase.Entity.serializeBinaryToWriter);
+            }
+        }
+        get trainingPhrase() {
+            return this._trainingPhrase;
+        }
+        set trainingPhrase(value) {
+            this._trainingPhrase = value;
+        }
+        get intentDisplayName() {
+            return this._intentDisplayName;
+        }
+        set intentDisplayName(value) {
+            this._intentDisplayName = value;
+        }
+        get entities() {
+            return this._entities;
+        }
+        set entities(value) {
+            this._entities = value;
+        }
+        /**
+         * Serialize message to binary data
+         * @param instance message instance
+         */
+        serializeBinary() {
+            const writer = new BinaryWriter();
+            TrainingPhraseForIntent.serializeBinaryToWriter(this, writer);
+            return writer.getResultBuffer();
+        }
+        /**
+         * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+         */
+        toObject() {
+            return {
+                trainingPhrase: this.trainingPhrase,
+                intentDisplayName: this.intentDisplayName,
+                entities: (this.entities || []).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 {
+                trainingPhrase: this.trainingPhrase,
+                intentDisplayName: this.intentDisplayName,
+                entities: (this.entities || []).map(m => m.toProtobufJSON(options))
+            };
+        }
+    }
+    TrainingPhraseForIntent.id = 'ondewo.nlu.TrainingPhraseForIntent';
+    AddTrainingPhrasesRequest.TrainingPhraseForIntent = TrainingPhraseForIntent;
+})(AddTrainingPhrasesRequest || (AddTrainingPhrasesRequest = {}));
+/**
+ * Message implementation for ondewo.nlu.AddTrainingPhrasesResponse
+ */
+export class AddTrainingPhrasesResponse {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of AddTrainingPhrasesResponse to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.errorMessages = (_value.errorMessages || []).slice();
+        AddTrainingPhrasesResponse.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new AddTrainingPhrasesResponse();
+        AddTrainingPhrasesResponse.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.errorMessages = _instance.errorMessages || [];
+    }
+    /**
+     * 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.errorMessages = _instance.errorMessages || []).push(_reader.readString());
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        AddTrainingPhrasesResponse.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.errorMessages && _instance.errorMessages.length) {
+            _writer.writeRepeatedString(1, _instance.errorMessages);
+        }
+    }
+    get errorMessages() {
+        return this._errorMessages;
+    }
+    set errorMessages(value) {
+        this._errorMessages = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        AddTrainingPhrasesResponse.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            errorMessages: (this.errorMessages || []).slice()
+        };
+    }
+    /**
+     * 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 {
+            errorMessages: (this.errorMessages || []).slice()
+        };
+    }
+}
+AddTrainingPhrasesResponse.id = 'ondewo.nlu.AddTrainingPhrasesResponse';
+/**
+ * Message implementation for ondewo.nlu.AddTrainingPhrasesFromCSVRequest
+ */
+export class AddTrainingPhrasesFromCSVRequest {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of AddTrainingPhrasesFromCSVRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.parent = _value.parent;
+        this.languageCode = _value.languageCode;
+        this.csvContents = _value.csvContents;
+        this.extractEntities = _value.extractEntities;
+        this.specialCharacters = _value.specialCharacters;
+        this.trainingPhraseCleanerOptions = _value.trainingPhraseCleanerOptions
+            ? new TrainingPhraseCleanerOptions(_value.trainingPhraseCleanerOptions)
+            : undefined;
+        this.numberOfWorkers = _value.numberOfWorkers;
+        AddTrainingPhrasesFromCSVRequest.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new AddTrainingPhrasesFromCSVRequest();
+        AddTrainingPhrasesFromCSVRequest.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.languageCode = _instance.languageCode || '';
+        _instance.csvContents = _instance.csvContents || new Uint8Array();
+        _instance.extractEntities = _instance.extractEntities || false;
+        _instance.specialCharacters = _instance.specialCharacters || '';
+        _instance.trainingPhraseCleanerOptions =
+            _instance.trainingPhraseCleanerOptions || undefined;
+        _instance.numberOfWorkers = _instance.numberOfWorkers || 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.languageCode = _reader.readString();
+                    break;
+                case 3:
+                    _instance.csvContents = _reader.readBytes();
+                    break;
+                case 4:
+                    _instance.extractEntities = _reader.readBool();
+                    break;
+                case 5:
+                    _instance.specialCharacters = _reader.readString();
+                    break;
+                case 6:
+                    _instance.trainingPhraseCleanerOptions = new TrainingPhraseCleanerOptions();
+                    _reader.readMessage(_instance.trainingPhraseCleanerOptions, TrainingPhraseCleanerOptions.deserializeBinaryFromReader);
+                    break;
+                case 7:
+                    _instance.numberOfWorkers = _reader.readInt32();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        AddTrainingPhrasesFromCSVRequest.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.languageCode) {
+            _writer.writeString(2, _instance.languageCode);
+        }
+        if (_instance.csvContents && _instance.csvContents.length) {
+            _writer.writeBytes(3, _instance.csvContents);
+        }
+        if (_instance.extractEntities) {
+            _writer.writeBool(4, _instance.extractEntities);
+        }
+        if (_instance.specialCharacters) {
+            _writer.writeString(5, _instance.specialCharacters);
+        }
+        if (_instance.trainingPhraseCleanerOptions) {
+            _writer.writeMessage(6, _instance.trainingPhraseCleanerOptions, TrainingPhraseCleanerOptions.serializeBinaryToWriter);
+        }
+        if (_instance.numberOfWorkers) {
+            _writer.writeInt32(7, _instance.numberOfWorkers);
+        }
+    }
+    get parent() {
+        return this._parent;
+    }
+    set parent(value) {
+        this._parent = value;
+    }
+    get languageCode() {
+        return this._languageCode;
+    }
+    set languageCode(value) {
+        this._languageCode = value;
+    }
+    get csvContents() {
+        return this._csvContents;
+    }
+    set csvContents(value) {
+        this._csvContents = value;
+    }
+    get extractEntities() {
+        return this._extractEntities;
+    }
+    set extractEntities(value) {
+        this._extractEntities = value;
+    }
+    get specialCharacters() {
+        return this._specialCharacters;
+    }
+    set specialCharacters(value) {
+        this._specialCharacters = value;
+    }
+    get trainingPhraseCleanerOptions() {
+        return this._trainingPhraseCleanerOptions;
+    }
+    set trainingPhraseCleanerOptions(value) {
+        this._trainingPhraseCleanerOptions = value;
+    }
+    get numberOfWorkers() {
+        return this._numberOfWorkers;
+    }
+    set numberOfWorkers(value) {
+        this._numberOfWorkers = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        AddTrainingPhrasesFromCSVRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            parent: this.parent,
+            languageCode: this.languageCode,
+            csvContents: this.csvContents
+                ? this.csvContents.subarray(0)
+                : new Uint8Array(),
+            extractEntities: this.extractEntities,
+            specialCharacters: this.specialCharacters,
+            trainingPhraseCleanerOptions: this.trainingPhraseCleanerOptions
+                ? this.trainingPhraseCleanerOptions.toObject()
+                : undefined,
+            numberOfWorkers: this.numberOfWorkers
+        };
+    }
+    /**
+     * 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,
+            languageCode: this.languageCode,
+            csvContents: this.csvContents ? uint8ArrayToBase64(this.csvContents) : '',
+            extractEntities: this.extractEntities,
+            specialCharacters: this.specialCharacters,
+            trainingPhraseCleanerOptions: this.trainingPhraseCleanerOptions
+                ? this.trainingPhraseCleanerOptions.toProtobufJSON(options)
+                : null,
+            numberOfWorkers: this.numberOfWorkers
+        };
+    }
+}
+AddTrainingPhrasesFromCSVRequest.id = 'ondewo.nlu.AddTrainingPhrasesFromCSVRequest';
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utility.pb.js","sourceRoot":"","sources":["../../../../../api/ondewo/nlu/utility.pb.ts"],"names":[],"mappings":"AAAA,oBAAoB;AACpB,oBAAoB;AACpB,cAAc;AACd,EAAE;AACF,2BAA2B;AAC3B,8CAA8C;AAC9C,OAAO,EAIL,kBAAkB,EACnB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,YAAY,EAAE,YAAY,EAAc,MAAM,iBAAiB,CAAC;AASzE,OAAO,KAAK,YAAY,MAAM,4BAA4B,CAAC;AAC3D,OAAO,KAAK,YAAY,MAAM,iCAAiC,CAAC;AAChE,MAAM,CAAN,IAAY,yBAMX;AAND,WAAY,yBAAyB;IACnC,iGAAoB,CAAA;IACpB,mGAAqB,CAAA;IACrB,uGAAuB,CAAA;IACvB,mHAA6B,CAAA;IAC7B,2IAAyC,CAAA;AAC3C,CAAC,EANW,yBAAyB,KAAzB,yBAAyB,QAMpC;AACD;;GAEG;AACH,MAAM,OAAO,oBAAoB;IAgE/B;;;OAGG;IACH,YAAY,MAAwD;QAClE,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;QACtB,IAAI,CAAC,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;QAC1B,oBAAoB,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IAC1C,CAAC;IArED;;;OAGG;IACH,MAAM,CAAC,iBAAiB,CAAC,KAAiB;QACxC,MAAM,QAAQ,GAAG,IAAI,oBAAoB,EAAE,CAAC;QAC5C,oBAAoB,CAAC,2BAA2B,CAC9C,QAAQ,EACR,IAAI,YAAY,CAAC,KAAK,CAAC,CACxB,CAAC;QACF,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,YAAY,CAAC,SAA+B;QACjD,SAAS,CAAC,KAAK,GAAG,SAAS,CAAC,KAAK,IAAI,EAAE,CAAC;IAC1C,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,2BAA2B,CAChC,SAA+B,EAC/B,OAAqB;QAErB,OAAO,OAAO,CAAC,SAAS,EAAE,EAAE;YAC1B,IAAI,OAAO,CAAC,UAAU,EAAE;gBAAE,MAAM;YAEhC,QAAQ,OAAO,CAAC,cAAc,EAAE,EAAE;gBAChC,KAAK,CAAC;oBACJ,SAAS,CAAC,KAAK,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;oBACvC,MAAM;gBACR;oBACE,OAAO,CAAC,SAAS,EAAE,CAAC;aACvB;SACF;QAED,oBAAoB,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;IAC/C,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,uBAAuB,CAC5B,SAA+B,EAC/B,OAAqB;QAErB,IAAI,SAAS,CAAC,KAAK,EAAE;YACnB,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,SAAS,CAAC,KAAK,CAAC,CAAC;SACzC;IACH,CAAC;IAaD,IAAI,KAAK;QACP,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IACD,IAAI,KAAK,CAAC,KAAyB;QACjC,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;IACtB,CAAC;IAED;;;OAGG;IACH,eAAe;QACb,MAAM,MAAM,GAAG,IAAI,YAAY,EAAE,CAAC;QAClC,oBAAoB,CAAC,uBAAuB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QAC3D,OAAO,MAAM,CAAC,eAAe,EAAE,CAAC;IAClC,CAAC;IAED;;OAEG;IACH,QAAQ;QACN,OAAO;YACL,KAAK,EAAE,IAAI,CAAC,KAAK;SAClB,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,MAAM;QACJ,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC;IACzB,CAAC;IAED;;;;OAIG;IACH,cAAc;IACZ,aAAa;IACb,OAA+B;QAE/B,OAAO;YACL,KAAK,EAAE,IAAI,CAAC,KAAK;SAClB,CAAC;IACJ,CAAC;;AArHM,uBAAE,GAAG,iCAAiC,CAAC;AAuIhD;;GAEG;AACH,MAAM,OAAO,qBAAqB;IAkEhC;;;OAGG;IACH,YAAY,MAAyD;QACnE,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;QACtB,IAAI,CAAC,aAAa,GAAG,CAAC,MAAM,CAAC,aAAa,IAAI,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC;QAC1D,qBAAqB,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IAC3C,CAAC;IAvED;;;OAGG;IACH,MAAM,CAAC,iBAAiB,CAAC,KAAiB;QACxC,MAAM,QAAQ,GAAG,IAAI,qBAAqB,EAAE,CAAC;QAC7C,qBAAqB,CAAC,2BAA2B,CAC/C,QAAQ,EACR,IAAI,YAAY,CAAC,KAAK,CAAC,CACxB,CAAC;QACF,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,YAAY,CAAC,SAAgC;QAClD,SAAS,CAAC,aAAa,GAAG,SAAS,CAAC,aAAa,IAAI,EAAE,CAAC;IAC1D,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,2BAA2B,CAChC,SAAgC,EAChC,OAAqB;QAErB,OAAO,OAAO,CAAC,SAAS,EAAE,EAAE;YAC1B,IAAI,OAAO,CAAC,UAAU,EAAE;gBAAE,MAAM;YAEhC,QAAQ,OAAO,CAAC,cAAc,EAAE,EAAE;gBAChC,KAAK,CAAC;oBACJ,CAAC,SAAS,CAAC,aAAa,GAAG,SAAS,CAAC,aAAa,IAAI,EAAE,CAAC,CAAC,IAAI,CAC5D,OAAO,CAAC,UAAU,EAAE,CACrB,CAAC;oBACF,MAAM;gBACR;oBACE,OAAO,CAAC,SAAS,EAAE,CAAC;aACvB;SACF;QAED,qBAAqB,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;IAChD,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,uBAAuB,CAC5B,SAAgC,EAChC,OAAqB;QAErB,IAAI,SAAS,CAAC,aAAa,IAAI,SAAS,CAAC,aAAa,CAAC,MAAM,EAAE;YAC7D,OAAO,CAAC,mBAAmB,CAAC,CAAC,EAAE,SAAS,CAAC,aAAa,CAAC,CAAC;SACzD;IACH,CAAC;IAaD,IAAI,aAAa;QACf,OAAO,IAAI,CAAC,cAAc,CAAC;IAC7B,CAAC;IACD,IAAI,aAAa,CAAC,KAA2B;QAC3C,IAAI,CAAC,cAAc,GAAG,KAAK,CAAC;IAC9B,CAAC;IAED;;;OAGG;IACH,eAAe;QACb,MAAM,MAAM,GAAG,IAAI,YAAY,EAAE,CAAC;QAClC,qBAAqB,CAAC,uBAAuB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QAC5D,OAAO,MAAM,CAAC,eAAe,EAAE,CAAC;IAClC,CAAC;IAED;;OAEG;IACH,QAAQ;QACN,OAAO;YACL,aAAa,EAAE,CAAC,IAAI,CAAC,aAAa,IAAI,EAAE,CAAC,CAAC,KAAK,EAAE;SAClD,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,MAAM;QACJ,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC;IACzB,CAAC;IAED;;;;OAIG;IACH,cAAc;IACZ,aAAa;IACb,OAA+B;QAE/B,OAAO;YACL,aAAa,EAAE,CAAC,IAAI,CAAC,aAAa,IAAI,EAAE,CAAC,CAAC,KAAK,EAAE;SAClD,CAAC;IACJ,CAAC;;AAvHM,wBAAE,GAAG,kCAAkC,CAAC;AAyIjD;;GAEG;AACH,MAAM,OAAO,4BAA4B;IAwEvC;;;OAGG;IACH,YACE,MAAgE;QAEhE,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;QACtB,IAAI,CAAC,UAAU,GAAG,MAAM,CAAC,UAAU;YACjC,CAAC,CAAC,IAAI,YAAY,CAAC,UAAU,CAAC,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC;YACvD,CAAC,CAAC,SAAS,CAAC;QACd,4BAA4B,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IAClD,CAAC;IAjFD;;;OAGG;IACH,MAAM,CAAC,iBAAiB,CAAC,KAAiB;QACxC,MAAM,QAAQ,GAAG,IAAI,4BAA4B,EAAE,CAAC;QACpD,4BAA4B,CAAC,2BAA2B,CACtD,QAAQ,EACR,IAAI,YAAY,CAAC,KAAK,CAAC,CACxB,CAAC;QACF,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,YAAY,CAAC,SAAuC;QACzD,SAAS,CAAC,UAAU,GAAG,SAAS,CAAC,UAAU,IAAI,SAAS,CAAC;IAC3D,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,2BAA2B,CAChC,SAAuC,EACvC,OAAqB;QAErB,OAAO,OAAO,CAAC,SAAS,EAAE,EAAE;YAC1B,IAAI,OAAO,CAAC,UAAU,EAAE;gBAAE,MAAM;YAEhC,QAAQ,OAAO,CAAC,cAAc,EAAE,EAAE;gBAChC,KAAK,CAAC;oBACJ,SAAS,CAAC,UAAU,GAAG,IAAI,YAAY,CAAC,UAAU,CAAC,MAAM,EAAE,CAAC;oBAC5D,OAAO,CAAC,WAAW,CACjB,SAAS,CAAC,UAAU,EACpB,YAAY,CAAC,UAAU,CAAC,MAAM,CAAC,2BAA2B,CAC3D,CAAC;oBACF,MAAM;gBACR;oBACE,OAAO,CAAC,SAAS,EAAE,CAAC;aACvB;SACF;QAED,4BAA4B,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;IACvD,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,uBAAuB,CAC5B,SAAuC,EACvC,OAAqB;QAErB,IAAI,SAAS,CAAC,UAAU,EAAE;YACxB,OAAO,CAAC,YAAY,CAClB,CAAC,EACD,SAAS,CAAC,UAAiB,EAC3B,YAAY,CAAC,UAAU,CAAC,MAAM,CAAC,uBAAuB,CACvD,CAAC;SACH;IACH,CAAC;IAiBD,IAAI,UAAU;QACZ,OAAO,IAAI,CAAC,WAAW,CAAC;IAC1B,CAAC;IACD,IAAI,UAAU,CAAC,KAAiD;QAC9D,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC;IAC3B,CAAC;IAED;;;OAGG;IACH,eAAe;QACb,MAAM,MAAM,GAAG,IAAI,YAAY,EAAE,CAAC;QAClC,4BAA4B,CAAC,uBAAuB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QACnE,OAAO,MAAM,CAAC,eAAe,EAAE,CAAC;IAClC,CAAC;IAED;;OAEG;IACH,QAAQ;QACN,OAAO;YACL,UAAU,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,SAAS;SACrE,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,MAAM;QACJ,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC;IACzB,CAAC;IAED;;;;OAIG;IACH,cAAc;IACZ,aAAa;IACb,OAA+B;QAE/B,OAAO;YACL,UAAU,EAAE,IAAI,CAAC,UAAU;gBACzB,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC,OAAO,CAAC;gBACzC,CAAC,CAAC,IAAI;SACT,CAAC;IACJ,CAAC;;AAnIM,+BAAE,GAAG,yCAAyC,CAAC;AAqJxD;;GAEG;AACH,MAAM,OAAO,6BAA6B;IAkExC;;;OAGG;IACH,YACE,MAAiE;QAEjE,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;QACtB,IAAI,CAAC,aAAa,GAAG,CAAC,MAAM,CAAC,aAAa,IAAI,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC;QAC1D,6BAA6B,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IACnD,CAAC;IAzED;;;OAGG;IACH,MAAM,CAAC,iBAAiB,CAAC,KAAiB;QACxC,MAAM,QAAQ,GAAG,IAAI,6BAA6B,EAAE,CAAC;QACrD,6BAA6B,CAAC,2BAA2B,CACvD,QAAQ,EACR,IAAI,YAAY,CAAC,KAAK,CAAC,CACxB,CAAC;QACF,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,YAAY,CAAC,SAAwC;QAC1D,SAAS,CAAC,aAAa,GAAG,SAAS,CAAC,aAAa,IAAI,EAAE,CAAC;IAC1D,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,2BAA2B,CAChC,SAAwC,EACxC,OAAqB;QAErB,OAAO,OAAO,CAAC,SAAS,EAAE,EAAE;YAC1B,IAAI,OAAO,CAAC,UAAU,EAAE;gBAAE,MAAM;YAEhC,QAAQ,OAAO,CAAC,cAAc,EAAE,EAAE;gBAChC,KAAK,CAAC;oBACJ,CAAC,SAAS,CAAC,aAAa,GAAG,SAAS,CAAC,aAAa,IAAI,EAAE,CAAC,CAAC,IAAI,CAC5D,OAAO,CAAC,UAAU,EAAE,CACrB,CAAC;oBACF,MAAM;gBACR;oBACE,OAAO,CAAC,SAAS,EAAE,CAAC;aACvB;SACF;QAED,6BAA6B,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;IACxD,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,uBAAuB,CAC5B,SAAwC,EACxC,OAAqB;QAErB,IAAI,SAAS,CAAC,aAAa,IAAI,SAAS,CAAC,aAAa,CAAC,MAAM,EAAE;YAC7D,OAAO,CAAC,mBAAmB,CAAC,CAAC,EAAE,SAAS,CAAC,aAAa,CAAC,CAAC;SACzD;IACH,CAAC;IAeD,IAAI,aAAa;QACf,OAAO,IAAI,CAAC,cAAc,CAAC;IAC7B,CAAC;IACD,IAAI,aAAa,CAAC,KAA2B;QAC3C,IAAI,CAAC,cAAc,GAAG,KAAK,CAAC;IAC9B,CAAC;IAED;;;OAGG;IACH,eAAe;QACb,MAAM,MAAM,GAAG,IAAI,YAAY,EAAE,CAAC;QAClC,6BAA6B,CAAC,uBAAuB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QACpE,OAAO,MAAM,CAAC,eAAe,EAAE,CAAC;IAClC,CAAC;IAED;;OAEG;IACH,QAAQ;QACN,OAAO;YACL,aAAa,EAAE,CAAC,IAAI,CAAC,aAAa,IAAI,EAAE,CAAC,CAAC,KAAK,EAAE;SAClD,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,MAAM;QACJ,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC;IACzB,CAAC;IAED;;;;OAIG;IACH,cAAc;IACZ,aAAa;IACb,OAA+B;QAE/B,OAAO;YACL,aAAa,EAAE,CAAC,IAAI,CAAC,aAAa,IAAI,EAAE,CAAC,CAAC,KAAK,EAAE;SAClD,CAAC;IACJ,CAAC;;AAzHM,gCAAE,GAAG,0CAA0C,CAAC;AA2IzD;;GAEG;AACH,MAAM,OAAO,sBAAsB;IAmIjC;;;OAGG;IACH,YAAY,MAA0D;QACpE,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;QACtB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;QAC5B,IAAI,CAAC,YAAY,GAAG,MAAM,CAAC,YAAY,CAAC;QACxC,IAAI,CAAC,iBAAiB,GAAG,MAAM,CAAC,iBAAiB,CAAC;QAClD,IAAI,CAAC,kBAAkB,GAAG,CAAC,MAAM,CAAC,kBAAkB,IAAI,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC;QACpE,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;QAC5B,IAAI,CAAC,4BAA4B,GAAG,MAAM,CAAC,4BAA4B;YACrE,CAAC,CAAC,IAAI,4BAA4B,CAAC,MAAM,CAAC,4BAA4B,CAAC;YACvE,CAAC,CAAC,SAAS,CAAC;QACd,IAAI,CAAC,yBAAyB,GAAG,MAAM,CAAC,yBAAyB,CAAC;QAClE,IAAI,CAAC,eAAe,GAAG,MAAM,CAAC,eAAe,CAAC;QAC9C,sBAAsB,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IAC5C,CAAC;IAjJD;;;OAGG;IACH,MAAM,CAAC,iBAAiB,CAAC,KAAiB;QACxC,MAAM,QAAQ,GAAG,IAAI,sBAAsB,EAAE,CAAC;QAC9C,sBAAsB,CAAC,2BAA2B,CAChD,QAAQ,EACR,IAAI,YAAY,CAAC,KAAK,CAAC,CACxB,CAAC;QACF,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,YAAY,CAAC,SAAiC;QACnD,SAAS,CAAC,MAAM,GAAG,SAAS,CAAC,MAAM,IAAI,EAAE,CAAC;QAC1C,SAAS,CAAC,YAAY,GAAG,SAAS,CAAC,YAAY,IAAI,EAAE,CAAC;QACtD,SAAS,CAAC,iBAAiB,GAAG,SAAS,CAAC,iBAAiB,IAAI,EAAE,CAAC;QAChE,SAAS,CAAC,kBAAkB,GAAG,SAAS,CAAC,kBAAkB,IAAI,EAAE,CAAC;QAClE,SAAS,CAAC,MAAM,GAAG,SAAS,CAAC,MAAM,IAAI,KAAK,CAAC;QAC7C,SAAS,CAAC,4BAA4B;YACpC,SAAS,CAAC,4BAA4B,IAAI,SAAS,CAAC;QACtD,SAAS,CAAC,yBAAyB;YACjC,SAAS,CAAC,yBAAyB,IAAI,CAAC,CAAC;QAC3C,SAAS,CAAC,eAAe,GAAG,SAAS,CAAC,eAAe,IAAI,CAAC,CAAC;IAC7D,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,2BAA2B,CAChC,SAAiC,EACjC,OAAqB;QAErB,OAAO,OAAO,CAAC,SAAS,EAAE,EAAE;YAC1B,IAAI,OAAO,CAAC,UAAU,EAAE;gBAAE,MAAM;YAEhC,QAAQ,OAAO,CAAC,cAAc,EAAE,EAAE;gBAChC,KAAK,CAAC;oBACJ,SAAS,CAAC,MAAM,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;oBACxC,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,YAAY,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;oBAC9C,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,iBAAiB,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;oBACnD,MAAM;gBACR,KAAK,CAAC;oBACJ,CAAC,SAAS,CAAC,kBAAkB;wBAC3B,SAAS,CAAC,kBAAkB,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC;oBACjE,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,MAAM,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC;oBACtC,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,4BAA4B,GAAG,IAAI,4BAA4B,EAAE,CAAC;oBAC5E,OAAO,CAAC,WAAW,CACjB,SAAS,CAAC,4BAA4B,EACtC,4BAA4B,CAAC,2BAA2B,CACzD,CAAC;oBACF,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,yBAAyB,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC;oBACzD,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,eAAe,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;oBAChD,MAAM;gBACR;oBACE,OAAO,CAAC,SAAS,EAAE,CAAC;aACvB;SACF;QAED,sBAAsB,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;IACjD,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,uBAAuB,CAC5B,SAAiC,EACjC,OAAqB;QAErB,IAAI,SAAS,CAAC,MAAM,EAAE;YACpB,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;SAC1C;QACD,IAAI,SAAS,CAAC,YAAY,EAAE;YAC1B,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,SAAS,CAAC,YAAY,CAAC,CAAC;SAChD;QACD,IAAI,SAAS,CAAC,iBAAiB,EAAE;YAC/B,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,SAAS,CAAC,iBAAiB,CAAC,CAAC;SACrD;QACD,IAAI,SAAS,CAAC,kBAAkB,IAAI,SAAS,CAAC,kBAAkB,CAAC,MAAM,EAAE;YACvE,OAAO,CAAC,mBAAmB,CAAC,CAAC,EAAE,SAAS,CAAC,kBAAkB,CAAC,CAAC;SAC9D;QACD,IAAI,SAAS,CAAC,MAAM,EAAE;YACpB,OAAO,CAAC,SAAS,CAAC,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;SACxC;QACD,IAAI,SAAS,CAAC,4BAA4B,EAAE;YAC1C,OAAO,CAAC,YAAY,CAClB,CAAC,EACD,SAAS,CAAC,4BAAmC,EAC7C,4BAA4B,CAAC,uBAAuB,CACrD,CAAC;SACH;QACD,IAAI,SAAS,CAAC,yBAAyB,EAAE;YACvC,OAAO,CAAC,SAAS,CAAC,CAAC,EAAE,SAAS,CAAC,yBAAyB,CAAC,CAAC;SAC3D;QACD,IAAI,SAAS,CAAC,eAAe,EAAE;YAC7B,OAAO,CAAC,UAAU,CAAC,CAAC,EAAE,SAAS,CAAC,eAAe,CAAC,CAAC;SAClD;IACH,CAAC;IA6BD,IAAI,MAAM;QACR,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IACD,IAAI,MAAM,CAAC,KAAyB;QAClC,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;IACvB,CAAC;IACD,IAAI,YAAY;QACd,OAAO,IAAI,CAAC,aAAa,CAAC;IAC5B,CAAC;IACD,IAAI,YAAY,CAAC,KAAyB;QACxC,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC;IAC7B,CAAC;IACD,IAAI,iBAAiB;QACnB,OAAO,IAAI,CAAC,kBAAkB,CAAC;IACjC,CAAC;IACD,IAAI,iBAAiB,CAAC,KAAyB;QAC7C,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC;IAClC,CAAC;IACD,IAAI,kBAAkB;QACpB,OAAO,IAAI,CAAC,mBAAmB,CAAC;IAClC,CAAC;IACD,IAAI,kBAAkB,CAAC,KAA2B;QAChD,IAAI,CAAC,mBAAmB,GAAG,KAAK,CAAC;IACnC,CAAC;IACD,IAAI,MAAM;QACR,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IACD,IAAI,MAAM,CAAC,KAA0B;QACnC,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;IACvB,CAAC;IACD,IAAI,4BAA4B;QAC9B,OAAO,IAAI,CAAC,6BAA6B,CAAC;IAC5C,CAAC;IACD,IAAI,4BAA4B,CAC9B,KAA+C;QAE/C,IAAI,CAAC,6BAA6B,GAAG,KAAK,CAAC;IAC7C,CAAC;IACD,IAAI,yBAAyB;QAC3B,OAAO,IAAI,CAAC,0BAA0B,CAAC;IACzC,CAAC;IACD,IAAI,yBAAyB,CAAC,KAA4C;QACxE,IAAI,CAAC,0BAA0B,GAAG,KAAK,CAAC;IAC1C,CAAC;IACD,IAAI,eAAe;QACjB,OAAO,IAAI,CAAC,gBAAgB,CAAC;IAC/B,CAAC;IACD,IAAI,eAAe,CAAC,KAAyB;QAC3C,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC;IAChC,CAAC;IAED;;;OAGG;IACH,eAAe;QACb,MAAM,MAAM,GAAG,IAAI,YAAY,EAAE,CAAC;QAClC,sBAAsB,CAAC,uBAAuB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QAC7D,OAAO,MAAM,CAAC,eAAe,EAAE,CAAC;IAClC,CAAC;IAED;;OAEG;IACH,QAAQ;QACN,OAAO;YACL,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,YAAY,EAAE,IAAI,CAAC,YAAY;YAC/B,iBAAiB,EAAE,IAAI,CAAC,iBAAiB;YACzC,kBAAkB,EAAE,CAAC,IAAI,CAAC,kBAAkB,IAAI,EAAE,CAAC,CAAC,KAAK,EAAE;YAC3D,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,4BAA4B,EAAE,IAAI,CAAC,4BAA4B;gBAC7D,CAAC,CAAC,IAAI,CAAC,4BAA4B,CAAC,QAAQ,EAAE;gBAC9C,CAAC,CAAC,SAAS;YACb,yBAAyB,EAAE,IAAI,CAAC,yBAAyB;YACzD,eAAe,EAAE,IAAI,CAAC,eAAe;SACtC,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,MAAM;QACJ,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC;IACzB,CAAC;IAED;;;;OAIG;IACH,cAAc;IACZ,aAAa;IACb,OAA+B;QAE/B,OAAO;YACL,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,YAAY,EAAE,IAAI,CAAC,YAAY;YAC/B,iBAAiB,EAAE,IAAI,CAAC,iBAAiB;YACzC,kBAAkB,EAAE,CAAC,IAAI,CAAC,kBAAkB,IAAI,EAAE,CAAC,CAAC,KAAK,EAAE;YAC3D,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,4BAA4B,EAAE,IAAI,CAAC,4BAA4B;gBAC7D,CAAC,CAAC,IAAI,CAAC,4BAA4B,CAAC,cAAc,CAAC,OAAO,CAAC;gBAC3D,CAAC,CAAC,IAAI;YACR,yBAAyB,EACvB,yBAAyB,CACvB,IAAI,CAAC,yBAAyB,KAAK,IAAI;gBACvC,IAAI,CAAC,yBAAyB,KAAK,SAAS;gBAC1C,CAAC,CAAC,CAAC;gBACH,CAAC,CAAC,IAAI,CAAC,yBAAyB,CACnC;YACH,eAAe,EAAE,IAAI,CAAC,eAAe;SACtC,CAAC;IACJ,CAAC;;AArQM,yBAAE,GAAG,mCAAmC,CAAC;AAqSlD;;GAEG;AACH,MAAM,OAAO,uBAAuB;IA8FlC;;;OAGG;IACH,YAAY,MAA2D;QACrE,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;QACtB,IAAI,CAAC,cAAc,GAAG,CAAC,MAAM,CAAC,cAAc,IAAI,EAAE,CAAC,CAAC,GAAG,CACrD,CAAC,CAAC,EAAE,CAAC,IAAI,YAAY,CAAC,MAAM,CAAC,CAAC,CAAC,CAChC,CAAC;QACF,IAAI,CAAC,gBAAgB,GAAG,CAAC,MAAM,CAAC,gBAAgB,IAAI,EAAE,CAAC,CAAC,GAAG,CACzD,CAAC,CAAC,EAAE,CAAC,IAAI,YAAY,CAAC,CAAC,CAAC,CACzB,CAAC;QACF,uBAAuB,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IAC7C,CAAC;IAxGD;;;OAGG;IACH,MAAM,CAAC,iBAAiB,CAAC,KAAiB;QACxC,MAAM,QAAQ,GAAG,IAAI,uBAAuB,EAAE,CAAC;QAC/C,uBAAuB,CAAC,2BAA2B,CACjD,QAAQ,EACR,IAAI,YAAY,CAAC,KAAK,CAAC,CACxB,CAAC;QACF,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,YAAY,CAAC,SAAkC;QACpD,SAAS,CAAC,cAAc,GAAG,SAAS,CAAC,cAAc,IAAI,EAAE,CAAC;QAC1D,SAAS,CAAC,gBAAgB,GAAG,SAAS,CAAC,gBAAgB,IAAI,EAAE,CAAC;IAChE,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,2BAA2B,CAChC,SAAkC,EAClC,OAAqB;QAErB,OAAO,OAAO,CAAC,SAAS,EAAE,EAAE;YAC1B,IAAI,OAAO,CAAC,UAAU,EAAE;gBAAE,MAAM;YAEhC,QAAQ,OAAO,CAAC,cAAc,EAAE,EAAE;gBAChC,KAAK,CAAC;oBACJ,MAAM,mBAAmB,GAAG,IAAI,YAAY,CAAC,MAAM,EAAE,CAAC;oBACtD,OAAO,CAAC,WAAW,CACjB,mBAAmB,EACnB,YAAY,CAAC,MAAM,CAAC,2BAA2B,CAChD,CAAC;oBACF,CAAC,SAAS,CAAC,cAAc,GAAG,SAAS,CAAC,cAAc,IAAI,EAAE,CAAC,CAAC,IAAI,CAC9D,mBAAmB,CACpB,CAAC;oBACF,MAAM;gBACR,KAAK,CAAC;oBACJ,MAAM,mBAAmB,GAAG,IAAI,YAAY,EAAE,CAAC;oBAC/C,OAAO,CAAC,WAAW,CACjB,mBAAmB,EACnB,YAAY,CAAC,2BAA2B,CACzC,CAAC;oBACF,CAAC,SAAS,CAAC,gBAAgB,GAAG,SAAS,CAAC,gBAAgB,IAAI,EAAE,CAAC,CAAC,IAAI,CAClE,mBAAmB,CACpB,CAAC;oBACF,MAAM;gBACR;oBACE,OAAO,CAAC,SAAS,EAAE,CAAC;aACvB;SACF;QAED,uBAAuB,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;IAClD,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,uBAAuB,CAC5B,SAAkC,EAClC,OAAqB;QAErB,IAAI,SAAS,CAAC,cAAc,IAAI,SAAS,CAAC,cAAc,CAAC,MAAM,EAAE;YAC/D,OAAO,CAAC,oBAAoB,CAC1B,CAAC,EACD,SAAS,CAAC,cAAqB,EAC/B,YAAY,CAAC,MAAM,CAAC,uBAAuB,CAC5C,CAAC;SACH;QACD,IAAI,SAAS,CAAC,gBAAgB,IAAI,SAAS,CAAC,gBAAgB,CAAC,MAAM,EAAE;YACnE,OAAO,CAAC,oBAAoB,CAC1B,CAAC,EACD,SAAS,CAAC,gBAAuB,EACjC,YAAY,CAAC,uBAAuB,CACrC,CAAC;SACH;IACH,CAAC;IAmBD,IAAI,cAAc;QAChB,OAAO,IAAI,CAAC,eAAe,CAAC;IAC9B,CAAC;IACD,IAAI,cAAc,CAAC,KAAwC;QACzD,IAAI,CAAC,eAAe,GAAG,KAAK,CAAC;IAC/B,CAAC;IACD,IAAI,gBAAgB;QAClB,OAAO,IAAI,CAAC,iBAAiB,CAAC;IAChC,CAAC;IACD,IAAI,gBAAgB,CAAC,KAAiC;QACpD,IAAI,CAAC,iBAAiB,GAAG,KAAK,CAAC;IACjC,CAAC;IAED;;;OAGG;IACH,eAAe;QACb,MAAM,MAAM,GAAG,IAAI,YAAY,EAAE,CAAC;QAClC,uBAAuB,CAAC,uBAAuB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QAC9D,OAAO,MAAM,CAAC,eAAe,EAAE,CAAC;IAClC,CAAC;IAED;;OAEG;IACH,QAAQ;QACN,OAAO;YACL,cAAc,EAAE,CAAC,IAAI,CAAC,cAAc,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC;YAClE,gBAAgB,EAAE,CAAC,IAAI,CAAC,gBAAgB,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC;SACvE,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,MAAM;QACJ,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC;IACzB,CAAC;IAED;;;;OAIG;IACH,cAAc;IACZ,aAAa;IACb,OAA+B;QAE/B,OAAO;YACL,cAAc,EAAE,CAAC,IAAI,CAAC,cAAc,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAClD,CAAC,CAAC,cAAc,CAAC,OAAO,CAAC,CAC1B;YACD,gBAAgB,EAAE,CAAC,IAAI,CAAC,gBAAgB,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CACtD,CAAC,CAAC,cAAc,CAAC,OAAO,CAAC,CAC1B;SACF,CAAC;IACJ,CAAC;;AApKM,0BAAE,GAAG,oCAAoC,CAAC;AAwLnD;;GAEG;AACH,MAAM,OAAO,kBAAkB;IAmI7B;;;OAGG;IACH,YAAY,MAAsD;QAChE,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;QACtB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;QAC5B,IAAI,CAAC,UAAU,GAAG,MAAM,CAAC,UAAU,CAAC;QACpC,IAAI,CAAC,YAAY,GAAG,MAAM,CAAC,YAAY,CAAC;QACxC,IAAI,CAAC,iBAAiB,GAAG,MAAM,CAAC,iBAAiB,CAAC;QAClD,IAAI,CAAC,kBAAkB,GAAG,CAAC,MAAM,CAAC,kBAAkB,IAAI,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC;QACpE,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;QAC5B,IAAI,CAAC,4BAA4B,GAAG,MAAM,CAAC,4BAA4B;YACrE,CAAC,CAAC,IAAI,4BAA4B,CAAC,MAAM,CAAC,4BAA4B,CAAC;YACvE,CAAC,CAAC,SAAS,CAAC;QACd,IAAI,CAAC,yBAAyB,GAAG,MAAM,CAAC,yBAAyB,CAAC;QAClE,kBAAkB,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IACxC,CAAC;IAjJD;;;OAGG;IACH,MAAM,CAAC,iBAAiB,CAAC,KAAiB;QACxC,MAAM,QAAQ,GAAG,IAAI,kBAAkB,EAAE,CAAC;QAC1C,kBAAkB,CAAC,2BAA2B,CAC5C,QAAQ,EACR,IAAI,YAAY,CAAC,KAAK,CAAC,CACxB,CAAC;QACF,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,YAAY,CAAC,SAA6B;QAC/C,SAAS,CAAC,MAAM,GAAG,SAAS,CAAC,MAAM,IAAI,EAAE,CAAC;QAC1C,SAAS,CAAC,UAAU,GAAG,SAAS,CAAC,UAAU,IAAI,EAAE,CAAC;QAClD,SAAS,CAAC,YAAY,GAAG,SAAS,CAAC,YAAY,IAAI,EAAE,CAAC;QACtD,SAAS,CAAC,iBAAiB,GAAG,SAAS,CAAC,iBAAiB,IAAI,EAAE,CAAC;QAChE,SAAS,CAAC,kBAAkB,GAAG,SAAS,CAAC,kBAAkB,IAAI,EAAE,CAAC;QAClE,SAAS,CAAC,MAAM,GAAG,SAAS,CAAC,MAAM,IAAI,KAAK,CAAC;QAC7C,SAAS,CAAC,4BAA4B;YACpC,SAAS,CAAC,4BAA4B,IAAI,SAAS,CAAC;QACtD,SAAS,CAAC,yBAAyB;YACjC,SAAS,CAAC,yBAAyB,IAAI,CAAC,CAAC;IAC7C,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,2BAA2B,CAChC,SAA6B,EAC7B,OAAqB;QAErB,OAAO,OAAO,CAAC,SAAS,EAAE,EAAE;YAC1B,IAAI,OAAO,CAAC,UAAU,EAAE;gBAAE,MAAM;YAEhC,QAAQ,OAAO,CAAC,cAAc,EAAE,EAAE;gBAChC,KAAK,CAAC;oBACJ,SAAS,CAAC,MAAM,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;oBACxC,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,UAAU,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;oBAC5C,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,YAAY,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;oBAC9C,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,iBAAiB,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;oBACnD,MAAM;gBACR,KAAK,CAAC;oBACJ,CAAC,SAAS,CAAC,kBAAkB;wBAC3B,SAAS,CAAC,kBAAkB,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC;oBACjE,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,MAAM,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC;oBACtC,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,4BAA4B,GAAG,IAAI,4BAA4B,EAAE,CAAC;oBAC5E,OAAO,CAAC,WAAW,CACjB,SAAS,CAAC,4BAA4B,EACtC,4BAA4B,CAAC,2BAA2B,CACzD,CAAC;oBACF,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,yBAAyB,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC;oBACzD,MAAM;gBACR;oBACE,OAAO,CAAC,SAAS,EAAE,CAAC;aACvB;SACF;QAED,kBAAkB,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;IAC7C,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,uBAAuB,CAC5B,SAA6B,EAC7B,OAAqB;QAErB,IAAI,SAAS,CAAC,MAAM,EAAE;YACpB,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;SAC1C;QACD,IAAI,SAAS,CAAC,UAAU,EAAE;YACxB,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,SAAS,CAAC,UAAU,CAAC,CAAC;SAC9C;QACD,IAAI,SAAS,CAAC,YAAY,EAAE;YAC1B,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,SAAS,CAAC,YAAY,CAAC,CAAC;SAChD;QACD,IAAI,SAAS,CAAC,iBAAiB,EAAE;YAC/B,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,SAAS,CAAC,iBAAiB,CAAC,CAAC;SACrD;QACD,IAAI,SAAS,CAAC,kBAAkB,IAAI,SAAS,CAAC,kBAAkB,CAAC,MAAM,EAAE;YACvE,OAAO,CAAC,mBAAmB,CAAC,CAAC,EAAE,SAAS,CAAC,kBAAkB,CAAC,CAAC;SAC9D;QACD,IAAI,SAAS,CAAC,MAAM,EAAE;YACpB,OAAO,CAAC,SAAS,CAAC,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;SACxC;QACD,IAAI,SAAS,CAAC,4BAA4B,EAAE;YAC1C,OAAO,CAAC,YAAY,CAClB,CAAC,EACD,SAAS,CAAC,4BAAmC,EAC7C,4BAA4B,CAAC,uBAAuB,CACrD,CAAC;SACH;QACD,IAAI,SAAS,CAAC,yBAAyB,EAAE;YACvC,OAAO,CAAC,SAAS,CAAC,CAAC,EAAE,SAAS,CAAC,yBAAyB,CAAC,CAAC;SAC3D;IACH,CAAC;IA6BD,IAAI,MAAM;QACR,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IACD,IAAI,MAAM,CAAC,KAAyB;QAClC,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;IACvB,CAAC;IACD,IAAI,UAAU;QACZ,OAAO,IAAI,CAAC,WAAW,CAAC;IAC1B,CAAC;IACD,IAAI,UAAU,CAAC,KAAyB;QACtC,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC;IAC3B,CAAC;IACD,IAAI,YAAY;QACd,OAAO,IAAI,CAAC,aAAa,CAAC;IAC5B,CAAC;IACD,IAAI,YAAY,CAAC,KAAyB;QACxC,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC;IAC7B,CAAC;IACD,IAAI,iBAAiB;QACnB,OAAO,IAAI,CAAC,kBAAkB,CAAC;IACjC,CAAC;IACD,IAAI,iBAAiB,CAAC,KAAyB;QAC7C,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC;IAClC,CAAC;IACD,IAAI,kBAAkB;QACpB,OAAO,IAAI,CAAC,mBAAmB,CAAC;IAClC,CAAC;IACD,IAAI,kBAAkB,CAAC,KAA2B;QAChD,IAAI,CAAC,mBAAmB,GAAG,KAAK,CAAC;IACnC,CAAC;IACD,IAAI,MAAM;QACR,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IACD,IAAI,MAAM,CAAC,KAA0B;QACnC,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;IACvB,CAAC;IACD,IAAI,4BAA4B;QAC9B,OAAO,IAAI,CAAC,6BAA6B,CAAC;IAC5C,CAAC;IACD,IAAI,4BAA4B,CAC9B,KAA+C;QAE/C,IAAI,CAAC,6BAA6B,GAAG,KAAK,CAAC;IAC7C,CAAC;IACD,IAAI,yBAAyB;QAC3B,OAAO,IAAI,CAAC,0BAA0B,CAAC;IACzC,CAAC;IACD,IAAI,yBAAyB,CAAC,KAA4C;QACxE,IAAI,CAAC,0BAA0B,GAAG,KAAK,CAAC;IAC1C,CAAC;IAED;;;OAGG;IACH,eAAe;QACb,MAAM,MAAM,GAAG,IAAI,YAAY,EAAE,CAAC;QAClC,kBAAkB,CAAC,uBAAuB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QACzD,OAAO,MAAM,CAAC,eAAe,EAAE,CAAC;IAClC,CAAC;IAED;;OAEG;IACH,QAAQ;QACN,OAAO;YACL,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,YAAY,EAAE,IAAI,CAAC,YAAY;YAC/B,iBAAiB,EAAE,IAAI,CAAC,iBAAiB;YACzC,kBAAkB,EAAE,CAAC,IAAI,CAAC,kBAAkB,IAAI,EAAE,CAAC,CAAC,KAAK,EAAE;YAC3D,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,4BAA4B,EAAE,IAAI,CAAC,4BAA4B;gBAC7D,CAAC,CAAC,IAAI,CAAC,4BAA4B,CAAC,QAAQ,EAAE;gBAC9C,CAAC,CAAC,SAAS;YACb,yBAAyB,EAAE,IAAI,CAAC,yBAAyB;SAC1D,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,MAAM;QACJ,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC;IACzB,CAAC;IAED;;;;OAIG;IACH,cAAc;IACZ,aAAa;IACb,OAA+B;QAE/B,OAAO;YACL,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,YAAY,EAAE,IAAI,CAAC,YAAY;YAC/B,iBAAiB,EAAE,IAAI,CAAC,iBAAiB;YACzC,kBAAkB,EAAE,CAAC,IAAI,CAAC,kBAAkB,IAAI,EAAE,CAAC,CAAC,KAAK,EAAE;YAC3D,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,4BAA4B,EAAE,IAAI,CAAC,4BAA4B;gBAC7D,CAAC,CAAC,IAAI,CAAC,4BAA4B,CAAC,cAAc,CAAC,OAAO,CAAC;gBAC3D,CAAC,CAAC,IAAI;YACR,yBAAyB,EACvB,yBAAyB,CACvB,IAAI,CAAC,yBAAyB,KAAK,IAAI;gBACvC,IAAI,CAAC,yBAAyB,KAAK,SAAS;gBAC1C,CAAC,CAAC,CAAC;gBACH,CAAC,CAAC,IAAI,CAAC,yBAAyB,CACnC;SACJ,CAAC;IACJ,CAAC;;AArQM,qBAAE,GAAG,+BAA+B,CAAC;AAqS9C;;GAEG;AACH,MAAM,OAAO,mBAAmB;IAwF9B;;;OAGG;IACH,YAAY,MAAuD;QACjE,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;QACtB,IAAI,CAAC,aAAa,GAAG,MAAM,CAAC,aAAa;YACvC,CAAC,CAAC,IAAI,YAAY,CAAC,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC;YAC/C,CAAC,CAAC,SAAS,CAAC;QACd,IAAI,CAAC,YAAY,GAAG,MAAM,CAAC,YAAY;YACrC,CAAC,CAAC,IAAI,YAAY,CAAC,MAAM,CAAC,YAAY,CAAC;YACvC,CAAC,CAAC,SAAS,CAAC;QACd,mBAAmB,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IACzC,CAAC;IAlGD;;;OAGG;IACH,MAAM,CAAC,iBAAiB,CAAC,KAAiB;QACxC,MAAM,QAAQ,GAAG,IAAI,mBAAmB,EAAE,CAAC;QAC3C,mBAAmB,CAAC,2BAA2B,CAC7C,QAAQ,EACR,IAAI,YAAY,CAAC,KAAK,CAAC,CACxB,CAAC;QACF,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,YAAY,CAAC,SAA8B;QAChD,SAAS,CAAC,aAAa,GAAG,SAAS,CAAC,aAAa,IAAI,SAAS,CAAC;QAC/D,SAAS,CAAC,YAAY,GAAG,SAAS,CAAC,YAAY,IAAI,SAAS,CAAC;IAC/D,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,2BAA2B,CAChC,SAA8B,EAC9B,OAAqB;QAErB,OAAO,OAAO,CAAC,SAAS,EAAE,EAAE;YAC1B,IAAI,OAAO,CAAC,UAAU,EAAE;gBAAE,MAAM;YAEhC,QAAQ,OAAO,CAAC,cAAc,EAAE,EAAE;gBAChC,KAAK,CAAC;oBACJ,SAAS,CAAC,aAAa,GAAG,IAAI,YAAY,CAAC,MAAM,EAAE,CAAC;oBACpD,OAAO,CAAC,WAAW,CACjB,SAAS,CAAC,aAAa,EACvB,YAAY,CAAC,MAAM,CAAC,2BAA2B,CAChD,CAAC;oBACF,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,YAAY,GAAG,IAAI,YAAY,EAAE,CAAC;oBAC5C,OAAO,CAAC,WAAW,CACjB,SAAS,CAAC,YAAY,EACtB,YAAY,CAAC,2BAA2B,CACzC,CAAC;oBACF,MAAM;gBACR;oBACE,OAAO,CAAC,SAAS,EAAE,CAAC;aACvB;SACF;QAED,mBAAmB,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;IAC9C,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,uBAAuB,CAC5B,SAA8B,EAC9B,OAAqB;QAErB,IAAI,SAAS,CAAC,aAAa,EAAE;YAC3B,OAAO,CAAC,YAAY,CAClB,CAAC,EACD,SAAS,CAAC,aAAoB,EAC9B,YAAY,CAAC,MAAM,CAAC,uBAAuB,CAC5C,CAAC;SACH;QACD,IAAI,SAAS,CAAC,YAAY,EAAE;YAC1B,OAAO,CAAC,YAAY,CAClB,CAAC,EACD,SAAS,CAAC,YAAmB,EAC7B,YAAY,CAAC,uBAAuB,CACrC,CAAC;SACH;IACH,CAAC;IAmBD,IAAI,aAAa;QACf,OAAO,IAAI,CAAC,cAAc,CAAC;IAC7B,CAAC;IACD,IAAI,aAAa,CAAC,KAAsC;QACtD,IAAI,CAAC,cAAc,GAAG,KAAK,CAAC;IAC9B,CAAC;IACD,IAAI,YAAY;QACd,OAAO,IAAI,CAAC,aAAa,CAAC;IAC5B,CAAC;IACD,IAAI,YAAY,CAAC,KAA+B;QAC9C,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC;IAC7B,CAAC;IAED;;;OAGG;IACH,eAAe;QACb,MAAM,MAAM,GAAG,IAAI,YAAY,EAAE,CAAC;QAClC,mBAAmB,CAAC,uBAAuB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QAC1D,OAAO,MAAM,CAAC,eAAe,EAAE,CAAC;IAClC,CAAC;IAED;;OAEG;IACH,QAAQ;QACN,OAAO;YACL,aAAa,EAAE,IAAI,CAAC,aAAa;gBAC/B,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE;gBAC/B,CAAC,CAAC,SAAS;YACb,YAAY,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,SAAS;SAC3E,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,MAAM;QACJ,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC;IACzB,CAAC;IAED;;;;OAIG;IACH,cAAc;IACZ,aAAa;IACb,OAA+B;QAE/B,OAAO;YACL,aAAa,EAAE,IAAI,CAAC,aAAa;gBAC/B,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC,OAAO,CAAC;gBAC5C,CAAC,CAAC,IAAI;YACR,YAAY,EAAE,IAAI,CAAC,YAAY;gBAC7B,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,cAAc,CAAC,OAAO,CAAC;gBAC3C,CAAC,CAAC,IAAI;SACT,CAAC;IACJ,CAAC;;AAhKM,sBAAE,GAAG,gCAAgC,CAAC;AAoL/C;;GAEG;AACH,MAAM,OAAO,4BAA4B;IAmFvC;;;OAGG;IACH,YACE,MAAgE;QAEhE,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;QACtB,IAAI,CAAC,yBAAyB,GAAG,MAAM,CAAC,yBAAyB,CAAC;QAClE,IAAI,CAAC,8BAA8B,GAAG,MAAM,CAAC,8BAA8B,CAAC;QAC5E,IAAI,CAAC,+BAA+B;YAClC,MAAM,CAAC,+BAA+B,CAAC;QACzC,4BAA4B,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IAClD,CAAC;IA7FD;;;OAGG;IACH,MAAM,CAAC,iBAAiB,CAAC,KAAiB;QACxC,MAAM,QAAQ,GAAG,IAAI,4BAA4B,EAAE,CAAC;QACpD,4BAA4B,CAAC,2BAA2B,CACtD,QAAQ,EACR,IAAI,YAAY,CAAC,KAAK,CAAC,CACxB,CAAC;QACF,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,YAAY,CAAC,SAAuC;QACzD,SAAS,CAAC,yBAAyB;YACjC,SAAS,CAAC,yBAAyB,IAAI,KAAK,CAAC;QAC/C,SAAS,CAAC,8BAA8B;YACtC,SAAS,CAAC,8BAA8B,IAAI,KAAK,CAAC;QACpD,SAAS,CAAC,+BAA+B;YACvC,SAAS,CAAC,+BAA+B,IAAI,KAAK,CAAC;IACvD,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,2BAA2B,CAChC,SAAuC,EACvC,OAAqB;QAErB,OAAO,OAAO,CAAC,SAAS,EAAE,EAAE;YAC1B,IAAI,OAAO,CAAC,UAAU,EAAE;gBAAE,MAAM;YAEhC,QAAQ,OAAO,CAAC,cAAc,EAAE,EAAE;gBAChC,KAAK,CAAC;oBACJ,SAAS,CAAC,yBAAyB,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC;oBACzD,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,8BAA8B,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC;oBAC9D,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,+BAA+B,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC;oBAC/D,MAAM;gBACR;oBACE,OAAO,CAAC,SAAS,EAAE,CAAC;aACvB;SACF;QAED,4BAA4B,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;IACvD,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,uBAAuB,CAC5B,SAAuC,EACvC,OAAqB;QAErB,IAAI,SAAS,CAAC,yBAAyB,EAAE;YACvC,OAAO,CAAC,SAAS,CAAC,CAAC,EAAE,SAAS,CAAC,yBAAyB,CAAC,CAAC;SAC3D;QACD,IAAI,SAAS,CAAC,8BAA8B,EAAE;YAC5C,OAAO,CAAC,SAAS,CAAC,CAAC,EAAE,SAAS,CAAC,8BAA8B,CAAC,CAAC;SAChE;QACD,IAAI,SAAS,CAAC,+BAA+B,EAAE;YAC7C,OAAO,CAAC,SAAS,CAAC,CAAC,EAAE,SAAS,CAAC,+BAA+B,CAAC,CAAC;SACjE;IACH,CAAC;IAoBD,IAAI,yBAAyB;QAC3B,OAAO,IAAI,CAAC,0BAA0B,CAAC;IACzC,CAAC;IACD,IAAI,yBAAyB,CAAC,KAA0B;QACtD,IAAI,CAAC,0BAA0B,GAAG,KAAK,CAAC;IAC1C,CAAC;IACD,IAAI,8BAA8B;QAChC,OAAO,IAAI,CAAC,+BAA+B,CAAC;IAC9C,CAAC;IACD,IAAI,8BAA8B,CAAC,KAA0B;QAC3D,IAAI,CAAC,+BAA+B,GAAG,KAAK,CAAC;IAC/C,CAAC;IACD,IAAI,+BAA+B;QACjC,OAAO,IAAI,CAAC,gCAAgC,CAAC;IAC/C,CAAC;IACD,IAAI,+BAA+B,CAAC,KAA0B;QAC5D,IAAI,CAAC,gCAAgC,GAAG,KAAK,CAAC;IAChD,CAAC;IAED;;;OAGG;IACH,eAAe;QACb,MAAM,MAAM,GAAG,IAAI,YAAY,EAAE,CAAC;QAClC,4BAA4B,CAAC,uBAAuB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QACnE,OAAO,MAAM,CAAC,eAAe,EAAE,CAAC;IAClC,CAAC;IAED;;OAEG;IACH,QAAQ;QACN,OAAO;YACL,yBAAyB,EAAE,IAAI,CAAC,yBAAyB;YACzD,8BAA8B,EAAE,IAAI,CAAC,8BAA8B;YACnE,+BAA+B,EAAE,IAAI,CAAC,+BAA+B;SACtE,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,MAAM;QACJ,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC;IACzB,CAAC;IAED;;;;OAIG;IACH,cAAc;IACZ,aAAa;IACb,OAA+B;QAE/B,OAAO;YACL,yBAAyB,EAAE,IAAI,CAAC,yBAAyB;YACzD,8BAA8B,EAAE,IAAI,CAAC,8BAA8B;YACnE,+BAA+B,EAAE,IAAI,CAAC,+BAA+B;SACtE,CAAC;IACJ,CAAC;;AA7JM,+BAAE,GAAG,yCAAyC,CAAC;AAmLxD;;GAEG;AACH,MAAM,OAAO,YAAY;IAqEvB;;;OAGG;IACH,YAAY,MAAgD;QAC1D,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;QACtB,IAAI,CAAC,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC;QACtB,IAAI,CAAC,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC;QACtB,YAAY,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IAClC,CAAC;IA3ED;;;OAGG;IACH,MAAM,CAAC,iBAAiB,CAAC,KAAiB;QACxC,MAAM,QAAQ,GAAG,IAAI,YAAY,EAAE,CAAC;QACpC,YAAY,CAAC,2BAA2B,CAAC,QAAQ,EAAE,IAAI,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC;QAC5E,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,YAAY,CAAC,SAAuB;QACzC,SAAS,CAAC,GAAG,GAAG,SAAS,CAAC,GAAG,IAAI,EAAE,CAAC;QACpC,SAAS,CAAC,GAAG,GAAG,SAAS,CAAC,GAAG,IAAI,EAAE,CAAC;IACtC,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,2BAA2B,CAChC,SAAuB,EACvB,OAAqB;QAErB,OAAO,OAAO,CAAC,SAAS,EAAE,EAAE;YAC1B,IAAI,OAAO,CAAC,UAAU,EAAE;gBAAE,MAAM;YAEhC,QAAQ,OAAO,CAAC,cAAc,EAAE,EAAE;gBAChC,KAAK,CAAC;oBACJ,SAAS,CAAC,GAAG,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;oBACrC,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,GAAG,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;oBACrC,MAAM;gBACR;oBACE,OAAO,CAAC,SAAS,EAAE,CAAC;aACvB;SACF;QAED,YAAY,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;IACvC,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,uBAAuB,CAC5B,SAAuB,EACvB,OAAqB;QAErB,IAAI,SAAS,CAAC,GAAG,EAAE;YACjB,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,SAAS,CAAC,GAAG,CAAC,CAAC;SACvC;QACD,IAAI,SAAS,CAAC,GAAG,EAAE;YACjB,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,SAAS,CAAC,GAAG,CAAC,CAAC;SACvC;IACH,CAAC;IAeD,IAAI,GAAG;QACL,OAAO,IAAI,CAAC,IAAI,CAAC;IACnB,CAAC;IACD,IAAI,GAAG,CAAC,KAAyB;QAC/B,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC;IACpB,CAAC;IACD,IAAI,GAAG;QACL,OAAO,IAAI,CAAC,IAAI,CAAC;IACnB,CAAC;IACD,IAAI,GAAG,CAAC,KAAyB;QAC/B,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC;IACpB,CAAC;IAED;;;OAGG;IACH,eAAe;QACb,MAAM,MAAM,GAAG,IAAI,YAAY,EAAE,CAAC;QAClC,YAAY,CAAC,uBAAuB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QACnD,OAAO,MAAM,CAAC,eAAe,EAAE,CAAC;IAClC,CAAC;IAED;;OAEG;IACH,QAAQ;QACN,OAAO;YACL,GAAG,EAAE,IAAI,CAAC,GAAG;YACb,GAAG,EAAE,IAAI,CAAC,GAAG;SACd,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,MAAM;QACJ,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC;IACzB,CAAC;IAED;;;;OAIG;IACH,cAAc;IACZ,aAAa;IACb,OAA+B;QAE/B,OAAO;YACL,GAAG,EAAE,IAAI,CAAC,GAAG;YACb,GAAG,EAAE,IAAI,CAAC,GAAG;SACd,CAAC;IACJ,CAAC;;AAnIM,eAAE,GAAG,yBAAyB,CAAC;AAuJxC;;GAEG;AACH,MAAM,OAAO,YAAY;IA4FvB;;;OAGG;IACH,YAAY,MAAgD;QAC1D,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;QACtB,IAAI,CAAC,iBAAiB,GAAG,MAAM,CAAC,iBAAiB,CAAC;QAClD,IAAI,CAAC,wBAAwB,GAAG,CAAC,MAAM,CAAC,wBAAwB,IAAI,EAAE,CAAC,CAAC,GAAG,CACzE,CAAC,CAAC,EAAE,CAAC,IAAI,YAAY,CAAC,oBAAoB,CAAC,CAAC,CAAC,CAC9C,CAAC;QACF,IAAI,CAAC,iBAAiB,GAAG,CAAC,MAAM,CAAC,iBAAiB,IAAI,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC;QAClE,YAAY,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IAClC,CAAC;IArGD;;;OAGG;IACH,MAAM,CAAC,iBAAiB,CAAC,KAAiB;QACxC,MAAM,QAAQ,GAAG,IAAI,YAAY,EAAE,CAAC;QACpC,YAAY,CAAC,2BAA2B,CAAC,QAAQ,EAAE,IAAI,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC;QAC5E,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,YAAY,CAAC,SAAuB;QACzC,SAAS,CAAC,iBAAiB,GAAG,SAAS,CAAC,iBAAiB,IAAI,EAAE,CAAC;QAChE,SAAS,CAAC,wBAAwB;YAChC,SAAS,CAAC,wBAAwB,IAAI,EAAE,CAAC;QAC3C,SAAS,CAAC,iBAAiB,GAAG,SAAS,CAAC,iBAAiB,IAAI,EAAE,CAAC;IAClE,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,2BAA2B,CAChC,SAAuB,EACvB,OAAqB;QAErB,OAAO,OAAO,CAAC,SAAS,EAAE,EAAE;YAC1B,IAAI,OAAO,CAAC,UAAU,EAAE;gBAAE,MAAM;YAEhC,QAAQ,OAAO,CAAC,cAAc,EAAE,EAAE;gBAChC,KAAK,CAAC;oBACJ,SAAS,CAAC,iBAAiB,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;oBACnD,MAAM;gBACR,KAAK,CAAC;oBACJ,MAAM,mBAAmB,GAAG,IAAI,YAAY,CAAC,oBAAoB,EAAE,CAAC;oBACpE,OAAO,CAAC,WAAW,CACjB,mBAAmB,EACnB,YAAY,CAAC,oBAAoB,CAAC,2BAA2B,CAC9D,CAAC;oBACF,CAAC,SAAS,CAAC,wBAAwB;wBACjC,SAAS,CAAC,wBAAwB,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;oBACtE,MAAM;gBACR,KAAK,CAAC;oBACJ,CAAC,SAAS,CAAC,iBAAiB;wBAC1B,SAAS,CAAC,iBAAiB,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC;oBAChE,MAAM;gBACR;oBACE,OAAO,CAAC,SAAS,EAAE,CAAC;aACvB;SACF;QAED,YAAY,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;IACvC,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,uBAAuB,CAC5B,SAAuB,EACvB,OAAqB;QAErB,IAAI,SAAS,CAAC,iBAAiB,EAAE;YAC/B,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,SAAS,CAAC,iBAAiB,CAAC,CAAC;SACrD;QACD,IACE,SAAS,CAAC,wBAAwB;YAClC,SAAS,CAAC,wBAAwB,CAAC,MAAM,EACzC;YACA,OAAO,CAAC,oBAAoB,CAC1B,CAAC,EACD,SAAS,CAAC,wBAA+B,EACzC,YAAY,CAAC,oBAAoB,CAAC,uBAAuB,CAC1D,CAAC;SACH;QACD,IAAI,SAAS,CAAC,iBAAiB,IAAI,SAAS,CAAC,iBAAiB,CAAC,MAAM,EAAE;YACrE,OAAO,CAAC,mBAAmB,CAAC,CAAC,EAAE,SAAS,CAAC,iBAAiB,CAAC,CAAC;SAC7D;IACH,CAAC;IAmBD,IAAI,iBAAiB;QACnB,OAAO,IAAI,CAAC,kBAAkB,CAAC;IACjC,CAAC;IACD,IAAI,iBAAiB,CAAC,KAAyB;QAC7C,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC;IAClC,CAAC;IACD,IAAI,wBAAwB;QAG1B,OAAO,IAAI,CAAC,yBAAyB,CAAC;IACxC,CAAC;IACD,IAAI,wBAAwB,CAC1B,KAAsD;QAEtD,IAAI,CAAC,yBAAyB,GAAG,KAAK,CAAC;IACzC,CAAC;IACD,IAAI,iBAAiB;QACnB,OAAO,IAAI,CAAC,kBAAkB,CAAC;IACjC,CAAC;IACD,IAAI,iBAAiB,CAAC,KAA2B;QAC/C,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC;IAClC,CAAC;IAED;;;OAGG;IACH,eAAe;QACb,MAAM,MAAM,GAAG,IAAI,YAAY,EAAE,CAAC;QAClC,YAAY,CAAC,uBAAuB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QACnD,OAAO,MAAM,CAAC,eAAe,EAAE,CAAC;IAClC,CAAC;IAED;;OAEG;IACH,QAAQ;QACN,OAAO;YACL,iBAAiB,EAAE,IAAI,CAAC,iBAAiB;YACzC,wBAAwB,EAAE,CAAC,IAAI,CAAC,wBAAwB,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CACtE,CAAC,CAAC,QAAQ,EAAE,CACb;YACD,iBAAiB,EAAE,CAAC,IAAI,CAAC,iBAAiB,IAAI,EAAE,CAAC,CAAC,KAAK,EAAE;SAC1D,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,MAAM;QACJ,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC;IACzB,CAAC;IAED;;;;OAIG;IACH,cAAc;IACZ,aAAa;IACb,OAA+B;QAE/B,OAAO;YACL,iBAAiB,EAAE,IAAI,CAAC,iBAAiB;YACzC,wBAAwB,EAAE,CAAC,IAAI,CAAC,wBAAwB,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CACtE,CAAC,CAAC,cAAc,CAAC,OAAO,CAAC,CAC1B;YACD,iBAAiB,EAAE,CAAC,IAAI,CAAC,iBAAiB,IAAI,EAAE,CAAC,CAAC,KAAK,EAAE;SAC1D,CAAC;IACJ,CAAC;;AA7KM,eAAE,GAAG,yBAAyB,CAAC;AA+KxC,WAAc,YAAY;IAqBxB;;OAEG;IACH,MAAa,oBAAoB;QAiH/B;;;WAGG;QACH,YAAY,MAAwD;YAClE,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;YACtB,IAAI,CAAC,oBAAoB,GAAG,MAAM,CAAC,oBAAoB;gBACrD,CAAC,CAAC,IAAI,YAAY,CAAC,MAAM,CAAC,oBAAoB,CAAC;gBAC/C,CAAC,CAAC,SAAS,CAAC;YACd,IAAI,CAAC,aAAa,GAAG,CAAC,MAAM,CAAC,aAAa,IAAI,EAAE,CAAC,CAAC,GAAG,CACnD,CAAC,CAAC,EAAE,CAAC,IAAI,YAAY,CAAC,CAAC,CAAC,CACzB,CAAC;YACF,IAAI,CAAC,mBAAmB,GAAG,CAAC,MAAM,CAAC,mBAAmB,IAAI,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC;YACtE,IAAI,CAAC,sBAAsB,GAAG,MAAM,CAAC,sBAAsB,CAAC;YAC5D,oBAAoB,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;QAC1C,CAAC;QA7HD;;;WAGG;QACH,MAAM,CAAC,iBAAiB,CAAC,KAAiB;YACxC,MAAM,QAAQ,GAAG,IAAI,oBAAoB,EAAE,CAAC;YAC5C,oBAAoB,CAAC,2BAA2B,CAC9C,QAAQ,EACR,IAAI,YAAY,CAAC,KAAK,CAAC,CACxB,CAAC;YACF,OAAO,QAAQ,CAAC;QAClB,CAAC;QAED;;;WAGG;QACH,MAAM,CAAC,YAAY,CAAC,SAA+B;YACjD,SAAS,CAAC,oBAAoB;gBAC5B,SAAS,CAAC,oBAAoB,IAAI,SAAS,CAAC;YAC9C,SAAS,CAAC,aAAa,GAAG,SAAS,CAAC,aAAa,IAAI,EAAE,CAAC;YACxD,SAAS,CAAC,mBAAmB,GAAG,SAAS,CAAC,mBAAmB,IAAI,EAAE,CAAC;YACpE,SAAS,CAAC,sBAAsB;gBAC9B,SAAS,CAAC,sBAAsB,IAAI,KAAK,CAAC;QAC9C,CAAC;QAED;;;;WAIG;QACH,MAAM,CAAC,2BAA2B,CAChC,SAA+B,EAC/B,OAAqB;YAErB,OAAO,OAAO,CAAC,SAAS,EAAE,EAAE;gBAC1B,IAAI,OAAO,CAAC,UAAU,EAAE;oBAAE,MAAM;gBAEhC,QAAQ,OAAO,CAAC,cAAc,EAAE,EAAE;oBAChC,KAAK,CAAC;wBACJ,SAAS,CAAC,oBAAoB,GAAG,IAAI,YAAY,EAAE,CAAC;wBACpD,OAAO,CAAC,WAAW,CACjB,SAAS,CAAC,oBAAoB,EAC9B,YAAY,CAAC,2BAA2B,CACzC,CAAC;wBACF,MAAM;oBACR,KAAK,CAAC;wBACJ,MAAM,mBAAmB,GAAG,IAAI,YAAY,EAAE,CAAC;wBAC/C,OAAO,CAAC,WAAW,CACjB,mBAAmB,EACnB,YAAY,CAAC,2BAA2B,CACzC,CAAC;wBACF,CAAC,SAAS,CAAC,aAAa,GAAG,SAAS,CAAC,aAAa,IAAI,EAAE,CAAC,CAAC,IAAI,CAC5D,mBAAmB,CACpB,CAAC;wBACF,MAAM;oBACR,KAAK,CAAC;wBACJ,CAAC,SAAS,CAAC,mBAAmB;4BAC5B,SAAS,CAAC,mBAAmB,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC;wBAClE,MAAM;oBACR,KAAK,CAAC;wBACJ,SAAS,CAAC,sBAAsB,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC;wBACtD,MAAM;oBACR;wBACE,OAAO,CAAC,SAAS,EAAE,CAAC;iBACvB;aACF;YAED,oBAAoB,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;QAC/C,CAAC;QAED;;;;WAIG;QACH,MAAM,CAAC,uBAAuB,CAC5B,SAA+B,EAC/B,OAAqB;YAErB,IAAI,SAAS,CAAC,oBAAoB,EAAE;gBAClC,OAAO,CAAC,YAAY,CAClB,CAAC,EACD,SAAS,CAAC,oBAA2B,EACrC,YAAY,CAAC,uBAAuB,CACrC,CAAC;aACH;YACD,IAAI,SAAS,CAAC,aAAa,IAAI,SAAS,CAAC,aAAa,CAAC,MAAM,EAAE;gBAC7D,OAAO,CAAC,oBAAoB,CAC1B,CAAC,EACD,SAAS,CAAC,aAAoB,EAC9B,YAAY,CAAC,uBAAuB,CACrC,CAAC;aACH;YACD,IACE,SAAS,CAAC,mBAAmB;gBAC7B,SAAS,CAAC,mBAAmB,CAAC,MAAM,EACpC;gBACA,OAAO,CAAC,mBAAmB,CAAC,CAAC,EAAE,SAAS,CAAC,mBAAmB,CAAC,CAAC;aAC/D;YACD,IAAI,SAAS,CAAC,sBAAsB,EAAE;gBACpC,OAAO,CAAC,SAAS,CAAC,CAAC,EAAE,SAAS,CAAC,sBAAsB,CAAC,CAAC;aACxD;QACH,CAAC;QAuBD,IAAI,oBAAoB;YACtB,OAAO,IAAI,CAAC,qBAAqB,CAAC;QACpC,CAAC;QACD,IAAI,oBAAoB,CAAC,KAA+B;YACtD,IAAI,CAAC,qBAAqB,GAAG,KAAK,CAAC;QACrC,CAAC;QACD,IAAI,aAAa;YACf,OAAO,IAAI,CAAC,cAAc,CAAC;QAC7B,CAAC;QACD,IAAI,aAAa,CAAC,KAAiC;YACjD,IAAI,CAAC,cAAc,GAAG,KAAK,CAAC;QAC9B,CAAC;QACD,IAAI,mBAAmB;YACrB,OAAO,IAAI,CAAC,oBAAoB,CAAC;QACnC,CAAC;QACD,IAAI,mBAAmB,CAAC,KAA2B;YACjD,IAAI,CAAC,oBAAoB,GAAG,KAAK,CAAC;QACpC,CAAC;QACD,IAAI,sBAAsB;YACxB,OAAO,IAAI,CAAC,uBAAuB,CAAC;QACtC,CAAC;QACD,IAAI,sBAAsB,CAAC,KAA0B;YACnD,IAAI,CAAC,uBAAuB,GAAG,KAAK,CAAC;QACvC,CAAC;QAED;;;WAGG;QACH,eAAe;YACb,MAAM,MAAM,GAAG,IAAI,YAAY,EAAE,CAAC;YAClC,oBAAoB,CAAC,uBAAuB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;YAC3D,OAAO,MAAM,CAAC,eAAe,EAAE,CAAC;QAClC,CAAC;QAED;;WAEG;QACH,QAAQ;YACN,OAAO;gBACL,oBAAoB,EAAE,IAAI,CAAC,oBAAoB;oBAC7C,CAAC,CAAC,IAAI,CAAC,oBAAoB,CAAC,QAAQ,EAAE;oBACtC,CAAC,CAAC,SAAS;gBACb,aAAa,EAAE,CAAC,IAAI,CAAC,aAAa,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC;gBAChE,mBAAmB,EAAE,CAAC,IAAI,CAAC,mBAAmB,IAAI,EAAE,CAAC,CAAC,KAAK,EAAE;gBAC7D,sBAAsB,EAAE,IAAI,CAAC,sBAAsB;aACpD,CAAC;QACJ,CAAC;QAED;;WAEG;QACH,MAAM;YACJ,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC;QACzB,CAAC;QAED;;;;WAIG;QACH,cAAc;QACZ,aAAa;QACb,OAA+B;YAE/B,OAAO;gBACL,oBAAoB,EAAE,IAAI,CAAC,oBAAoB;oBAC7C,CAAC,CAAC,IAAI,CAAC,oBAAoB,CAAC,cAAc,CAAC,OAAO,CAAC;oBACnD,CAAC,CAAC,IAAI;gBACR,aAAa,EAAE,CAAC,IAAI,CAAC,aAAa,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAChD,CAAC,CAAC,cAAc,CAAC,OAAO,CAAC,CAC1B;gBACD,mBAAmB,EAAE,CAAC,IAAI,CAAC,mBAAmB,IAAI,EAAE,CAAC,CAAC,KAAK,EAAE;gBAC7D,sBAAsB,EAAE,IAAI,CAAC,sBAAsB;aACpD,CAAC;QACJ,CAAC;;IA3MM,uBAAE,GAAG,iCAAiC,CAAC;IADnC,iCAAoB,uBA6MhC,CAAA;AAsBH,CAAC,EA3Pa,YAAY,KAAZ,YAAY,QA2PzB;AAED;;GAEG;AACH,MAAM,OAAO,gBAAgB;IAmF3B;;;OAGG;IACH,YAAY,MAAoD;QAC9D,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;QACtB,IAAI,CAAC,cAAc,GAAG,MAAM,CAAC,cAAc,CAAC;QAC5C,IAAI,CAAC,gBAAgB,GAAG,CAAC,MAAM,CAAC,gBAAgB,IAAI,EAAE,CAAC,CAAC,GAAG,CACzD,CAAC,CAAC,EAAE,CAAC,IAAI,gBAAgB,CAAC,YAAY,CAAC,CAAC,CAAC,CAC1C,CAAC;QACF,gBAAgB,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IACtC,CAAC;IA3FD;;;OAGG;IACH,MAAM,CAAC,iBAAiB,CAAC,KAAiB;QACxC,MAAM,QAAQ,GAAG,IAAI,gBAAgB,EAAE,CAAC;QACxC,gBAAgB,CAAC,2BAA2B,CAC1C,QAAQ,EACR,IAAI,YAAY,CAAC,KAAK,CAAC,CACxB,CAAC;QACF,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,YAAY,CAAC,SAA2B;QAC7C,SAAS,CAAC,cAAc,GAAG,SAAS,CAAC,cAAc,IAAI,EAAE,CAAC;QAC1D,SAAS,CAAC,gBAAgB,GAAG,SAAS,CAAC,gBAAgB,IAAI,EAAE,CAAC;IAChE,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,2BAA2B,CAChC,SAA2B,EAC3B,OAAqB;QAErB,OAAO,OAAO,CAAC,SAAS,EAAE,EAAE;YAC1B,IAAI,OAAO,CAAC,UAAU,EAAE;gBAAE,MAAM;YAEhC,QAAQ,OAAO,CAAC,cAAc,EAAE,EAAE;gBAChC,KAAK,CAAC;oBACJ,SAAS,CAAC,cAAc,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;oBAChD,MAAM;gBACR,KAAK,CAAC;oBACJ,MAAM,mBAAmB,GAAG,IAAI,gBAAgB,CAAC,YAAY,EAAE,CAAC;oBAChE,OAAO,CAAC,WAAW,CACjB,mBAAmB,EACnB,gBAAgB,CAAC,YAAY,CAAC,2BAA2B,CAC1D,CAAC;oBACF,CAAC,SAAS,CAAC,gBAAgB,GAAG,SAAS,CAAC,gBAAgB,IAAI,EAAE,CAAC,CAAC,IAAI,CAClE,mBAAmB,CACpB,CAAC;oBACF,MAAM;gBACR;oBACE,OAAO,CAAC,SAAS,EAAE,CAAC;aACvB;SACF;QAED,gBAAgB,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;IAC3C,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,uBAAuB,CAC5B,SAA2B,EAC3B,OAAqB;QAErB,IAAI,SAAS,CAAC,cAAc,EAAE;YAC5B,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,SAAS,CAAC,cAAc,CAAC,CAAC;SAClD;QACD,IAAI,SAAS,CAAC,gBAAgB,IAAI,SAAS,CAAC,gBAAgB,CAAC,MAAM,EAAE;YACnE,OAAO,CAAC,oBAAoB,CAC1B,CAAC,EACD,SAAS,CAAC,gBAAuB,EACjC,gBAAgB,CAAC,YAAY,CAAC,uBAAuB,CACtD,CAAC;SACH;IACH,CAAC;IAiBD,IAAI,cAAc;QAChB,OAAO,IAAI,CAAC,eAAe,CAAC;IAC9B,CAAC;IACD,IAAI,cAAc,CAAC,KAAyB;QAC1C,IAAI,CAAC,eAAe,GAAG,KAAK,CAAC;IAC/B,CAAC;IACD,IAAI,gBAAgB;QAClB,OAAO,IAAI,CAAC,iBAAiB,CAAC;IAChC,CAAC;IACD,IAAI,gBAAgB,CAAC,KAAkD;QACrE,IAAI,CAAC,iBAAiB,GAAG,KAAK,CAAC;IACjC,CAAC;IAED;;;OAGG;IACH,eAAe;QACb,MAAM,MAAM,GAAG,IAAI,YAAY,EAAE,CAAC;QAClC,gBAAgB,CAAC,uBAAuB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QACvD,OAAO,MAAM,CAAC,eAAe,EAAE,CAAC;IAClC,CAAC;IAED;;OAEG;IACH,QAAQ;QACN,OAAO;YACL,cAAc,EAAE,IAAI,CAAC,cAAc;YACnC,gBAAgB,EAAE,CAAC,IAAI,CAAC,gBAAgB,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC;SACvE,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,MAAM;QACJ,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC;IACzB,CAAC;IAED;;;;OAIG;IACH,cAAc;IACZ,aAAa;IACb,OAA+B;QAE/B,OAAO;YACL,cAAc,EAAE,IAAI,CAAC,cAAc;YACnC,gBAAgB,EAAE,CAAC,IAAI,CAAC,gBAAgB,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CACtD,CAAC,CAAC,cAAc,CAAC,OAAO,CAAC,CAC1B;SACF,CAAC;IACJ,CAAC;;AArJM,mBAAE,GAAG,6BAA6B,CAAC;AAuJ5C,WAAc,gBAAgB;IAiB5B;;OAEG;IACH,MAAa,YAAY;QA6FvB;;;WAGG;QACH,YAAY,MAAgD;YAC1D,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;YACtB,IAAI,CAAC,iBAAiB,GAAG,MAAM,CAAC,iBAAiB;gBAC/C,CAAC,CAAC,IAAI,YAAY,CAAC,MAAM,CAAC,iBAAiB,CAAC;gBAC5C,CAAC,CAAC,SAAS,CAAC;YACd,IAAI,CAAC,oBAAoB,GAAG,CAAC,MAAM,CAAC,oBAAoB,IAAI,EAAE,CAAC,CAAC,GAAG,CACjE,CAAC,CAAC,EAAE,CAAC,IAAI,YAAY,CAAC,CAAC,CAAC,CACzB,CAAC;YACF,YAAY,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;QAClC,CAAC;QAvGD;;;WAGG;QACH,MAAM,CAAC,iBAAiB,CAAC,KAAiB;YACxC,MAAM,QAAQ,GAAG,IAAI,YAAY,EAAE,CAAC;YACpC,YAAY,CAAC,2BAA2B,CACtC,QAAQ,EACR,IAAI,YAAY,CAAC,KAAK,CAAC,CACxB,CAAC;YACF,OAAO,QAAQ,CAAC;QAClB,CAAC;QAED;;;WAGG;QACH,MAAM,CAAC,YAAY,CAAC,SAAuB;YACzC,SAAS,CAAC,iBAAiB,GAAG,SAAS,CAAC,iBAAiB,IAAI,SAAS,CAAC;YACvE,SAAS,CAAC,oBAAoB,GAAG,SAAS,CAAC,oBAAoB,IAAI,EAAE,CAAC;QACxE,CAAC;QAED;;;;WAIG;QACH,MAAM,CAAC,2BAA2B,CAChC,SAAuB,EACvB,OAAqB;YAErB,OAAO,OAAO,CAAC,SAAS,EAAE,EAAE;gBAC1B,IAAI,OAAO,CAAC,UAAU,EAAE;oBAAE,MAAM;gBAEhC,QAAQ,OAAO,CAAC,cAAc,EAAE,EAAE;oBAChC,KAAK,CAAC;wBACJ,SAAS,CAAC,iBAAiB,GAAG,IAAI,YAAY,EAAE,CAAC;wBACjD,OAAO,CAAC,WAAW,CACjB,SAAS,CAAC,iBAAiB,EAC3B,YAAY,CAAC,2BAA2B,CACzC,CAAC;wBACF,MAAM;oBACR,KAAK,CAAC;wBACJ,MAAM,mBAAmB,GAAG,IAAI,YAAY,EAAE,CAAC;wBAC/C,OAAO,CAAC,WAAW,CACjB,mBAAmB,EACnB,YAAY,CAAC,2BAA2B,CACzC,CAAC;wBACF,CAAC,SAAS,CAAC,oBAAoB;4BAC7B,SAAS,CAAC,oBAAoB,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;wBAClE,MAAM;oBACR;wBACE,OAAO,CAAC,SAAS,EAAE,CAAC;iBACvB;aACF;YAED,YAAY,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;QACvC,CAAC;QAED;;;;WAIG;QACH,MAAM,CAAC,uBAAuB,CAC5B,SAAuB,EACvB,OAAqB;YAErB,IAAI,SAAS,CAAC,iBAAiB,EAAE;gBAC/B,OAAO,CAAC,YAAY,CAClB,CAAC,EACD,SAAS,CAAC,iBAAwB,EAClC,YAAY,CAAC,uBAAuB,CACrC,CAAC;aACH;YACD,IACE,SAAS,CAAC,oBAAoB;gBAC9B,SAAS,CAAC,oBAAoB,CAAC,MAAM,EACrC;gBACA,OAAO,CAAC,oBAAoB,CAC1B,CAAC,EACD,SAAS,CAAC,oBAA2B,EACrC,YAAY,CAAC,uBAAuB,CACrC,CAAC;aACH;QACH,CAAC;QAmBD,IAAI,iBAAiB;YACnB,OAAO,IAAI,CAAC,kBAAkB,CAAC;QACjC,CAAC;QACD,IAAI,iBAAiB,CAAC,KAA+B;YACnD,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC;QAClC,CAAC;QACD,IAAI,oBAAoB;YACtB,OAAO,IAAI,CAAC,qBAAqB,CAAC;QACpC,CAAC;QACD,IAAI,oBAAoB,CAAC,KAAiC;YACxD,IAAI,CAAC,qBAAqB,GAAG,KAAK,CAAC;QACrC,CAAC;QAED;;;WAGG;QACH,eAAe;YACb,MAAM,MAAM,GAAG,IAAI,YAAY,EAAE,CAAC;YAClC,YAAY,CAAC,uBAAuB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;YACnD,OAAO,MAAM,CAAC,eAAe,EAAE,CAAC;QAClC,CAAC;QAED;;WAEG;QACH,QAAQ;YACN,OAAO;gBACL,iBAAiB,EAAE,IAAI,CAAC,iBAAiB;oBACvC,CAAC,CAAC,IAAI,CAAC,iBAAiB,CAAC,QAAQ,EAAE;oBACnC,CAAC,CAAC,SAAS;gBACb,oBAAoB,EAAE,CAAC,IAAI,CAAC,oBAAoB,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAC9D,CAAC,CAAC,QAAQ,EAAE,CACb;aACF,CAAC;QACJ,CAAC;QAED;;WAEG;QACH,MAAM;YACJ,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC;QACzB,CAAC;QAED;;;;WAIG;QACH,cAAc;QACZ,aAAa;QACb,OAA+B;YAE/B,OAAO;gBACL,iBAAiB,EAAE,IAAI,CAAC,iBAAiB;oBACvC,CAAC,CAAC,IAAI,CAAC,iBAAiB,CAAC,cAAc,CAAC,OAAO,CAAC;oBAChD,CAAC,CAAC,IAAI;gBACR,oBAAoB,EAAE,CAAC,IAAI,CAAC,oBAAoB,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAC9D,CAAC,CAAC,cAAc,CAAC,OAAO,CAAC,CAC1B;aACF,CAAC;QACJ,CAAC;;IAvKM,eAAE,GAAG,yBAAyB,CAAC;IAD3B,6BAAY,eAyKxB,CAAA;AAkBH,CAAC,EA/Ma,gBAAgB,KAAhB,gBAAgB,QA+M7B;AAED;;GAEG;AACH,MAAM,OAAO,0BAA0B;IAgIrC;;;OAGG;IACH,YAAY,MAA8D;QACxE,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;QACtB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;QAC5B,IAAI,CAAC,YAAY,GAAG,MAAM,CAAC,YAAY,CAAC;QACxC,IAAI,CAAC,iBAAiB,GAAG,MAAM,CAAC,iBAAiB,CAAC;QAClD,IAAI,CAAC,kBAAkB,GAAG,CAAC,MAAM,CAAC,kBAAkB,IAAI,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC;QACpE,IAAI,CAAC,oBAAoB,GAAG,MAAM,CAAC,oBAAoB,CAAC;QACxD,IAAI,CAAC,2BAA2B,GAAG,CACjC,MAAM,CAAC,2BAA2B,IAAI,EAAE,CACzC,CAAC,KAAK,EAAE,CAAC;QACV,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;QAC5B,IAAI,CAAC,eAAe,GAAG,MAAM,CAAC,eAAe,CAAC;QAC9C,0BAA0B,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IAChD,CAAC;IA9ID;;;OAGG;IACH,MAAM,CAAC,iBAAiB,CAAC,KAAiB;QACxC,MAAM,QAAQ,GAAG,IAAI,0BAA0B,EAAE,CAAC;QAClD,0BAA0B,CAAC,2BAA2B,CACpD,QAAQ,EACR,IAAI,YAAY,CAAC,KAAK,CAAC,CACxB,CAAC;QACF,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,YAAY,CAAC,SAAqC;QACvD,SAAS,CAAC,MAAM,GAAG,SAAS,CAAC,MAAM,IAAI,EAAE,CAAC;QAC1C,SAAS,CAAC,YAAY,GAAG,SAAS,CAAC,YAAY,IAAI,EAAE,CAAC;QACtD,SAAS,CAAC,iBAAiB,GAAG,SAAS,CAAC,iBAAiB,IAAI,EAAE,CAAC;QAChE,SAAS,CAAC,kBAAkB,GAAG,SAAS,CAAC,kBAAkB,IAAI,EAAE,CAAC;QAClE,SAAS,CAAC,oBAAoB,GAAG,SAAS,CAAC,oBAAoB,IAAI,CAAC,CAAC;QACrE,SAAS,CAAC,2BAA2B;YACnC,SAAS,CAAC,2BAA2B,IAAI,EAAE,CAAC;QAC9C,SAAS,CAAC,MAAM,GAAG,SAAS,CAAC,MAAM,IAAI,KAAK,CAAC;QAC7C,SAAS,CAAC,eAAe,GAAG,SAAS,CAAC,eAAe,IAAI,CAAC,CAAC;IAC7D,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,2BAA2B,CAChC,SAAqC,EACrC,OAAqB;QAErB,OAAO,OAAO,CAAC,SAAS,EAAE,EAAE;YAC1B,IAAI,OAAO,CAAC,UAAU,EAAE;gBAAE,MAAM;YAEhC,QAAQ,OAAO,CAAC,cAAc,EAAE,EAAE;gBAChC,KAAK,CAAC;oBACJ,SAAS,CAAC,MAAM,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;oBACxC,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,YAAY,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;oBAC9C,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,iBAAiB,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;oBACnD,MAAM;gBACR,KAAK,CAAC;oBACJ,CAAC,SAAS,CAAC,kBAAkB;wBAC3B,SAAS,CAAC,kBAAkB,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC;oBACjE,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,oBAAoB,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;oBACrD,MAAM;gBACR,KAAK,CAAC;oBACJ,CAAC,SAAS,CAAC,2BAA2B;wBACpC,SAAS,CAAC,2BAA2B,IAAI,EAAE,CAAC,CAAC,IAAI,CACjD,OAAO,CAAC,UAAU,EAAE,CACrB,CAAC;oBACF,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,MAAM,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC;oBACtC,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,eAAe,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;oBAChD,MAAM;gBACR;oBACE,OAAO,CAAC,SAAS,EAAE,CAAC;aACvB;SACF;QAED,0BAA0B,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;IACrD,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,uBAAuB,CAC5B,SAAqC,EACrC,OAAqB;QAErB,IAAI,SAAS,CAAC,MAAM,EAAE;YACpB,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;SAC1C;QACD,IAAI,SAAS,CAAC,YAAY,EAAE;YAC1B,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,SAAS,CAAC,YAAY,CAAC,CAAC;SAChD;QACD,IAAI,SAAS,CAAC,iBAAiB,EAAE;YAC/B,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,SAAS,CAAC,iBAAiB,CAAC,CAAC;SACrD;QACD,IAAI,SAAS,CAAC,kBAAkB,IAAI,SAAS,CAAC,kBAAkB,CAAC,MAAM,EAAE;YACvE,OAAO,CAAC,mBAAmB,CAAC,CAAC,EAAE,SAAS,CAAC,kBAAkB,CAAC,CAAC;SAC9D;QACD,IAAI,SAAS,CAAC,oBAAoB,EAAE;YAClC,OAAO,CAAC,UAAU,CAAC,CAAC,EAAE,SAAS,CAAC,oBAAoB,CAAC,CAAC;SACvD;QACD,IACE,SAAS,CAAC,2BAA2B;YACrC,SAAS,CAAC,2BAA2B,CAAC,MAAM,EAC5C;YACA,OAAO,CAAC,mBAAmB,CAAC,CAAC,EAAE,SAAS,CAAC,2BAA2B,CAAC,CAAC;SACvE;QACD,IAAI,SAAS,CAAC,MAAM,EAAE;YACpB,OAAO,CAAC,SAAS,CAAC,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;SACxC;QACD,IAAI,SAAS,CAAC,eAAe,EAAE;YAC7B,OAAO,CAAC,UAAU,CAAC,CAAC,EAAE,SAAS,CAAC,eAAe,CAAC,CAAC;SAClD;IACH,CAAC;IA6BD,IAAI,MAAM;QACR,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IACD,IAAI,MAAM,CAAC,KAAyB;QAClC,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;IACvB,CAAC;IACD,IAAI,YAAY;QACd,OAAO,IAAI,CAAC,aAAa,CAAC;IAC5B,CAAC;IACD,IAAI,YAAY,CAAC,KAAyB;QACxC,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC;IAC7B,CAAC;IACD,IAAI,iBAAiB;QACnB,OAAO,IAAI,CAAC,kBAAkB,CAAC;IACjC,CAAC;IACD,IAAI,iBAAiB,CAAC,KAAyB;QAC7C,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC;IAClC,CAAC;IACD,IAAI,kBAAkB;QACpB,OAAO,IAAI,CAAC,mBAAmB,CAAC;IAClC,CAAC;IACD,IAAI,kBAAkB,CAAC,KAA2B;QAChD,IAAI,CAAC,mBAAmB,GAAG,KAAK,CAAC;IACnC,CAAC;IACD,IAAI,oBAAoB;QACtB,OAAO,IAAI,CAAC,qBAAqB,CAAC;IACpC,CAAC;IACD,IAAI,oBAAoB,CAAC,KAAyB;QAChD,IAAI,CAAC,qBAAqB,GAAG,KAAK,CAAC;IACrC,CAAC;IACD,IAAI,2BAA2B;QAC7B,OAAO,IAAI,CAAC,4BAA4B,CAAC;IAC3C,CAAC;IACD,IAAI,2BAA2B,CAAC,KAA2B;QACzD,IAAI,CAAC,4BAA4B,GAAG,KAAK,CAAC;IAC5C,CAAC;IACD,IAAI,MAAM;QACR,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IACD,IAAI,MAAM,CAAC,KAA0B;QACnC,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;IACvB,CAAC;IACD,IAAI,eAAe;QACjB,OAAO,IAAI,CAAC,gBAAgB,CAAC;IAC/B,CAAC;IACD,IAAI,eAAe,CAAC,KAAyB;QAC3C,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC;IAChC,CAAC;IAED;;;OAGG;IACH,eAAe;QACb,MAAM,MAAM,GAAG,IAAI,YAAY,EAAE,CAAC;QAClC,0BAA0B,CAAC,uBAAuB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QACjE,OAAO,MAAM,CAAC,eAAe,EAAE,CAAC;IAClC,CAAC;IAED;;OAEG;IACH,QAAQ;QACN,OAAO;YACL,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,YAAY,EAAE,IAAI,CAAC,YAAY;YAC/B,iBAAiB,EAAE,IAAI,CAAC,iBAAiB;YACzC,kBAAkB,EAAE,CAAC,IAAI,CAAC,kBAAkB,IAAI,EAAE,CAAC,CAAC,KAAK,EAAE;YAC3D,oBAAoB,EAAE,IAAI,CAAC,oBAAoB;YAC/C,2BAA2B,EAAE,CAC3B,IAAI,CAAC,2BAA2B,IAAI,EAAE,CACvC,CAAC,KAAK,EAAE;YACT,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,eAAe,EAAE,IAAI,CAAC,eAAe;SACtC,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,MAAM;QACJ,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC;IACzB,CAAC;IAED;;;;OAIG;IACH,cAAc;IACZ,aAAa;IACb,OAA+B;QAE/B,OAAO;YACL,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,YAAY,EAAE,IAAI,CAAC,YAAY;YAC/B,iBAAiB,EAAE,IAAI,CAAC,iBAAiB;YACzC,kBAAkB,EAAE,CAAC,IAAI,CAAC,kBAAkB,IAAI,EAAE,CAAC,CAAC,KAAK,EAAE;YAC3D,oBAAoB,EAAE,IAAI,CAAC,oBAAoB;YAC/C,2BAA2B,EAAE,CAC3B,IAAI,CAAC,2BAA2B,IAAI,EAAE,CACvC,CAAC,KAAK,EAAE;YACT,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,eAAe,EAAE,IAAI,CAAC,eAAe;SACtC,CAAC;IACJ,CAAC;;AA1PM,6BAAE,GAAG,uCAAuC,CAAC;AA0RtD;;GAEG;AACH,MAAM,OAAO,2BAA2B;IAgItC;;;OAGG;IACH,YAAY,MAA+D;QACzE,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;QACtB,IAAI,CAAC,kBAAkB,GAAG,CAAC,MAAM,CAAC,kBAAkB,IAAI,EAAE,CAAC,CAAC,GAAG,CAC7D,CAAC,CAAC,EAAE,CAAC,IAAI,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,CACpC,CAAC;QACF,IAAI,CAAC,kBAAkB,GAAG,CAAC,MAAM,CAAC,kBAAkB,IAAI,EAAE,CAAC,CAAC,GAAG,CAC7D,CAAC,CAAC,EAAE,CAAC,IAAI,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,CACpC,CAAC;QACF,IAAI,CAAC,iBAAiB,GAAG,CAAC,MAAM,CAAC,iBAAiB,IAAI,EAAE,CAAC,CAAC,GAAG,CAC3D,CAAC,CAAC,EAAE,CAAC,IAAI,gBAAgB,CAAC,CAAC,CAAC,CAC7B,CAAC;QACF,IAAI,CAAC,mBAAmB,GAAG,CAAC,MAAM,CAAC,mBAAmB,IAAI,EAAE,CAAC,CAAC,GAAG,CAC/D,CAAC,CAAC,EAAE,CAAC,IAAI,gBAAgB,CAAC,CAAC,CAAC,CAC7B,CAAC;QACF,2BAA2B,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IACjD,CAAC;IAhJD;;;OAGG;IACH,MAAM,CAAC,iBAAiB,CAAC,KAAiB;QACxC,MAAM,QAAQ,GAAG,IAAI,2BAA2B,EAAE,CAAC;QACnD,2BAA2B,CAAC,2BAA2B,CACrD,QAAQ,EACR,IAAI,YAAY,CAAC,KAAK,CAAC,CACxB,CAAC;QACF,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,YAAY,CAAC,SAAsC;QACxD,SAAS,CAAC,kBAAkB,GAAG,SAAS,CAAC,kBAAkB,IAAI,EAAE,CAAC;QAClE,SAAS,CAAC,kBAAkB,GAAG,SAAS,CAAC,kBAAkB,IAAI,EAAE,CAAC;QAClE,SAAS,CAAC,iBAAiB,GAAG,SAAS,CAAC,iBAAiB,IAAI,EAAE,CAAC;QAChE,SAAS,CAAC,mBAAmB,GAAG,SAAS,CAAC,mBAAmB,IAAI,EAAE,CAAC;IACtE,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,2BAA2B,CAChC,SAAsC,EACtC,OAAqB;QAErB,OAAO,OAAO,CAAC,SAAS,EAAE,EAAE;YAC1B,IAAI,OAAO,CAAC,UAAU,EAAE;gBAAE,MAAM;YAEhC,QAAQ,OAAO,CAAC,cAAc,EAAE,EAAE;gBAChC,KAAK,CAAC;oBACJ,MAAM,mBAAmB,GAAG,IAAI,YAAY,CAAC,UAAU,EAAE,CAAC;oBAC1D,OAAO,CAAC,WAAW,CACjB,mBAAmB,EACnB,YAAY,CAAC,UAAU,CAAC,2BAA2B,CACpD,CAAC;oBACF,CAAC,SAAS,CAAC,kBAAkB;wBAC3B,SAAS,CAAC,kBAAkB,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;oBAChE,MAAM;gBACR,KAAK,CAAC;oBACJ,MAAM,mBAAmB,GAAG,IAAI,YAAY,CAAC,UAAU,EAAE,CAAC;oBAC1D,OAAO,CAAC,WAAW,CACjB,mBAAmB,EACnB,YAAY,CAAC,UAAU,CAAC,2BAA2B,CACpD,CAAC;oBACF,CAAC,SAAS,CAAC,kBAAkB;wBAC3B,SAAS,CAAC,kBAAkB,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;oBAChE,MAAM;gBACR,KAAK,CAAC;oBACJ,MAAM,mBAAmB,GAAG,IAAI,gBAAgB,EAAE,CAAC;oBACnD,OAAO,CAAC,WAAW,CACjB,mBAAmB,EACnB,gBAAgB,CAAC,2BAA2B,CAC7C,CAAC;oBACF,CAAC,SAAS,CAAC,iBAAiB;wBAC1B,SAAS,CAAC,iBAAiB,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;oBAC/D,MAAM;gBACR,KAAK,CAAC;oBACJ,MAAM,mBAAmB,GAAG,IAAI,gBAAgB,EAAE,CAAC;oBACnD,OAAO,CAAC,WAAW,CACjB,mBAAmB,EACnB,gBAAgB,CAAC,2BAA2B,CAC7C,CAAC;oBACF,CAAC,SAAS,CAAC,mBAAmB;wBAC5B,SAAS,CAAC,mBAAmB,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;oBACjE,MAAM;gBACR;oBACE,OAAO,CAAC,SAAS,EAAE,CAAC;aACvB;SACF;QAED,2BAA2B,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;IACtD,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,uBAAuB,CAC5B,SAAsC,EACtC,OAAqB;QAErB,IAAI,SAAS,CAAC,kBAAkB,IAAI,SAAS,CAAC,kBAAkB,CAAC,MAAM,EAAE;YACvE,OAAO,CAAC,oBAAoB,CAC1B,CAAC,EACD,SAAS,CAAC,kBAAyB,EACnC,YAAY,CAAC,UAAU,CAAC,uBAAuB,CAChD,CAAC;SACH;QACD,IAAI,SAAS,CAAC,kBAAkB,IAAI,SAAS,CAAC,kBAAkB,CAAC,MAAM,EAAE;YACvE,OAAO,CAAC,oBAAoB,CAC1B,CAAC,EACD,SAAS,CAAC,kBAAyB,EACnC,YAAY,CAAC,UAAU,CAAC,uBAAuB,CAChD,CAAC;SACH;QACD,IAAI,SAAS,CAAC,iBAAiB,IAAI,SAAS,CAAC,iBAAiB,CAAC,MAAM,EAAE;YACrE,OAAO,CAAC,oBAAoB,CAC1B,CAAC,EACD,SAAS,CAAC,iBAAwB,EAClC,gBAAgB,CAAC,uBAAuB,CACzC,CAAC;SACH;QACD,IAAI,SAAS,CAAC,mBAAmB,IAAI,SAAS,CAAC,mBAAmB,CAAC,MAAM,EAAE;YACzE,OAAO,CAAC,oBAAoB,CAC1B,CAAC,EACD,SAAS,CAAC,mBAA0B,EACpC,gBAAgB,CAAC,uBAAuB,CACzC,CAAC;SACH;IACH,CAAC;IA2BD,IAAI,kBAAkB;QACpB,OAAO,IAAI,CAAC,mBAAmB,CAAC;IAClC,CAAC;IACD,IAAI,kBAAkB,CAAC,KAA4C;QACjE,IAAI,CAAC,mBAAmB,GAAG,KAAK,CAAC;IACnC,CAAC;IACD,IAAI,kBAAkB;QACpB,OAAO,IAAI,CAAC,mBAAmB,CAAC;IAClC,CAAC;IACD,IAAI,kBAAkB,CAAC,KAA4C;QACjE,IAAI,CAAC,mBAAmB,GAAG,KAAK,CAAC;IACnC,CAAC;IACD,IAAI,iBAAiB;QACnB,OAAO,IAAI,CAAC,kBAAkB,CAAC;IACjC,CAAC;IACD,IAAI,iBAAiB,CAAC,KAAqC;QACzD,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC;IAClC,CAAC;IACD,IAAI,mBAAmB;QACrB,OAAO,IAAI,CAAC,oBAAoB,CAAC;IACnC,CAAC;IACD,IAAI,mBAAmB,CAAC,KAAqC;QAC3D,IAAI,CAAC,oBAAoB,GAAG,KAAK,CAAC;IACpC,CAAC;IAED;;;OAGG;IACH,eAAe;QACb,MAAM,MAAM,GAAG,IAAI,YAAY,EAAE,CAAC;QAClC,2BAA2B,CAAC,uBAAuB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QAClE,OAAO,MAAM,CAAC,eAAe,EAAE,CAAC;IAClC,CAAC;IAED;;OAEG;IACH,QAAQ;QACN,OAAO;YACL,kBAAkB,EAAE,CAAC,IAAI,CAAC,kBAAkB,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAC1D,CAAC,CAAC,QAAQ,EAAE,CACb;YACD,kBAAkB,EAAE,CAAC,IAAI,CAAC,kBAAkB,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAC1D,CAAC,CAAC,QAAQ,EAAE,CACb;YACD,iBAAiB,EAAE,CAAC,IAAI,CAAC,iBAAiB,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC;YACxE,mBAAmB,EAAE,CAAC,IAAI,CAAC,mBAAmB,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAC5D,CAAC,CAAC,QAAQ,EAAE,CACb;SACF,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,MAAM;QACJ,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC;IACzB,CAAC;IAED;;;;OAIG;IACH,cAAc;IACZ,aAAa;IACb,OAA+B;QAE/B,OAAO;YACL,kBAAkB,EAAE,CAAC,IAAI,CAAC,kBAAkB,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAC1D,CAAC,CAAC,cAAc,CAAC,OAAO,CAAC,CAC1B;YACD,kBAAkB,EAAE,CAAC,IAAI,CAAC,kBAAkB,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAC1D,CAAC,CAAC,cAAc,CAAC,OAAO,CAAC,CAC1B;YACD,iBAAiB,EAAE,CAAC,IAAI,CAAC,iBAAiB,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CACxD,CAAC,CAAC,cAAc,CAAC,OAAO,CAAC,CAC1B;YACD,mBAAmB,EAAE,CAAC,IAAI,CAAC,mBAAmB,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAC5D,CAAC,CAAC,cAAc,CAAC,OAAO,CAAC,CAC1B;SACF,CAAC;IACJ,CAAC;;AAtOM,8BAAE,GAAG,wCAAwC,CAAC;AA8PvD;;GAEG;AACH,MAAM,OAAO,sBAAsB;IAiHjC;;;OAGG;IACH,YAAY,MAA0D;QACpE,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;QACtB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;QAC5B,IAAI,CAAC,cAAc,GAAG,MAAM,CAAC,cAAc,CAAC;QAC5C,IAAI,CAAC,YAAY,GAAG,MAAM,CAAC,YAAY,CAAC;QACxC,IAAI,CAAC,iBAAiB,GAAG,MAAM,CAAC,iBAAiB,CAAC;QAClD,IAAI,CAAC,kBAAkB,GAAG,CAAC,MAAM,CAAC,kBAAkB,IAAI,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC;QACpE,IAAI,CAAC,oBAAoB,GAAG,MAAM,CAAC,oBAAoB,CAAC;QACxD,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;QAC5B,sBAAsB,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IAC5C,CAAC;IA5HD;;;OAGG;IACH,MAAM,CAAC,iBAAiB,CAAC,KAAiB;QACxC,MAAM,QAAQ,GAAG,IAAI,sBAAsB,EAAE,CAAC;QAC9C,sBAAsB,CAAC,2BAA2B,CAChD,QAAQ,EACR,IAAI,YAAY,CAAC,KAAK,CAAC,CACxB,CAAC;QACF,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,YAAY,CAAC,SAAiC;QACnD,SAAS,CAAC,MAAM,GAAG,SAAS,CAAC,MAAM,IAAI,EAAE,CAAC;QAC1C,SAAS,CAAC,cAAc,GAAG,SAAS,CAAC,cAAc,IAAI,EAAE,CAAC;QAC1D,SAAS,CAAC,YAAY,GAAG,SAAS,CAAC,YAAY,IAAI,EAAE,CAAC;QACtD,SAAS,CAAC,iBAAiB,GAAG,SAAS,CAAC,iBAAiB,IAAI,EAAE,CAAC;QAChE,SAAS,CAAC,kBAAkB,GAAG,SAAS,CAAC,kBAAkB,IAAI,EAAE,CAAC;QAClE,SAAS,CAAC,oBAAoB,GAAG,SAAS,CAAC,oBAAoB,IAAI,CAAC,CAAC;QACrE,SAAS,CAAC,MAAM,GAAG,SAAS,CAAC,MAAM,IAAI,KAAK,CAAC;IAC/C,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,2BAA2B,CAChC,SAAiC,EACjC,OAAqB;QAErB,OAAO,OAAO,CAAC,SAAS,EAAE,EAAE;YAC1B,IAAI,OAAO,CAAC,UAAU,EAAE;gBAAE,MAAM;YAEhC,QAAQ,OAAO,CAAC,cAAc,EAAE,EAAE;gBAChC,KAAK,CAAC;oBACJ,SAAS,CAAC,MAAM,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;oBACxC,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,cAAc,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;oBAChD,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,YAAY,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;oBAC9C,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,iBAAiB,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;oBACnD,MAAM;gBACR,KAAK,CAAC;oBACJ,CAAC,SAAS,CAAC,kBAAkB;wBAC3B,SAAS,CAAC,kBAAkB,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC;oBACjE,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,oBAAoB,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;oBACrD,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,MAAM,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC;oBACtC,MAAM;gBACR;oBACE,OAAO,CAAC,SAAS,EAAE,CAAC;aACvB;SACF;QAED,sBAAsB,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;IACjD,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,uBAAuB,CAC5B,SAAiC,EACjC,OAAqB;QAErB,IAAI,SAAS,CAAC,MAAM,EAAE;YACpB,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;SAC1C;QACD,IAAI,SAAS,CAAC,cAAc,EAAE;YAC5B,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,SAAS,CAAC,cAAc,CAAC,CAAC;SAClD;QACD,IAAI,SAAS,CAAC,YAAY,EAAE;YAC1B,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,SAAS,CAAC,YAAY,CAAC,CAAC;SAChD;QACD,IAAI,SAAS,CAAC,iBAAiB,EAAE;YAC/B,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,SAAS,CAAC,iBAAiB,CAAC,CAAC;SACrD;QACD,IAAI,SAAS,CAAC,kBAAkB,IAAI,SAAS,CAAC,kBAAkB,CAAC,MAAM,EAAE;YACvE,OAAO,CAAC,mBAAmB,CAAC,CAAC,EAAE,SAAS,CAAC,kBAAkB,CAAC,CAAC;SAC9D;QACD,IAAI,SAAS,CAAC,oBAAoB,EAAE;YAClC,OAAO,CAAC,UAAU,CAAC,CAAC,EAAE,SAAS,CAAC,oBAAoB,CAAC,CAAC;SACvD;QACD,IAAI,SAAS,CAAC,MAAM,EAAE;YACpB,OAAO,CAAC,SAAS,CAAC,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;SACxC;IACH,CAAC;IAyBD,IAAI,MAAM;QACR,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IACD,IAAI,MAAM,CAAC,KAAyB;QAClC,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;IACvB,CAAC;IACD,IAAI,cAAc;QAChB,OAAO,IAAI,CAAC,eAAe,CAAC;IAC9B,CAAC;IACD,IAAI,cAAc,CAAC,KAAyB;QAC1C,IAAI,CAAC,eAAe,GAAG,KAAK,CAAC;IAC/B,CAAC;IACD,IAAI,YAAY;QACd,OAAO,IAAI,CAAC,aAAa,CAAC;IAC5B,CAAC;IACD,IAAI,YAAY,CAAC,KAAyB;QACxC,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC;IAC7B,CAAC;IACD,IAAI,iBAAiB;QACnB,OAAO,IAAI,CAAC,kBAAkB,CAAC;IACjC,CAAC;IACD,IAAI,iBAAiB,CAAC,KAAyB;QAC7C,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC;IAClC,CAAC;IACD,IAAI,kBAAkB;QACpB,OAAO,IAAI,CAAC,mBAAmB,CAAC;IAClC,CAAC;IACD,IAAI,kBAAkB,CAAC,KAA2B;QAChD,IAAI,CAAC,mBAAmB,GAAG,KAAK,CAAC;IACnC,CAAC;IACD,IAAI,oBAAoB;QACtB,OAAO,IAAI,CAAC,qBAAqB,CAAC;IACpC,CAAC;IACD,IAAI,oBAAoB,CAAC,KAAyB;QAChD,IAAI,CAAC,qBAAqB,GAAG,KAAK,CAAC;IACrC,CAAC;IACD,IAAI,MAAM;QACR,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IACD,IAAI,MAAM,CAAC,KAA0B;QACnC,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;IACvB,CAAC;IAED;;;OAGG;IACH,eAAe;QACb,MAAM,MAAM,GAAG,IAAI,YAAY,EAAE,CAAC;QAClC,sBAAsB,CAAC,uBAAuB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QAC7D,OAAO,MAAM,CAAC,eAAe,EAAE,CAAC;IAClC,CAAC;IAED;;OAEG;IACH,QAAQ;QACN,OAAO;YACL,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,cAAc,EAAE,IAAI,CAAC,cAAc;YACnC,YAAY,EAAE,IAAI,CAAC,YAAY;YAC/B,iBAAiB,EAAE,IAAI,CAAC,iBAAiB;YACzC,kBAAkB,EAAE,CAAC,IAAI,CAAC,kBAAkB,IAAI,EAAE,CAAC,CAAC,KAAK,EAAE;YAC3D,oBAAoB,EAAE,IAAI,CAAC,oBAAoB;YAC/C,MAAM,EAAE,IAAI,CAAC,MAAM;SACpB,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,MAAM;QACJ,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC;IACzB,CAAC;IAED;;;;OAIG;IACH,cAAc;IACZ,aAAa;IACb,OAA+B;QAE/B,OAAO;YACL,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,cAAc,EAAE,IAAI,CAAC,cAAc;YACnC,YAAY,EAAE,IAAI,CAAC,YAAY;YAC/B,iBAAiB,EAAE,IAAI,CAAC,iBAAiB;YACzC,kBAAkB,EAAE,CAAC,IAAI,CAAC,kBAAkB,IAAI,EAAE,CAAC,CAAC,KAAK,EAAE;YAC3D,oBAAoB,EAAE,IAAI,CAAC,oBAAoB;YAC/C,MAAM,EAAE,IAAI,CAAC,MAAM;SACpB,CAAC;IACJ,CAAC;;AA5NM,yBAAE,GAAG,mCAAmC,CAAC;AA0PlD;;GAEG;AACH,MAAM,OAAO,uBAAuB;IAwFlC;;;OAGG;IACH,YAAY,MAA2D;QACrE,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;QACtB,IAAI,CAAC,iBAAiB,GAAG,MAAM,CAAC,iBAAiB;YAC/C,CAAC,CAAC,IAAI,YAAY,CAAC,UAAU,CAAC,MAAM,CAAC,iBAAiB,CAAC;YACvD,CAAC,CAAC,SAAS,CAAC;QACd,IAAI,CAAC,gBAAgB,GAAG,MAAM,CAAC,gBAAgB;YAC7C,CAAC,CAAC,IAAI,gBAAgB,CAAC,MAAM,CAAC,gBAAgB,CAAC;YAC/C,CAAC,CAAC,SAAS,CAAC;QACd,uBAAuB,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IAC7C,CAAC;IAlGD;;;OAGG;IACH,MAAM,CAAC,iBAAiB,CAAC,KAAiB;QACxC,MAAM,QAAQ,GAAG,IAAI,uBAAuB,EAAE,CAAC;QAC/C,uBAAuB,CAAC,2BAA2B,CACjD,QAAQ,EACR,IAAI,YAAY,CAAC,KAAK,CAAC,CACxB,CAAC;QACF,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,YAAY,CAAC,SAAkC;QACpD,SAAS,CAAC,iBAAiB,GAAG,SAAS,CAAC,iBAAiB,IAAI,SAAS,CAAC;QACvE,SAAS,CAAC,gBAAgB,GAAG,SAAS,CAAC,gBAAgB,IAAI,SAAS,CAAC;IACvE,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,2BAA2B,CAChC,SAAkC,EAClC,OAAqB;QAErB,OAAO,OAAO,CAAC,SAAS,EAAE,EAAE;YAC1B,IAAI,OAAO,CAAC,UAAU,EAAE;gBAAE,MAAM;YAEhC,QAAQ,OAAO,CAAC,cAAc,EAAE,EAAE;gBAChC,KAAK,CAAC;oBACJ,SAAS,CAAC,iBAAiB,GAAG,IAAI,YAAY,CAAC,UAAU,EAAE,CAAC;oBAC5D,OAAO,CAAC,WAAW,CACjB,SAAS,CAAC,iBAAiB,EAC3B,YAAY,CAAC,UAAU,CAAC,2BAA2B,CACpD,CAAC;oBACF,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,gBAAgB,GAAG,IAAI,gBAAgB,EAAE,CAAC;oBACpD,OAAO,CAAC,WAAW,CACjB,SAAS,CAAC,gBAAgB,EAC1B,gBAAgB,CAAC,2BAA2B,CAC7C,CAAC;oBACF,MAAM;gBACR;oBACE,OAAO,CAAC,SAAS,EAAE,CAAC;aACvB;SACF;QAED,uBAAuB,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;IAClD,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,uBAAuB,CAC5B,SAAkC,EAClC,OAAqB;QAErB,IAAI,SAAS,CAAC,iBAAiB,EAAE;YAC/B,OAAO,CAAC,YAAY,CAClB,CAAC,EACD,SAAS,CAAC,iBAAwB,EAClC,YAAY,CAAC,UAAU,CAAC,uBAAuB,CAChD,CAAC;SACH;QACD,IAAI,SAAS,CAAC,gBAAgB,EAAE;YAC9B,OAAO,CAAC,YAAY,CAClB,CAAC,EACD,SAAS,CAAC,gBAAuB,EACjC,gBAAgB,CAAC,uBAAuB,CACzC,CAAC;SACH;IACH,CAAC;IAmBD,IAAI,iBAAiB;QACnB,OAAO,IAAI,CAAC,kBAAkB,CAAC;IACjC,CAAC;IACD,IAAI,iBAAiB,CAAC,KAA0C;QAC9D,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC;IAClC,CAAC;IACD,IAAI,gBAAgB;QAClB,OAAO,IAAI,CAAC,iBAAiB,CAAC;IAChC,CAAC;IACD,IAAI,gBAAgB,CAAC,KAAmC;QACtD,IAAI,CAAC,iBAAiB,GAAG,KAAK,CAAC;IACjC,CAAC;IAED;;;OAGG;IACH,eAAe;QACb,MAAM,MAAM,GAAG,IAAI,YAAY,EAAE,CAAC;QAClC,uBAAuB,CAAC,uBAAuB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QAC9D,OAAO,MAAM,CAAC,eAAe,EAAE,CAAC;IAClC,CAAC;IAED;;OAEG;IACH,QAAQ;QACN,OAAO;YACL,iBAAiB,EAAE,IAAI,CAAC,iBAAiB;gBACvC,CAAC,CAAC,IAAI,CAAC,iBAAiB,CAAC,QAAQ,EAAE;gBACnC,CAAC,CAAC,SAAS;YACb,gBAAgB,EAAE,IAAI,CAAC,gBAAgB;gBACrC,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,QAAQ,EAAE;gBAClC,CAAC,CAAC,SAAS;SACd,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,MAAM;QACJ,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC;IACzB,CAAC;IAED;;;;OAIG;IACH,cAAc;IACZ,aAAa;IACb,OAA+B;QAE/B,OAAO;YACL,iBAAiB,EAAE,IAAI,CAAC,iBAAiB;gBACvC,CAAC,CAAC,IAAI,CAAC,iBAAiB,CAAC,cAAc,CAAC,OAAO,CAAC;gBAChD,CAAC,CAAC,IAAI;YACR,gBAAgB,EAAE,IAAI,CAAC,gBAAgB;gBACrC,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,cAAc,CAAC,OAAO,CAAC;gBAC/C,CAAC,CAAC,IAAI;SACT,CAAC;IACJ,CAAC;;AAlKM,0BAAE,GAAG,oCAAoC,CAAC;AAsLnD;;GAEG;AACH,MAAM,OAAO,yBAAyB;IAqIpC;;;OAGG;IACH,YAAY,MAA6D;QACvE,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;QACtB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;QAC5B,IAAI,CAAC,YAAY,GAAG,MAAM,CAAC,YAAY,CAAC;QACxC,IAAI,CAAC,kBAAkB,GAAG,CAAC,MAAM,CAAC,kBAAkB,IAAI,EAAE,CAAC,CAAC,GAAG,CAC7D,CAAC,CAAC,EAAE,CAAC,IAAI,yBAAyB,CAAC,uBAAuB,CAAC,CAAC,CAAC,CAC9D,CAAC;QACF,IAAI,CAAC,eAAe,GAAG,MAAM,CAAC,eAAe,CAAC;QAC9C,IAAI,CAAC,iBAAiB,GAAG,MAAM,CAAC,iBAAiB,CAAC;QAClD,IAAI,CAAC,4BAA4B,GAAG,MAAM,CAAC,4BAA4B;YACrE,CAAC,CAAC,IAAI,4BAA4B,CAAC,MAAM,CAAC,4BAA4B,CAAC;YACvE,CAAC,CAAC,SAAS,CAAC;QACd,IAAI,CAAC,eAAe,GAAG,MAAM,CAAC,eAAe,CAAC;QAC9C,yBAAyB,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IAC/C,CAAC;IApJD;;;OAGG;IACH,MAAM,CAAC,iBAAiB,CAAC,KAAiB;QACxC,MAAM,QAAQ,GAAG,IAAI,yBAAyB,EAAE,CAAC;QACjD,yBAAyB,CAAC,2BAA2B,CACnD,QAAQ,EACR,IAAI,YAAY,CAAC,KAAK,CAAC,CACxB,CAAC;QACF,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,YAAY,CAAC,SAAoC;QACtD,SAAS,CAAC,MAAM,GAAG,SAAS,CAAC,MAAM,IAAI,EAAE,CAAC;QAC1C,SAAS,CAAC,YAAY,GAAG,SAAS,CAAC,YAAY,IAAI,EAAE,CAAC;QACtD,SAAS,CAAC,kBAAkB,GAAG,SAAS,CAAC,kBAAkB,IAAI,EAAE,CAAC;QAClE,SAAS,CAAC,eAAe,GAAG,SAAS,CAAC,eAAe,IAAI,KAAK,CAAC;QAC/D,SAAS,CAAC,iBAAiB,GAAG,SAAS,CAAC,iBAAiB,IAAI,EAAE,CAAC;QAChE,SAAS,CAAC,4BAA4B;YACpC,SAAS,CAAC,4BAA4B,IAAI,SAAS,CAAC;QACtD,SAAS,CAAC,eAAe,GAAG,SAAS,CAAC,eAAe,IAAI,CAAC,CAAC;IAC7D,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,2BAA2B,CAChC,SAAoC,EACpC,OAAqB;QAErB,OAAO,OAAO,CAAC,SAAS,EAAE,EAAE;YAC1B,IAAI,OAAO,CAAC,UAAU,EAAE;gBAAE,MAAM;YAEhC,QAAQ,OAAO,CAAC,cAAc,EAAE,EAAE;gBAChC,KAAK,CAAC;oBACJ,SAAS,CAAC,MAAM,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;oBACxC,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,YAAY,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;oBAC9C,MAAM;gBACR,KAAK,CAAC;oBACJ,MAAM,mBAAmB,GAAG,IAAI,yBAAyB,CAAC,uBAAuB,EAAE,CAAC;oBACpF,OAAO,CAAC,WAAW,CACjB,mBAAmB,EACnB,yBAAyB,CAAC,uBAAuB;yBAC9C,2BAA2B,CAC/B,CAAC;oBACF,CAAC,SAAS,CAAC,kBAAkB;wBAC3B,SAAS,CAAC,kBAAkB,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;oBAChE,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,eAAe,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC;oBAC/C,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,iBAAiB,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;oBACnD,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,4BAA4B,GAAG,IAAI,4BAA4B,EAAE,CAAC;oBAC5E,OAAO,CAAC,WAAW,CACjB,SAAS,CAAC,4BAA4B,EACtC,4BAA4B,CAAC,2BAA2B,CACzD,CAAC;oBACF,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,eAAe,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;oBAChD,MAAM;gBACR;oBACE,OAAO,CAAC,SAAS,EAAE,CAAC;aACvB;SACF;QAED,yBAAyB,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;IACpD,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,uBAAuB,CAC5B,SAAoC,EACpC,OAAqB;QAErB,IAAI,SAAS,CAAC,MAAM,EAAE;YACpB,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;SAC1C;QACD,IAAI,SAAS,CAAC,YAAY,EAAE;YAC1B,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,SAAS,CAAC,YAAY,CAAC,CAAC;SAChD;QACD,IAAI,SAAS,CAAC,kBAAkB,IAAI,SAAS,CAAC,kBAAkB,CAAC,MAAM,EAAE;YACvE,OAAO,CAAC,oBAAoB,CAC1B,CAAC,EACD,SAAS,CAAC,kBAAyB,EACnC,yBAAyB,CAAC,uBAAuB;iBAC9C,uBAAuB,CAC3B,CAAC;SACH;QACD,IAAI,SAAS,CAAC,eAAe,EAAE;YAC7B,OAAO,CAAC,SAAS,CAAC,CAAC,EAAE,SAAS,CAAC,eAAe,CAAC,CAAC;SACjD;QACD,IAAI,SAAS,CAAC,iBAAiB,EAAE;YAC/B,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,SAAS,CAAC,iBAAiB,CAAC,CAAC;SACrD;QACD,IAAI,SAAS,CAAC,4BAA4B,EAAE;YAC1C,OAAO,CAAC,YAAY,CAClB,CAAC,EACD,SAAS,CAAC,4BAAmC,EAC7C,4BAA4B,CAAC,uBAAuB,CACrD,CAAC;SACH;QACD,IAAI,SAAS,CAAC,eAAe,EAAE;YAC7B,OAAO,CAAC,UAAU,CAAC,CAAC,EAAE,SAAS,CAAC,eAAe,CAAC,CAAC;SAClD;IACH,CAAC;IA6BD,IAAI,MAAM;QACR,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IACD,IAAI,MAAM,CAAC,KAAyB;QAClC,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;IACvB,CAAC;IACD,IAAI,YAAY;QACd,OAAO,IAAI,CAAC,aAAa,CAAC;IAC5B,CAAC;IACD,IAAI,YAAY,CAAC,KAAyB;QACxC,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC;IAC7B,CAAC;IACD,IAAI,kBAAkB;QAGpB,OAAO,IAAI,CAAC,mBAAmB,CAAC;IAClC,CAAC;IACD,IAAI,kBAAkB,CACpB,KAAsE;QAEtE,IAAI,CAAC,mBAAmB,GAAG,KAAK,CAAC;IACnC,CAAC;IACD,IAAI,eAAe;QACjB,OAAO,IAAI,CAAC,gBAAgB,CAAC;IAC/B,CAAC;IACD,IAAI,eAAe,CAAC,KAA0B;QAC5C,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC;IAChC,CAAC;IACD,IAAI,iBAAiB;QACnB,OAAO,IAAI,CAAC,kBAAkB,CAAC;IACjC,CAAC;IACD,IAAI,iBAAiB,CAAC,KAAyB;QAC7C,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC;IAClC,CAAC;IACD,IAAI,4BAA4B;QAC9B,OAAO,IAAI,CAAC,6BAA6B,CAAC;IAC5C,CAAC;IACD,IAAI,4BAA4B,CAC9B,KAA+C;QAE/C,IAAI,CAAC,6BAA6B,GAAG,KAAK,CAAC;IAC7C,CAAC;IACD,IAAI,eAAe;QACjB,OAAO,IAAI,CAAC,gBAAgB,CAAC;IAC/B,CAAC;IACD,IAAI,eAAe,CAAC,KAAyB;QAC3C,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC;IAChC,CAAC;IAED;;;OAGG;IACH,eAAe;QACb,MAAM,MAAM,GAAG,IAAI,YAAY,EAAE,CAAC;QAClC,yBAAyB,CAAC,uBAAuB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QAChE,OAAO,MAAM,CAAC,eAAe,EAAE,CAAC;IAClC,CAAC;IAED;;OAEG;IACH,QAAQ;QACN,OAAO;YACL,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,YAAY,EAAE,IAAI,CAAC,YAAY;YAC/B,kBAAkB,EAAE,CAAC,IAAI,CAAC,kBAAkB,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAC1D,CAAC,CAAC,QAAQ,EAAE,CACb;YACD,eAAe,EAAE,IAAI,CAAC,eAAe;YACrC,iBAAiB,EAAE,IAAI,CAAC,iBAAiB;YACzC,4BAA4B,EAAE,IAAI,CAAC,4BAA4B;gBAC7D,CAAC,CAAC,IAAI,CAAC,4BAA4B,CAAC,QAAQ,EAAE;gBAC9C,CAAC,CAAC,SAAS;YACb,eAAe,EAAE,IAAI,CAAC,eAAe;SACtC,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,MAAM;QACJ,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC;IACzB,CAAC;IAED;;;;OAIG;IACH,cAAc;IACZ,aAAa;IACb,OAA+B;QAE/B,OAAO;YACL,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,YAAY,EAAE,IAAI,CAAC,YAAY;YAC/B,kBAAkB,EAAE,CAAC,IAAI,CAAC,kBAAkB,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAC1D,CAAC,CAAC,cAAc,CAAC,OAAO,CAAC,CAC1B;YACD,eAAe,EAAE,IAAI,CAAC,eAAe;YACrC,iBAAiB,EAAE,IAAI,CAAC,iBAAiB;YACzC,4BAA4B,EAAE,IAAI,CAAC,4BAA4B;gBAC7D,CAAC,CAAC,IAAI,CAAC,4BAA4B,CAAC,cAAc,CAAC,OAAO,CAAC;gBAC3D,CAAC,CAAC,IAAI;YACR,eAAe,EAAE,IAAI,CAAC,eAAe;SACtC,CAAC;IACJ,CAAC;;AAlQM,4BAAE,GAAG,sCAAsC,CAAC;AAoQrD,WAAc,yBAAyB;IA6BrC;;OAEG;IACH,MAAa,uBAAuB;QA4FlC;;;WAGG;QACH,YAAY,MAA2D;YACrE,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;YACtB,IAAI,CAAC,cAAc,GAAG,MAAM,CAAC,cAAc,CAAC;YAC5C,IAAI,CAAC,iBAAiB,GAAG,MAAM,CAAC,iBAAiB,CAAC;YAClD,IAAI,CAAC,QAAQ,GAAG,CAAC,MAAM,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAC,GAAG,CACzC,CAAC,CAAC,EAAE,CAAC,IAAI,YAAY,CAAC,MAAM,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,CAAC,CACtD,CAAC;YACF,uBAAuB,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;QAC7C,CAAC;QArGD;;;WAGG;QACH,MAAM,CAAC,iBAAiB,CAAC,KAAiB;YACxC,MAAM,QAAQ,GAAG,IAAI,uBAAuB,EAAE,CAAC;YAC/C,uBAAuB,CAAC,2BAA2B,CACjD,QAAQ,EACR,IAAI,YAAY,CAAC,KAAK,CAAC,CACxB,CAAC;YACF,OAAO,QAAQ,CAAC;QAClB,CAAC;QAED;;;WAGG;QACH,MAAM,CAAC,YAAY,CAAC,SAAkC;YACpD,SAAS,CAAC,cAAc,GAAG,SAAS,CAAC,cAAc,IAAI,EAAE,CAAC;YAC1D,SAAS,CAAC,iBAAiB,GAAG,SAAS,CAAC,iBAAiB,IAAI,EAAE,CAAC;YAChE,SAAS,CAAC,QAAQ,GAAG,SAAS,CAAC,QAAQ,IAAI,EAAE,CAAC;QAChD,CAAC;QAED;;;;WAIG;QACH,MAAM,CAAC,2BAA2B,CAChC,SAAkC,EAClC,OAAqB;YAErB,OAAO,OAAO,CAAC,SAAS,EAAE,EAAE;gBAC1B,IAAI,OAAO,CAAC,UAAU,EAAE;oBAAE,MAAM;gBAEhC,QAAQ,OAAO,CAAC,cAAc,EAAE,EAAE;oBAChC,KAAK,CAAC;wBACJ,SAAS,CAAC,cAAc,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;wBAChD,MAAM;oBACR,KAAK,CAAC;wBACJ,SAAS,CAAC,iBAAiB,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;wBACnD,MAAM;oBACR,KAAK,CAAC;wBACJ,MAAM,mBAAmB,GAAG,IAAI,YAAY,CAAC,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,CAAC;wBAC5E,OAAO,CAAC,WAAW,CACjB,mBAAmB,EACnB,YAAY,CAAC,MAAM,CAAC,cAAc,CAAC,MAAM;6BACtC,2BAA2B,CAC/B,CAAC;wBACF,CAAC,SAAS,CAAC,QAAQ,GAAG,SAAS,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAC,IAAI,CAClD,mBAAmB,CACpB,CAAC;wBACF,MAAM;oBACR;wBACE,OAAO,CAAC,SAAS,EAAE,CAAC;iBACvB;aACF;YAED,uBAAuB,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;QAClD,CAAC;QAED;;;;WAIG;QACH,MAAM,CAAC,uBAAuB,CAC5B,SAAkC,EAClC,OAAqB;YAErB,IAAI,SAAS,CAAC,cAAc,EAAE;gBAC5B,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,SAAS,CAAC,cAAc,CAAC,CAAC;aAClD;YACD,IAAI,SAAS,CAAC,iBAAiB,EAAE;gBAC/B,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,SAAS,CAAC,iBAAiB,CAAC,CAAC;aACrD;YACD,IAAI,SAAS,CAAC,QAAQ,IAAI,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE;gBACnD,OAAO,CAAC,oBAAoB,CAC1B,CAAC,EACD,SAAS,CAAC,QAAe,EACzB,YAAY,CAAC,MAAM,CAAC,cAAc,CAAC,MAAM,CAAC,uBAAuB,CAClE,CAAC;aACH;QACH,CAAC;QAmBD,IAAI,cAAc;YAChB,OAAO,IAAI,CAAC,eAAe,CAAC;QAC9B,CAAC;QACD,IAAI,cAAc,CAAC,KAAyB;YAC1C,IAAI,CAAC,eAAe,GAAG,KAAK,CAAC;QAC/B,CAAC;QACD,IAAI,iBAAiB;YACnB,OAAO,IAAI,CAAC,kBAAkB,CAAC;QACjC,CAAC;QACD,IAAI,iBAAiB,CAAC,KAAyB;YAC7C,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC;QAClC,CAAC;QACD,IAAI,QAAQ;YACV,OAAO,IAAI,CAAC,SAAS,CAAC;QACxB,CAAC;QACD,IAAI,QAAQ,CACV,KAA8D;YAE9D,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;QACzB,CAAC;QAED;;;WAGG;QACH,eAAe;YACb,MAAM,MAAM,GAAG,IAAI,YAAY,EAAE,CAAC;YAClC,uBAAuB,CAAC,uBAAuB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;YAC9D,OAAO,MAAM,CAAC,eAAe,EAAE,CAAC;QAClC,CAAC;QAED;;WAEG;QACH,QAAQ;YACN,OAAO;gBACL,cAAc,EAAE,IAAI,CAAC,cAAc;gBACnC,iBAAiB,EAAE,IAAI,CAAC,iBAAiB;gBACzC,QAAQ,EAAE,CAAC,IAAI,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC;aACvD,CAAC;QACJ,CAAC;QAED;;WAEG;QACH,MAAM;YACJ,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC;QACzB,CAAC;QAED;;;;WAIG;QACH,cAAc;QACZ,aAAa;QACb,OAA+B;YAE/B,OAAO;gBACL,cAAc,EAAE,IAAI,CAAC,cAAc;gBACnC,iBAAiB,EAAE,IAAI,CAAC,iBAAiB;gBACzC,QAAQ,EAAE,CAAC,IAAI,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;aACpE,CAAC;QACJ,CAAC;;IAvKM,0BAAE,GAAG,oCAAoC,CAAC;IADtC,iDAAuB,0BAyKnC,CAAA;AAsBH,CAAC,EA/Na,yBAAyB,KAAzB,yBAAyB,QA+NtC;AAED;;GAEG;AACH,MAAM,OAAO,0BAA0B;IAkErC;;;OAGG;IACH,YAAY,MAA8D;QACxE,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;QACtB,IAAI,CAAC,aAAa,GAAG,CAAC,MAAM,CAAC,aAAa,IAAI,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC;QAC1D,0BAA0B,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IAChD,CAAC;IAvED;;;OAGG;IACH,MAAM,CAAC,iBAAiB,CAAC,KAAiB;QACxC,MAAM,QAAQ,GAAG,IAAI,0BAA0B,EAAE,CAAC;QAClD,0BAA0B,CAAC,2BAA2B,CACpD,QAAQ,EACR,IAAI,YAAY,CAAC,KAAK,CAAC,CACxB,CAAC;QACF,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,YAAY,CAAC,SAAqC;QACvD,SAAS,CAAC,aAAa,GAAG,SAAS,CAAC,aAAa,IAAI,EAAE,CAAC;IAC1D,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,2BAA2B,CAChC,SAAqC,EACrC,OAAqB;QAErB,OAAO,OAAO,CAAC,SAAS,EAAE,EAAE;YAC1B,IAAI,OAAO,CAAC,UAAU,EAAE;gBAAE,MAAM;YAEhC,QAAQ,OAAO,CAAC,cAAc,EAAE,EAAE;gBAChC,KAAK,CAAC;oBACJ,CAAC,SAAS,CAAC,aAAa,GAAG,SAAS,CAAC,aAAa,IAAI,EAAE,CAAC,CAAC,IAAI,CAC5D,OAAO,CAAC,UAAU,EAAE,CACrB,CAAC;oBACF,MAAM;gBACR;oBACE,OAAO,CAAC,SAAS,EAAE,CAAC;aACvB;SACF;QAED,0BAA0B,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;IACrD,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,uBAAuB,CAC5B,SAAqC,EACrC,OAAqB;QAErB,IAAI,SAAS,CAAC,aAAa,IAAI,SAAS,CAAC,aAAa,CAAC,MAAM,EAAE;YAC7D,OAAO,CAAC,mBAAmB,CAAC,CAAC,EAAE,SAAS,CAAC,aAAa,CAAC,CAAC;SACzD;IACH,CAAC;IAaD,IAAI,aAAa;QACf,OAAO,IAAI,CAAC,cAAc,CAAC;IAC7B,CAAC;IACD,IAAI,aAAa,CAAC,KAA2B;QAC3C,IAAI,CAAC,cAAc,GAAG,KAAK,CAAC;IAC9B,CAAC;IAED;;;OAGG;IACH,eAAe;QACb,MAAM,MAAM,GAAG,IAAI,YAAY,EAAE,CAAC;QAClC,0BAA0B,CAAC,uBAAuB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QACjE,OAAO,MAAM,CAAC,eAAe,EAAE,CAAC;IAClC,CAAC;IAED;;OAEG;IACH,QAAQ;QACN,OAAO;YACL,aAAa,EAAE,CAAC,IAAI,CAAC,aAAa,IAAI,EAAE,CAAC,CAAC,KAAK,EAAE;SAClD,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,MAAM;QACJ,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC;IACzB,CAAC;IAED;;;;OAIG;IACH,cAAc;IACZ,aAAa;IACb,OAA+B;QAE/B,OAAO;YACL,aAAa,EAAE,CAAC,IAAI,CAAC,aAAa,IAAI,EAAE,CAAC,CAAC,KAAK,EAAE;SAClD,CAAC;IACJ,CAAC;;AAvHM,6BAAE,GAAG,uCAAuC,CAAC;AAyItD;;GAEG;AACH,MAAM,OAAO,gCAAgC;IAyH3C;;;OAGG;IACH,YACE,MAAoE;QAEpE,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;QACtB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;QAC5B,IAAI,CAAC,YAAY,GAAG,MAAM,CAAC,YAAY,CAAC;QACxC,IAAI,CAAC,WAAW,GAAG,MAAM,CAAC,WAAW,CAAC;QACtC,IAAI,CAAC,eAAe,GAAG,MAAM,CAAC,eAAe,CAAC;QAC9C,IAAI,CAAC,iBAAiB,GAAG,MAAM,CAAC,iBAAiB,CAAC;QAClD,IAAI,CAAC,4BAA4B,GAAG,MAAM,CAAC,4BAA4B;YACrE,CAAC,CAAC,IAAI,4BAA4B,CAAC,MAAM,CAAC,4BAA4B,CAAC;YACvE,CAAC,CAAC,SAAS,CAAC;QACd,IAAI,CAAC,eAAe,GAAG,MAAM,CAAC,eAAe,CAAC;QAC9C,gCAAgC,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IACtD,CAAC;IAxID;;;OAGG;IACH,MAAM,CAAC,iBAAiB,CAAC,KAAiB;QACxC,MAAM,QAAQ,GAAG,IAAI,gCAAgC,EAAE,CAAC;QACxD,gCAAgC,CAAC,2BAA2B,CAC1D,QAAQ,EACR,IAAI,YAAY,CAAC,KAAK,CAAC,CACxB,CAAC;QACF,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,YAAY,CAAC,SAA2C;QAC7D,SAAS,CAAC,MAAM,GAAG,SAAS,CAAC,MAAM,IAAI,EAAE,CAAC;QAC1C,SAAS,CAAC,YAAY,GAAG,SAAS,CAAC,YAAY,IAAI,EAAE,CAAC;QACtD,SAAS,CAAC,WAAW,GAAG,SAAS,CAAC,WAAW,IAAI,IAAI,UAAU,EAAE,CAAC;QAClE,SAAS,CAAC,eAAe,GAAG,SAAS,CAAC,eAAe,IAAI,KAAK,CAAC;QAC/D,SAAS,CAAC,iBAAiB,GAAG,SAAS,CAAC,iBAAiB,IAAI,EAAE,CAAC;QAChE,SAAS,CAAC,4BAA4B;YACpC,SAAS,CAAC,4BAA4B,IAAI,SAAS,CAAC;QACtD,SAAS,CAAC,eAAe,GAAG,SAAS,CAAC,eAAe,IAAI,CAAC,CAAC;IAC7D,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,2BAA2B,CAChC,SAA2C,EAC3C,OAAqB;QAErB,OAAO,OAAO,CAAC,SAAS,EAAE,EAAE;YAC1B,IAAI,OAAO,CAAC,UAAU,EAAE;gBAAE,MAAM;YAEhC,QAAQ,OAAO,CAAC,cAAc,EAAE,EAAE;gBAChC,KAAK,CAAC;oBACJ,SAAS,CAAC,MAAM,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;oBACxC,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,YAAY,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;oBAC9C,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,WAAW,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;oBAC5C,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,eAAe,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC;oBAC/C,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,iBAAiB,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;oBACnD,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,4BAA4B,GAAG,IAAI,4BAA4B,EAAE,CAAC;oBAC5E,OAAO,CAAC,WAAW,CACjB,SAAS,CAAC,4BAA4B,EACtC,4BAA4B,CAAC,2BAA2B,CACzD,CAAC;oBACF,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,eAAe,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;oBAChD,MAAM;gBACR;oBACE,OAAO,CAAC,SAAS,EAAE,CAAC;aACvB;SACF;QAED,gCAAgC,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;IAC3D,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,uBAAuB,CAC5B,SAA2C,EAC3C,OAAqB;QAErB,IAAI,SAAS,CAAC,MAAM,EAAE;YACpB,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;SAC1C;QACD,IAAI,SAAS,CAAC,YAAY,EAAE;YAC1B,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,SAAS,CAAC,YAAY,CAAC,CAAC;SAChD;QACD,IAAI,SAAS,CAAC,WAAW,IAAI,SAAS,CAAC,WAAW,CAAC,MAAM,EAAE;YACzD,OAAO,CAAC,UAAU,CAAC,CAAC,EAAE,SAAS,CAAC,WAAW,CAAC,CAAC;SAC9C;QACD,IAAI,SAAS,CAAC,eAAe,EAAE;YAC7B,OAAO,CAAC,SAAS,CAAC,CAAC,EAAE,SAAS,CAAC,eAAe,CAAC,CAAC;SACjD;QACD,IAAI,SAAS,CAAC,iBAAiB,EAAE;YAC/B,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,SAAS,CAAC,iBAAiB,CAAC,CAAC;SACrD;QACD,IAAI,SAAS,CAAC,4BAA4B,EAAE;YAC1C,OAAO,CAAC,YAAY,CAClB,CAAC,EACD,SAAS,CAAC,4BAAmC,EAC7C,4BAA4B,CAAC,uBAAuB,CACrD,CAAC;SACH;QACD,IAAI,SAAS,CAAC,eAAe,EAAE;YAC7B,OAAO,CAAC,UAAU,CAAC,CAAC,EAAE,SAAS,CAAC,eAAe,CAAC,CAAC;SAClD;IACH,CAAC;IA6BD,IAAI,MAAM;QACR,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IACD,IAAI,MAAM,CAAC,KAAyB;QAClC,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;IACvB,CAAC;IACD,IAAI,YAAY;QACd,OAAO,IAAI,CAAC,aAAa,CAAC;IAC5B,CAAC;IACD,IAAI,YAAY,CAAC,KAAyB;QACxC,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC;IAC7B,CAAC;IACD,IAAI,WAAW;QACb,OAAO,IAAI,CAAC,YAAY,CAAC;IAC3B,CAAC;IACD,IAAI,WAAW,CAAC,KAA6B;QAC3C,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC;IAC5B,CAAC;IACD,IAAI,eAAe;QACjB,OAAO,IAAI,CAAC,gBAAgB,CAAC;IAC/B,CAAC;IACD,IAAI,eAAe,CAAC,KAA0B;QAC5C,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC;IAChC,CAAC;IACD,IAAI,iBAAiB;QACnB,OAAO,IAAI,CAAC,kBAAkB,CAAC;IACjC,CAAC;IACD,IAAI,iBAAiB,CAAC,KAAyB;QAC7C,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC;IAClC,CAAC;IACD,IAAI,4BAA4B;QAC9B,OAAO,IAAI,CAAC,6BAA6B,CAAC;IAC5C,CAAC;IACD,IAAI,4BAA4B,CAC9B,KAA+C;QAE/C,IAAI,CAAC,6BAA6B,GAAG,KAAK,CAAC;IAC7C,CAAC;IACD,IAAI,eAAe;QACjB,OAAO,IAAI,CAAC,gBAAgB,CAAC;IAC/B,CAAC;IACD,IAAI,eAAe,CAAC,KAAyB;QAC3C,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC;IAChC,CAAC;IAED;;;OAGG;IACH,eAAe;QACb,MAAM,MAAM,GAAG,IAAI,YAAY,EAAE,CAAC;QAClC,gCAAgC,CAAC,uBAAuB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QACvE,OAAO,MAAM,CAAC,eAAe,EAAE,CAAC;IAClC,CAAC;IAED;;OAEG;IACH,QAAQ;QACN,OAAO;YACL,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,YAAY,EAAE,IAAI,CAAC,YAAY;YAC/B,WAAW,EAAE,IAAI,CAAC,WAAW;gBAC3B,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC,CAAC;gBAC9B,CAAC,CAAC,IAAI,UAAU,EAAE;YACpB,eAAe,EAAE,IAAI,CAAC,eAAe;YACrC,iBAAiB,EAAE,IAAI,CAAC,iBAAiB;YACzC,4BAA4B,EAAE,IAAI,CAAC,4BAA4B;gBAC7D,CAAC,CAAC,IAAI,CAAC,4BAA4B,CAAC,QAAQ,EAAE;gBAC9C,CAAC,CAAC,SAAS;YACb,eAAe,EAAE,IAAI,CAAC,eAAe;SACtC,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,MAAM;QACJ,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC;IACzB,CAAC;IAED;;;;OAIG;IACH,cAAc;IACZ,aAAa;IACb,OAA+B;QAE/B,OAAO;YACL,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,YAAY,EAAE,IAAI,CAAC,YAAY;YAC/B,WAAW,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,kBAAkB,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,EAAE;YACzE,eAAe,EAAE,IAAI,CAAC,eAAe;YACrC,iBAAiB,EAAE,IAAI,CAAC,iBAAiB;YACzC,4BAA4B,EAAE,IAAI,CAAC,4BAA4B;gBAC7D,CAAC,CAAC,IAAI,CAAC,4BAA4B,CAAC,cAAc,CAAC,OAAO,CAAC;gBAC3D,CAAC,CAAC,IAAI;YACR,eAAe,EAAE,IAAI,CAAC,eAAe;SACtC,CAAC;IACJ,CAAC;;AAhPM,mCAAE,GAAG,6CAA6C,CAAC","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  uint8ArrayToBase64\n} from '@ngx-grpc/common';\nimport { BinaryReader, BinaryWriter, ByteSource } from 'google-protobuf';\nimport * as googleApi000 from '../../google/api/annotations.pb';\nimport * as ondewoNlu001 from '../../ondewo/nlu/context.pb';\nimport * as ondewoNlu002 from '../../ondewo/nlu/common.pb';\nimport * as ondewoNlu003 from '../../ondewo/nlu/operations.pb';\nimport * as googleProtobuf004 from '@ngx-grpc/well-known-types';\nimport * as googleProtobuf005 from '@ngx-grpc/well-known-types';\nimport * as googleProtobuf006 from '@ngx-grpc/well-known-types';\nimport * as googleProtobuf007 from '@ngx-grpc/well-known-types';\nimport * as ondewoNlu008 from '../../ondewo/nlu/intent.pb';\nimport * as ondewoNlu009 from '../../ondewo/nlu/entity-type.pb';\nexport enum ReannotateEntitiesOptions {\n  REANNOTATE_NEVER = 0,\n  REANNOTATE_ALWAYS = 1,\n  REANNOTATE_IF_EMPTY = 2,\n  REANNOTATE_AFTER_DELETION = 3,\n  REANNOTATE_IF_EMPTY_OR_AFTER_DELETION = 4\n}\n/**\n * Message implementation for ondewo.nlu.ValidateRegexRequest\n */\nexport class ValidateRegexRequest implements GrpcMessage {\n  static id = 'ondewo.nlu.ValidateRegexRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new ValidateRegexRequest();\n    ValidateRegexRequest.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: ValidateRegexRequest) {\n    _instance.regex = _instance.regex || '';\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: ValidateRegexRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.regex = _reader.readString();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    ValidateRegexRequest.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: ValidateRegexRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.regex) {\n      _writer.writeString(1, _instance.regex);\n    }\n  }\n\n  private _regex?: 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 ValidateRegexRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<ValidateRegexRequest.AsObject>) {\n    _value = _value || {};\n    this.regex = _value.regex;\n    ValidateRegexRequest.refineValues(this);\n  }\n  get regex(): string | undefined {\n    return this._regex;\n  }\n  set regex(value: string | undefined) {\n    this._regex = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    ValidateRegexRequest.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(): ValidateRegexRequest.AsObject {\n    return {\n      regex: this.regex\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  ): ValidateRegexRequest.AsProtobufJSON {\n    return {\n      regex: this.regex\n    };\n  }\n}\nexport module ValidateRegexRequest {\n  /**\n   * Standard JavaScript object representation for ValidateRegexRequest\n   */\n  export interface AsObject {\n    regex?: string;\n  }\n\n  /**\n   * Protobuf JSON representation for ValidateRegexRequest\n   */\n  export interface AsProtobufJSON {\n    regex?: string;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.ValidateRegexResponse\n */\nexport class ValidateRegexResponse implements GrpcMessage {\n  static id = 'ondewo.nlu.ValidateRegexResponse';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new ValidateRegexResponse();\n    ValidateRegexResponse.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: ValidateRegexResponse) {\n    _instance.errorMessages = _instance.errorMessages || [];\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: ValidateRegexResponse,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          (_instance.errorMessages = _instance.errorMessages || []).push(\n            _reader.readString()\n          );\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    ValidateRegexResponse.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: ValidateRegexResponse,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.errorMessages && _instance.errorMessages.length) {\n      _writer.writeRepeatedString(1, _instance.errorMessages);\n    }\n  }\n\n  private _errorMessages?: 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 ValidateRegexResponse to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<ValidateRegexResponse.AsObject>) {\n    _value = _value || {};\n    this.errorMessages = (_value.errorMessages || []).slice();\n    ValidateRegexResponse.refineValues(this);\n  }\n  get errorMessages(): string[] | undefined {\n    return this._errorMessages;\n  }\n  set errorMessages(value: string[] | undefined) {\n    this._errorMessages = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    ValidateRegexResponse.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(): ValidateRegexResponse.AsObject {\n    return {\n      errorMessages: (this.errorMessages || []).slice()\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  ): ValidateRegexResponse.AsProtobufJSON {\n    return {\n      errorMessages: (this.errorMessages || []).slice()\n    };\n  }\n}\nexport module ValidateRegexResponse {\n  /**\n   * Standard JavaScript object representation for ValidateRegexResponse\n   */\n  export interface AsObject {\n    errorMessages?: string[];\n  }\n\n  /**\n   * Protobuf JSON representation for ValidateRegexResponse\n   */\n  export interface AsProtobufJSON {\n    errorMessages?: string[];\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.ValidateEmbeddedRegexRequest\n */\nexport class ValidateEmbeddedRegexRequest implements GrpcMessage {\n  static id = 'ondewo.nlu.ValidateEmbeddedRegexRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new ValidateEmbeddedRegexRequest();\n    ValidateEmbeddedRegexRequest.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: ValidateEmbeddedRegexRequest) {\n    _instance.entityType = _instance.entityType || 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: ValidateEmbeddedRegexRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.entityType = new ondewoNlu009.EntityType.Entity();\n          _reader.readMessage(\n            _instance.entityType,\n            ondewoNlu009.EntityType.Entity.deserializeBinaryFromReader\n          );\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    ValidateEmbeddedRegexRequest.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: ValidateEmbeddedRegexRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.entityType) {\n      _writer.writeMessage(\n        1,\n        _instance.entityType as any,\n        ondewoNlu009.EntityType.Entity.serializeBinaryToWriter\n      );\n    }\n  }\n\n  private _entityType?: ondewoNlu009.EntityType.Entity;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of ValidateEmbeddedRegexRequest to deeply clone from\n   */\n  constructor(\n    _value?: RecursivePartial<ValidateEmbeddedRegexRequest.AsObject>\n  ) {\n    _value = _value || {};\n    this.entityType = _value.entityType\n      ? new ondewoNlu009.EntityType.Entity(_value.entityType)\n      : undefined;\n    ValidateEmbeddedRegexRequest.refineValues(this);\n  }\n  get entityType(): ondewoNlu009.EntityType.Entity | undefined {\n    return this._entityType;\n  }\n  set entityType(value: ondewoNlu009.EntityType.Entity | undefined) {\n    this._entityType = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    ValidateEmbeddedRegexRequest.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(): ValidateEmbeddedRegexRequest.AsObject {\n    return {\n      entityType: this.entityType ? this.entityType.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  ): ValidateEmbeddedRegexRequest.AsProtobufJSON {\n    return {\n      entityType: this.entityType\n        ? this.entityType.toProtobufJSON(options)\n        : null\n    };\n  }\n}\nexport module ValidateEmbeddedRegexRequest {\n  /**\n   * Standard JavaScript object representation for ValidateEmbeddedRegexRequest\n   */\n  export interface AsObject {\n    entityType?: ondewoNlu009.EntityType.Entity.AsObject;\n  }\n\n  /**\n   * Protobuf JSON representation for ValidateEmbeddedRegexRequest\n   */\n  export interface AsProtobufJSON {\n    entityType?: ondewoNlu009.EntityType.Entity.AsProtobufJSON | null;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.ValidateEmbeddedRegexResponse\n */\nexport class ValidateEmbeddedRegexResponse implements GrpcMessage {\n  static id = 'ondewo.nlu.ValidateEmbeddedRegexResponse';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new ValidateEmbeddedRegexResponse();\n    ValidateEmbeddedRegexResponse.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: ValidateEmbeddedRegexResponse) {\n    _instance.errorMessages = _instance.errorMessages || [];\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: ValidateEmbeddedRegexResponse,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          (_instance.errorMessages = _instance.errorMessages || []).push(\n            _reader.readString()\n          );\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    ValidateEmbeddedRegexResponse.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: ValidateEmbeddedRegexResponse,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.errorMessages && _instance.errorMessages.length) {\n      _writer.writeRepeatedString(1, _instance.errorMessages);\n    }\n  }\n\n  private _errorMessages?: 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 ValidateEmbeddedRegexResponse to deeply clone from\n   */\n  constructor(\n    _value?: RecursivePartial<ValidateEmbeddedRegexResponse.AsObject>\n  ) {\n    _value = _value || {};\n    this.errorMessages = (_value.errorMessages || []).slice();\n    ValidateEmbeddedRegexResponse.refineValues(this);\n  }\n  get errorMessages(): string[] | undefined {\n    return this._errorMessages;\n  }\n  set errorMessages(value: string[] | undefined) {\n    this._errorMessages = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    ValidateEmbeddedRegexResponse.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(): ValidateEmbeddedRegexResponse.AsObject {\n    return {\n      errorMessages: (this.errorMessages || []).slice()\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  ): ValidateEmbeddedRegexResponse.AsProtobufJSON {\n    return {\n      errorMessages: (this.errorMessages || []).slice()\n    };\n  }\n}\nexport module ValidateEmbeddedRegexResponse {\n  /**\n   * Standard JavaScript object representation for ValidateEmbeddedRegexResponse\n   */\n  export interface AsObject {\n    errorMessages?: string[];\n  }\n\n  /**\n   * Protobuf JSON representation for ValidateEmbeddedRegexResponse\n   */\n  export interface AsProtobufJSON {\n    errorMessages?: string[];\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.CleanAllIntentsRequest\n */\nexport class CleanAllIntentsRequest implements GrpcMessage {\n  static id = 'ondewo.nlu.CleanAllIntentsRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new CleanAllIntentsRequest();\n    CleanAllIntentsRequest.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: CleanAllIntentsRequest) {\n    _instance.parent = _instance.parent || '';\n    _instance.languageCode = _instance.languageCode || '';\n    _instance.specialCharacters = _instance.specialCharacters || '';\n    _instance.substringWhiteList = _instance.substringWhiteList || [];\n    _instance.dryRun = _instance.dryRun || false;\n    _instance.trainingPhraseCleanerOptions =\n      _instance.trainingPhraseCleanerOptions || undefined;\n    _instance.reannotateEntitiesOptions =\n      _instance.reannotateEntitiesOptions || 0;\n    _instance.numberOfWorkers = _instance.numberOfWorkers || 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: CleanAllIntentsRequest,\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.languageCode = _reader.readString();\n          break;\n        case 3:\n          _instance.specialCharacters = _reader.readString();\n          break;\n        case 4:\n          (_instance.substringWhiteList =\n            _instance.substringWhiteList || []).push(_reader.readString());\n          break;\n        case 5:\n          _instance.dryRun = _reader.readBool();\n          break;\n        case 6:\n          _instance.trainingPhraseCleanerOptions = new TrainingPhraseCleanerOptions();\n          _reader.readMessage(\n            _instance.trainingPhraseCleanerOptions,\n            TrainingPhraseCleanerOptions.deserializeBinaryFromReader\n          );\n          break;\n        case 7:\n          _instance.reannotateEntitiesOptions = _reader.readEnum();\n          break;\n        case 8:\n          _instance.numberOfWorkers = _reader.readInt32();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    CleanAllIntentsRequest.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: CleanAllIntentsRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.parent) {\n      _writer.writeString(1, _instance.parent);\n    }\n    if (_instance.languageCode) {\n      _writer.writeString(2, _instance.languageCode);\n    }\n    if (_instance.specialCharacters) {\n      _writer.writeString(3, _instance.specialCharacters);\n    }\n    if (_instance.substringWhiteList && _instance.substringWhiteList.length) {\n      _writer.writeRepeatedString(4, _instance.substringWhiteList);\n    }\n    if (_instance.dryRun) {\n      _writer.writeBool(5, _instance.dryRun);\n    }\n    if (_instance.trainingPhraseCleanerOptions) {\n      _writer.writeMessage(\n        6,\n        _instance.trainingPhraseCleanerOptions as any,\n        TrainingPhraseCleanerOptions.serializeBinaryToWriter\n      );\n    }\n    if (_instance.reannotateEntitiesOptions) {\n      _writer.writeEnum(7, _instance.reannotateEntitiesOptions);\n    }\n    if (_instance.numberOfWorkers) {\n      _writer.writeInt32(8, _instance.numberOfWorkers);\n    }\n  }\n\n  private _parent?: string;\n  private _languageCode?: string;\n  private _specialCharacters?: string;\n  private _substringWhiteList?: string[];\n  private _dryRun?: boolean;\n  private _trainingPhraseCleanerOptions?: TrainingPhraseCleanerOptions;\n  private _reannotateEntitiesOptions?: ReannotateEntitiesOptions;\n  private _numberOfWorkers?: number;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of CleanAllIntentsRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<CleanAllIntentsRequest.AsObject>) {\n    _value = _value || {};\n    this.parent = _value.parent;\n    this.languageCode = _value.languageCode;\n    this.specialCharacters = _value.specialCharacters;\n    this.substringWhiteList = (_value.substringWhiteList || []).slice();\n    this.dryRun = _value.dryRun;\n    this.trainingPhraseCleanerOptions = _value.trainingPhraseCleanerOptions\n      ? new TrainingPhraseCleanerOptions(_value.trainingPhraseCleanerOptions)\n      : undefined;\n    this.reannotateEntitiesOptions = _value.reannotateEntitiesOptions;\n    this.numberOfWorkers = _value.numberOfWorkers;\n    CleanAllIntentsRequest.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 languageCode(): string | undefined {\n    return this._languageCode;\n  }\n  set languageCode(value: string | undefined) {\n    this._languageCode = value;\n  }\n  get specialCharacters(): string | undefined {\n    return this._specialCharacters;\n  }\n  set specialCharacters(value: string | undefined) {\n    this._specialCharacters = value;\n  }\n  get substringWhiteList(): string[] | undefined {\n    return this._substringWhiteList;\n  }\n  set substringWhiteList(value: string[] | undefined) {\n    this._substringWhiteList = value;\n  }\n  get dryRun(): boolean | undefined {\n    return this._dryRun;\n  }\n  set dryRun(value: boolean | undefined) {\n    this._dryRun = value;\n  }\n  get trainingPhraseCleanerOptions(): TrainingPhraseCleanerOptions | undefined {\n    return this._trainingPhraseCleanerOptions;\n  }\n  set trainingPhraseCleanerOptions(\n    value: TrainingPhraseCleanerOptions | undefined\n  ) {\n    this._trainingPhraseCleanerOptions = value;\n  }\n  get reannotateEntitiesOptions(): ReannotateEntitiesOptions | undefined {\n    return this._reannotateEntitiesOptions;\n  }\n  set reannotateEntitiesOptions(value: ReannotateEntitiesOptions | undefined) {\n    this._reannotateEntitiesOptions = value;\n  }\n  get numberOfWorkers(): number | undefined {\n    return this._numberOfWorkers;\n  }\n  set numberOfWorkers(value: number | undefined) {\n    this._numberOfWorkers = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    CleanAllIntentsRequest.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(): CleanAllIntentsRequest.AsObject {\n    return {\n      parent: this.parent,\n      languageCode: this.languageCode,\n      specialCharacters: this.specialCharacters,\n      substringWhiteList: (this.substringWhiteList || []).slice(),\n      dryRun: this.dryRun,\n      trainingPhraseCleanerOptions: this.trainingPhraseCleanerOptions\n        ? this.trainingPhraseCleanerOptions.toObject()\n        : undefined,\n      reannotateEntitiesOptions: this.reannotateEntitiesOptions,\n      numberOfWorkers: this.numberOfWorkers\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  ): CleanAllIntentsRequest.AsProtobufJSON {\n    return {\n      parent: this.parent,\n      languageCode: this.languageCode,\n      specialCharacters: this.specialCharacters,\n      substringWhiteList: (this.substringWhiteList || []).slice(),\n      dryRun: this.dryRun,\n      trainingPhraseCleanerOptions: this.trainingPhraseCleanerOptions\n        ? this.trainingPhraseCleanerOptions.toProtobufJSON(options)\n        : null,\n      reannotateEntitiesOptions:\n        ReannotateEntitiesOptions[\n          this.reannotateEntitiesOptions === null ||\n          this.reannotateEntitiesOptions === undefined\n            ? 0\n            : this.reannotateEntitiesOptions\n        ],\n      numberOfWorkers: this.numberOfWorkers\n    };\n  }\n}\nexport module CleanAllIntentsRequest {\n  /**\n   * Standard JavaScript object representation for CleanAllIntentsRequest\n   */\n  export interface AsObject {\n    parent?: string;\n    languageCode?: string;\n    specialCharacters?: string;\n    substringWhiteList?: string[];\n    dryRun?: boolean;\n    trainingPhraseCleanerOptions?: TrainingPhraseCleanerOptions.AsObject;\n    reannotateEntitiesOptions?: ReannotateEntitiesOptions;\n    numberOfWorkers?: number;\n  }\n\n  /**\n   * Protobuf JSON representation for CleanAllIntentsRequest\n   */\n  export interface AsProtobufJSON {\n    parent?: string;\n    languageCode?: string;\n    specialCharacters?: string;\n    substringWhiteList?: string[];\n    dryRun?: boolean;\n    trainingPhraseCleanerOptions?: TrainingPhraseCleanerOptions.AsProtobufJSON | null;\n    reannotateEntitiesOptions?: string;\n    numberOfWorkers?: number;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.CleanAllIntentsResponse\n */\nexport class CleanAllIntentsResponse implements GrpcMessage {\n  static id = 'ondewo.nlu.CleanAllIntentsResponse';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new CleanAllIntentsResponse();\n    CleanAllIntentsResponse.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: CleanAllIntentsResponse) {\n    _instance.cleanedIntents = _instance.cleanedIntents || [];\n    _instance.intentUpdateList = _instance.intentUpdateList || [];\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: CleanAllIntentsResponse,\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 ondewoNlu008.Intent();\n          _reader.readMessage(\n            messageInitializer1,\n            ondewoNlu008.Intent.deserializeBinaryFromReader\n          );\n          (_instance.cleanedIntents = _instance.cleanedIntents || []).push(\n            messageInitializer1\n          );\n          break;\n        case 2:\n          const messageInitializer2 = new IntentUpdate();\n          _reader.readMessage(\n            messageInitializer2,\n            IntentUpdate.deserializeBinaryFromReader\n          );\n          (_instance.intentUpdateList = _instance.intentUpdateList || []).push(\n            messageInitializer2\n          );\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    CleanAllIntentsResponse.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: CleanAllIntentsResponse,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.cleanedIntents && _instance.cleanedIntents.length) {\n      _writer.writeRepeatedMessage(\n        1,\n        _instance.cleanedIntents as any,\n        ondewoNlu008.Intent.serializeBinaryToWriter\n      );\n    }\n    if (_instance.intentUpdateList && _instance.intentUpdateList.length) {\n      _writer.writeRepeatedMessage(\n        2,\n        _instance.intentUpdateList as any,\n        IntentUpdate.serializeBinaryToWriter\n      );\n    }\n  }\n\n  private _cleanedIntents?: ondewoNlu008.Intent[];\n  private _intentUpdateList?: IntentUpdate[];\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of CleanAllIntentsResponse to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<CleanAllIntentsResponse.AsObject>) {\n    _value = _value || {};\n    this.cleanedIntents = (_value.cleanedIntents || []).map(\n      m => new ondewoNlu008.Intent(m)\n    );\n    this.intentUpdateList = (_value.intentUpdateList || []).map(\n      m => new IntentUpdate(m)\n    );\n    CleanAllIntentsResponse.refineValues(this);\n  }\n  get cleanedIntents(): ondewoNlu008.Intent[] | undefined {\n    return this._cleanedIntents;\n  }\n  set cleanedIntents(value: ondewoNlu008.Intent[] | undefined) {\n    this._cleanedIntents = value;\n  }\n  get intentUpdateList(): IntentUpdate[] | undefined {\n    return this._intentUpdateList;\n  }\n  set intentUpdateList(value: IntentUpdate[] | undefined) {\n    this._intentUpdateList = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    CleanAllIntentsResponse.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(): CleanAllIntentsResponse.AsObject {\n    return {\n      cleanedIntents: (this.cleanedIntents || []).map(m => m.toObject()),\n      intentUpdateList: (this.intentUpdateList || []).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  ): CleanAllIntentsResponse.AsProtobufJSON {\n    return {\n      cleanedIntents: (this.cleanedIntents || []).map(m =>\n        m.toProtobufJSON(options)\n      ),\n      intentUpdateList: (this.intentUpdateList || []).map(m =>\n        m.toProtobufJSON(options)\n      )\n    };\n  }\n}\nexport module CleanAllIntentsResponse {\n  /**\n   * Standard JavaScript object representation for CleanAllIntentsResponse\n   */\n  export interface AsObject {\n    cleanedIntents?: ondewoNlu008.Intent.AsObject[];\n    intentUpdateList?: IntentUpdate.AsObject[];\n  }\n\n  /**\n   * Protobuf JSON representation for CleanAllIntentsResponse\n   */\n  export interface AsProtobufJSON {\n    cleanedIntents?: ondewoNlu008.Intent.AsProtobufJSON[] | null;\n    intentUpdateList?: IntentUpdate.AsProtobufJSON[] | null;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.CleanIntentRequest\n */\nexport class CleanIntentRequest implements GrpcMessage {\n  static id = 'ondewo.nlu.CleanIntentRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new CleanIntentRequest();\n    CleanIntentRequest.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: CleanIntentRequest) {\n    _instance.parent = _instance.parent || '';\n    _instance.intentName = _instance.intentName || '';\n    _instance.languageCode = _instance.languageCode || '';\n    _instance.specialCharacters = _instance.specialCharacters || '';\n    _instance.substringWhiteList = _instance.substringWhiteList || [];\n    _instance.dryRun = _instance.dryRun || false;\n    _instance.trainingPhraseCleanerOptions =\n      _instance.trainingPhraseCleanerOptions || undefined;\n    _instance.reannotateEntitiesOptions =\n      _instance.reannotateEntitiesOptions || 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: CleanIntentRequest,\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.intentName = _reader.readString();\n          break;\n        case 3:\n          _instance.languageCode = _reader.readString();\n          break;\n        case 4:\n          _instance.specialCharacters = _reader.readString();\n          break;\n        case 5:\n          (_instance.substringWhiteList =\n            _instance.substringWhiteList || []).push(_reader.readString());\n          break;\n        case 6:\n          _instance.dryRun = _reader.readBool();\n          break;\n        case 7:\n          _instance.trainingPhraseCleanerOptions = new TrainingPhraseCleanerOptions();\n          _reader.readMessage(\n            _instance.trainingPhraseCleanerOptions,\n            TrainingPhraseCleanerOptions.deserializeBinaryFromReader\n          );\n          break;\n        case 8:\n          _instance.reannotateEntitiesOptions = _reader.readEnum();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    CleanIntentRequest.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: CleanIntentRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.parent) {\n      _writer.writeString(1, _instance.parent);\n    }\n    if (_instance.intentName) {\n      _writer.writeString(2, _instance.intentName);\n    }\n    if (_instance.languageCode) {\n      _writer.writeString(3, _instance.languageCode);\n    }\n    if (_instance.specialCharacters) {\n      _writer.writeString(4, _instance.specialCharacters);\n    }\n    if (_instance.substringWhiteList && _instance.substringWhiteList.length) {\n      _writer.writeRepeatedString(5, _instance.substringWhiteList);\n    }\n    if (_instance.dryRun) {\n      _writer.writeBool(6, _instance.dryRun);\n    }\n    if (_instance.trainingPhraseCleanerOptions) {\n      _writer.writeMessage(\n        7,\n        _instance.trainingPhraseCleanerOptions as any,\n        TrainingPhraseCleanerOptions.serializeBinaryToWriter\n      );\n    }\n    if (_instance.reannotateEntitiesOptions) {\n      _writer.writeEnum(8, _instance.reannotateEntitiesOptions);\n    }\n  }\n\n  private _parent?: string;\n  private _intentName?: string;\n  private _languageCode?: string;\n  private _specialCharacters?: string;\n  private _substringWhiteList?: string[];\n  private _dryRun?: boolean;\n  private _trainingPhraseCleanerOptions?: TrainingPhraseCleanerOptions;\n  private _reannotateEntitiesOptions?: ReannotateEntitiesOptions;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of CleanIntentRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<CleanIntentRequest.AsObject>) {\n    _value = _value || {};\n    this.parent = _value.parent;\n    this.intentName = _value.intentName;\n    this.languageCode = _value.languageCode;\n    this.specialCharacters = _value.specialCharacters;\n    this.substringWhiteList = (_value.substringWhiteList || []).slice();\n    this.dryRun = _value.dryRun;\n    this.trainingPhraseCleanerOptions = _value.trainingPhraseCleanerOptions\n      ? new TrainingPhraseCleanerOptions(_value.trainingPhraseCleanerOptions)\n      : undefined;\n    this.reannotateEntitiesOptions = _value.reannotateEntitiesOptions;\n    CleanIntentRequest.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 intentName(): string | undefined {\n    return this._intentName;\n  }\n  set intentName(value: string | undefined) {\n    this._intentName = value;\n  }\n  get languageCode(): string | undefined {\n    return this._languageCode;\n  }\n  set languageCode(value: string | undefined) {\n    this._languageCode = value;\n  }\n  get specialCharacters(): string | undefined {\n    return this._specialCharacters;\n  }\n  set specialCharacters(value: string | undefined) {\n    this._specialCharacters = value;\n  }\n  get substringWhiteList(): string[] | undefined {\n    return this._substringWhiteList;\n  }\n  set substringWhiteList(value: string[] | undefined) {\n    this._substringWhiteList = value;\n  }\n  get dryRun(): boolean | undefined {\n    return this._dryRun;\n  }\n  set dryRun(value: boolean | undefined) {\n    this._dryRun = value;\n  }\n  get trainingPhraseCleanerOptions(): TrainingPhraseCleanerOptions | undefined {\n    return this._trainingPhraseCleanerOptions;\n  }\n  set trainingPhraseCleanerOptions(\n    value: TrainingPhraseCleanerOptions | undefined\n  ) {\n    this._trainingPhraseCleanerOptions = value;\n  }\n  get reannotateEntitiesOptions(): ReannotateEntitiesOptions | undefined {\n    return this._reannotateEntitiesOptions;\n  }\n  set reannotateEntitiesOptions(value: ReannotateEntitiesOptions | undefined) {\n    this._reannotateEntitiesOptions = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    CleanIntentRequest.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(): CleanIntentRequest.AsObject {\n    return {\n      parent: this.parent,\n      intentName: this.intentName,\n      languageCode: this.languageCode,\n      specialCharacters: this.specialCharacters,\n      substringWhiteList: (this.substringWhiteList || []).slice(),\n      dryRun: this.dryRun,\n      trainingPhraseCleanerOptions: this.trainingPhraseCleanerOptions\n        ? this.trainingPhraseCleanerOptions.toObject()\n        : undefined,\n      reannotateEntitiesOptions: this.reannotateEntitiesOptions\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  ): CleanIntentRequest.AsProtobufJSON {\n    return {\n      parent: this.parent,\n      intentName: this.intentName,\n      languageCode: this.languageCode,\n      specialCharacters: this.specialCharacters,\n      substringWhiteList: (this.substringWhiteList || []).slice(),\n      dryRun: this.dryRun,\n      trainingPhraseCleanerOptions: this.trainingPhraseCleanerOptions\n        ? this.trainingPhraseCleanerOptions.toProtobufJSON(options)\n        : null,\n      reannotateEntitiesOptions:\n        ReannotateEntitiesOptions[\n          this.reannotateEntitiesOptions === null ||\n          this.reannotateEntitiesOptions === undefined\n            ? 0\n            : this.reannotateEntitiesOptions\n        ]\n    };\n  }\n}\nexport module CleanIntentRequest {\n  /**\n   * Standard JavaScript object representation for CleanIntentRequest\n   */\n  export interface AsObject {\n    parent?: string;\n    intentName?: string;\n    languageCode?: string;\n    specialCharacters?: string;\n    substringWhiteList?: string[];\n    dryRun?: boolean;\n    trainingPhraseCleanerOptions?: TrainingPhraseCleanerOptions.AsObject;\n    reannotateEntitiesOptions?: ReannotateEntitiesOptions;\n  }\n\n  /**\n   * Protobuf JSON representation for CleanIntentRequest\n   */\n  export interface AsProtobufJSON {\n    parent?: string;\n    intentName?: string;\n    languageCode?: string;\n    specialCharacters?: string;\n    substringWhiteList?: string[];\n    dryRun?: boolean;\n    trainingPhraseCleanerOptions?: TrainingPhraseCleanerOptions.AsProtobufJSON | null;\n    reannotateEntitiesOptions?: string;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.CleanIntentResponse\n */\nexport class CleanIntentResponse implements GrpcMessage {\n  static id = 'ondewo.nlu.CleanIntentResponse';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new CleanIntentResponse();\n    CleanIntentResponse.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: CleanIntentResponse) {\n    _instance.cleanedIntent = _instance.cleanedIntent || undefined;\n    _instance.intentUpdate = _instance.intentUpdate || 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: CleanIntentResponse,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.cleanedIntent = new ondewoNlu008.Intent();\n          _reader.readMessage(\n            _instance.cleanedIntent,\n            ondewoNlu008.Intent.deserializeBinaryFromReader\n          );\n          break;\n        case 2:\n          _instance.intentUpdate = new IntentUpdate();\n          _reader.readMessage(\n            _instance.intentUpdate,\n            IntentUpdate.deserializeBinaryFromReader\n          );\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    CleanIntentResponse.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: CleanIntentResponse,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.cleanedIntent) {\n      _writer.writeMessage(\n        1,\n        _instance.cleanedIntent as any,\n        ondewoNlu008.Intent.serializeBinaryToWriter\n      );\n    }\n    if (_instance.intentUpdate) {\n      _writer.writeMessage(\n        2,\n        _instance.intentUpdate as any,\n        IntentUpdate.serializeBinaryToWriter\n      );\n    }\n  }\n\n  private _cleanedIntent?: ondewoNlu008.Intent;\n  private _intentUpdate?: IntentUpdate;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of CleanIntentResponse to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<CleanIntentResponse.AsObject>) {\n    _value = _value || {};\n    this.cleanedIntent = _value.cleanedIntent\n      ? new ondewoNlu008.Intent(_value.cleanedIntent)\n      : undefined;\n    this.intentUpdate = _value.intentUpdate\n      ? new IntentUpdate(_value.intentUpdate)\n      : undefined;\n    CleanIntentResponse.refineValues(this);\n  }\n  get cleanedIntent(): ondewoNlu008.Intent | undefined {\n    return this._cleanedIntent;\n  }\n  set cleanedIntent(value: ondewoNlu008.Intent | undefined) {\n    this._cleanedIntent = value;\n  }\n  get intentUpdate(): IntentUpdate | undefined {\n    return this._intentUpdate;\n  }\n  set intentUpdate(value: IntentUpdate | undefined) {\n    this._intentUpdate = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    CleanIntentResponse.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(): CleanIntentResponse.AsObject {\n    return {\n      cleanedIntent: this.cleanedIntent\n        ? this.cleanedIntent.toObject()\n        : undefined,\n      intentUpdate: this.intentUpdate ? this.intentUpdate.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  ): CleanIntentResponse.AsProtobufJSON {\n    return {\n      cleanedIntent: this.cleanedIntent\n        ? this.cleanedIntent.toProtobufJSON(options)\n        : null,\n      intentUpdate: this.intentUpdate\n        ? this.intentUpdate.toProtobufJSON(options)\n        : null\n    };\n  }\n}\nexport module CleanIntentResponse {\n  /**\n   * Standard JavaScript object representation for CleanIntentResponse\n   */\n  export interface AsObject {\n    cleanedIntent?: ondewoNlu008.Intent.AsObject;\n    intentUpdate?: IntentUpdate.AsObject;\n  }\n\n  /**\n   * Protobuf JSON representation for CleanIntentResponse\n   */\n  export interface AsProtobufJSON {\n    cleanedIntent?: ondewoNlu008.Intent.AsProtobufJSON | null;\n    intentUpdate?: IntentUpdate.AsProtobufJSON | null;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.TrainingPhraseCleanerOptions\n */\nexport class TrainingPhraseCleanerOptions implements GrpcMessage {\n  static id = 'ondewo.nlu.TrainingPhraseCleanerOptions';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new TrainingPhraseCleanerOptions();\n    TrainingPhraseCleanerOptions.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: TrainingPhraseCleanerOptions) {\n    _instance.deleteRepeatedWhitespaces =\n      _instance.deleteRepeatedWhitespaces || false;\n    _instance.deleteLeadingSpecialCharacters =\n      _instance.deleteLeadingSpecialCharacters || false;\n    _instance.deleteTrailingSpecialCharacters =\n      _instance.deleteTrailingSpecialCharacters || false;\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: TrainingPhraseCleanerOptions,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.deleteRepeatedWhitespaces = _reader.readBool();\n          break;\n        case 2:\n          _instance.deleteLeadingSpecialCharacters = _reader.readBool();\n          break;\n        case 3:\n          _instance.deleteTrailingSpecialCharacters = _reader.readBool();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    TrainingPhraseCleanerOptions.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: TrainingPhraseCleanerOptions,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.deleteRepeatedWhitespaces) {\n      _writer.writeBool(1, _instance.deleteRepeatedWhitespaces);\n    }\n    if (_instance.deleteLeadingSpecialCharacters) {\n      _writer.writeBool(2, _instance.deleteLeadingSpecialCharacters);\n    }\n    if (_instance.deleteTrailingSpecialCharacters) {\n      _writer.writeBool(3, _instance.deleteTrailingSpecialCharacters);\n    }\n  }\n\n  private _deleteRepeatedWhitespaces?: boolean;\n  private _deleteLeadingSpecialCharacters?: boolean;\n  private _deleteTrailingSpecialCharacters?: boolean;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of TrainingPhraseCleanerOptions to deeply clone from\n   */\n  constructor(\n    _value?: RecursivePartial<TrainingPhraseCleanerOptions.AsObject>\n  ) {\n    _value = _value || {};\n    this.deleteRepeatedWhitespaces = _value.deleteRepeatedWhitespaces;\n    this.deleteLeadingSpecialCharacters = _value.deleteLeadingSpecialCharacters;\n    this.deleteTrailingSpecialCharacters =\n      _value.deleteTrailingSpecialCharacters;\n    TrainingPhraseCleanerOptions.refineValues(this);\n  }\n  get deleteRepeatedWhitespaces(): boolean | undefined {\n    return this._deleteRepeatedWhitespaces;\n  }\n  set deleteRepeatedWhitespaces(value: boolean | undefined) {\n    this._deleteRepeatedWhitespaces = value;\n  }\n  get deleteLeadingSpecialCharacters(): boolean | undefined {\n    return this._deleteLeadingSpecialCharacters;\n  }\n  set deleteLeadingSpecialCharacters(value: boolean | undefined) {\n    this._deleteLeadingSpecialCharacters = value;\n  }\n  get deleteTrailingSpecialCharacters(): boolean | undefined {\n    return this._deleteTrailingSpecialCharacters;\n  }\n  set deleteTrailingSpecialCharacters(value: boolean | undefined) {\n    this._deleteTrailingSpecialCharacters = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    TrainingPhraseCleanerOptions.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(): TrainingPhraseCleanerOptions.AsObject {\n    return {\n      deleteRepeatedWhitespaces: this.deleteRepeatedWhitespaces,\n      deleteLeadingSpecialCharacters: this.deleteLeadingSpecialCharacters,\n      deleteTrailingSpecialCharacters: this.deleteTrailingSpecialCharacters\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  ): TrainingPhraseCleanerOptions.AsProtobufJSON {\n    return {\n      deleteRepeatedWhitespaces: this.deleteRepeatedWhitespaces,\n      deleteLeadingSpecialCharacters: this.deleteLeadingSpecialCharacters,\n      deleteTrailingSpecialCharacters: this.deleteTrailingSpecialCharacters\n    };\n  }\n}\nexport module TrainingPhraseCleanerOptions {\n  /**\n   * Standard JavaScript object representation for TrainingPhraseCleanerOptions\n   */\n  export interface AsObject {\n    deleteRepeatedWhitespaces?: boolean;\n    deleteLeadingSpecialCharacters?: boolean;\n    deleteTrailingSpecialCharacters?: boolean;\n  }\n\n  /**\n   * Protobuf JSON representation for TrainingPhraseCleanerOptions\n   */\n  export interface AsProtobufJSON {\n    deleteRepeatedWhitespaces?: boolean;\n    deleteLeadingSpecialCharacters?: boolean;\n    deleteTrailingSpecialCharacters?: boolean;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.StringUpdate\n */\nexport class StringUpdate implements GrpcMessage {\n  static id = 'ondewo.nlu.StringUpdate';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new StringUpdate();\n    StringUpdate.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: StringUpdate) {\n    _instance.new = _instance.new || '';\n    _instance.old = _instance.old || '';\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: StringUpdate,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.new = _reader.readString();\n          break;\n        case 2:\n          _instance.old = _reader.readString();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    StringUpdate.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: StringUpdate,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.new) {\n      _writer.writeString(1, _instance.new);\n    }\n    if (_instance.old) {\n      _writer.writeString(2, _instance.old);\n    }\n  }\n\n  private _new?: string;\n  private _old?: 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 StringUpdate to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<StringUpdate.AsObject>) {\n    _value = _value || {};\n    this.new = _value.new;\n    this.old = _value.old;\n    StringUpdate.refineValues(this);\n  }\n  get new(): string | undefined {\n    return this._new;\n  }\n  set new(value: string | undefined) {\n    this._new = value;\n  }\n  get old(): string | undefined {\n    return this._old;\n  }\n  set old(value: string | undefined) {\n    this._old = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    StringUpdate.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(): StringUpdate.AsObject {\n    return {\n      new: this.new,\n      old: this.old\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  ): StringUpdate.AsProtobufJSON {\n    return {\n      new: this.new,\n      old: this.old\n    };\n  }\n}\nexport module StringUpdate {\n  /**\n   * Standard JavaScript object representation for StringUpdate\n   */\n  export interface AsObject {\n    new?: string;\n    old?: string;\n  }\n\n  /**\n   * Protobuf JSON representation for StringUpdate\n   */\n  export interface AsProtobufJSON {\n    new?: string;\n    old?: string;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.IntentUpdate\n */\nexport class IntentUpdate implements GrpcMessage {\n  static id = 'ondewo.nlu.IntentUpdate';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new IntentUpdate();\n    IntentUpdate.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: IntentUpdate) {\n    _instance.intentDisplayName = _instance.intentDisplayName || '';\n    _instance.trainingPhraseUpdateList =\n      _instance.trainingPhraseUpdateList || [];\n    _instance.deletedParameters = _instance.deletedParameters || [];\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: IntentUpdate,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.intentDisplayName = _reader.readString();\n          break;\n        case 2:\n          const messageInitializer2 = new IntentUpdate.TrainingPhraseUpdate();\n          _reader.readMessage(\n            messageInitializer2,\n            IntentUpdate.TrainingPhraseUpdate.deserializeBinaryFromReader\n          );\n          (_instance.trainingPhraseUpdateList =\n            _instance.trainingPhraseUpdateList || []).push(messageInitializer2);\n          break;\n        case 3:\n          (_instance.deletedParameters =\n            _instance.deletedParameters || []).push(_reader.readString());\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    IntentUpdate.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: IntentUpdate,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.intentDisplayName) {\n      _writer.writeString(1, _instance.intentDisplayName);\n    }\n    if (\n      _instance.trainingPhraseUpdateList &&\n      _instance.trainingPhraseUpdateList.length\n    ) {\n      _writer.writeRepeatedMessage(\n        2,\n        _instance.trainingPhraseUpdateList as any,\n        IntentUpdate.TrainingPhraseUpdate.serializeBinaryToWriter\n      );\n    }\n    if (_instance.deletedParameters && _instance.deletedParameters.length) {\n      _writer.writeRepeatedString(3, _instance.deletedParameters);\n    }\n  }\n\n  private _intentDisplayName?: string;\n  private _trainingPhraseUpdateList?: IntentUpdate.TrainingPhraseUpdate[];\n  private _deletedParameters?: 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 IntentUpdate to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<IntentUpdate.AsObject>) {\n    _value = _value || {};\n    this.intentDisplayName = _value.intentDisplayName;\n    this.trainingPhraseUpdateList = (_value.trainingPhraseUpdateList || []).map(\n      m => new IntentUpdate.TrainingPhraseUpdate(m)\n    );\n    this.deletedParameters = (_value.deletedParameters || []).slice();\n    IntentUpdate.refineValues(this);\n  }\n  get intentDisplayName(): string | undefined {\n    return this._intentDisplayName;\n  }\n  set intentDisplayName(value: string | undefined) {\n    this._intentDisplayName = value;\n  }\n  get trainingPhraseUpdateList():\n    | IntentUpdate.TrainingPhraseUpdate[]\n    | undefined {\n    return this._trainingPhraseUpdateList;\n  }\n  set trainingPhraseUpdateList(\n    value: IntentUpdate.TrainingPhraseUpdate[] | undefined\n  ) {\n    this._trainingPhraseUpdateList = value;\n  }\n  get deletedParameters(): string[] | undefined {\n    return this._deletedParameters;\n  }\n  set deletedParameters(value: string[] | undefined) {\n    this._deletedParameters = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    IntentUpdate.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(): IntentUpdate.AsObject {\n    return {\n      intentDisplayName: this.intentDisplayName,\n      trainingPhraseUpdateList: (this.trainingPhraseUpdateList || []).map(m =>\n        m.toObject()\n      ),\n      deletedParameters: (this.deletedParameters || []).slice()\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  ): IntentUpdate.AsProtobufJSON {\n    return {\n      intentDisplayName: this.intentDisplayName,\n      trainingPhraseUpdateList: (this.trainingPhraseUpdateList || []).map(m =>\n        m.toProtobufJSON(options)\n      ),\n      deletedParameters: (this.deletedParameters || []).slice()\n    };\n  }\n}\nexport module IntentUpdate {\n  /**\n   * Standard JavaScript object representation for IntentUpdate\n   */\n  export interface AsObject {\n    intentDisplayName?: string;\n    trainingPhraseUpdateList?: IntentUpdate.TrainingPhraseUpdate.AsObject[];\n    deletedParameters?: string[];\n  }\n\n  /**\n   * Protobuf JSON representation for IntentUpdate\n   */\n  export interface AsProtobufJSON {\n    intentDisplayName?: string;\n    trainingPhraseUpdateList?:\n      | IntentUpdate.TrainingPhraseUpdate.AsProtobufJSON[]\n      | null;\n    deletedParameters?: string[];\n  }\n\n  /**\n   * Message implementation for ondewo.nlu.TrainingPhraseUpdate\n   */\n  export class TrainingPhraseUpdate implements GrpcMessage {\n    static id = 'ondewo.nlu.TrainingPhraseUpdate';\n\n    /**\n     * Deserialize binary data to message\n     * @param instance message instance\n     */\n    static deserializeBinary(bytes: ByteSource) {\n      const instance = new TrainingPhraseUpdate();\n      TrainingPhraseUpdate.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: TrainingPhraseUpdate) {\n      _instance.trainingPhraseUpdate =\n        _instance.trainingPhraseUpdate || undefined;\n      _instance.entityUpdates = _instance.entityUpdates || [];\n      _instance.entitiesReannotated = _instance.entitiesReannotated || [];\n      _instance.containsUpdateVariable =\n        _instance.containsUpdateVariable || false;\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: TrainingPhraseUpdate,\n      _reader: BinaryReader\n    ) {\n      while (_reader.nextField()) {\n        if (_reader.isEndGroup()) break;\n\n        switch (_reader.getFieldNumber()) {\n          case 1:\n            _instance.trainingPhraseUpdate = new StringUpdate();\n            _reader.readMessage(\n              _instance.trainingPhraseUpdate,\n              StringUpdate.deserializeBinaryFromReader\n            );\n            break;\n          case 2:\n            const messageInitializer2 = new StringUpdate();\n            _reader.readMessage(\n              messageInitializer2,\n              StringUpdate.deserializeBinaryFromReader\n            );\n            (_instance.entityUpdates = _instance.entityUpdates || []).push(\n              messageInitializer2\n            );\n            break;\n          case 3:\n            (_instance.entitiesReannotated =\n              _instance.entitiesReannotated || []).push(_reader.readString());\n            break;\n          case 4:\n            _instance.containsUpdateVariable = _reader.readBool();\n            break;\n          default:\n            _reader.skipField();\n        }\n      }\n\n      TrainingPhraseUpdate.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: TrainingPhraseUpdate,\n      _writer: BinaryWriter\n    ) {\n      if (_instance.trainingPhraseUpdate) {\n        _writer.writeMessage(\n          1,\n          _instance.trainingPhraseUpdate as any,\n          StringUpdate.serializeBinaryToWriter\n        );\n      }\n      if (_instance.entityUpdates && _instance.entityUpdates.length) {\n        _writer.writeRepeatedMessage(\n          2,\n          _instance.entityUpdates as any,\n          StringUpdate.serializeBinaryToWriter\n        );\n      }\n      if (\n        _instance.entitiesReannotated &&\n        _instance.entitiesReannotated.length\n      ) {\n        _writer.writeRepeatedString(3, _instance.entitiesReannotated);\n      }\n      if (_instance.containsUpdateVariable) {\n        _writer.writeBool(4, _instance.containsUpdateVariable);\n      }\n    }\n\n    private _trainingPhraseUpdate?: StringUpdate;\n    private _entityUpdates?: StringUpdate[];\n    private _entitiesReannotated?: string[];\n    private _containsUpdateVariable?: boolean;\n\n    /**\n     * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n     * @param _value initial values object or instance of TrainingPhraseUpdate to deeply clone from\n     */\n    constructor(_value?: RecursivePartial<TrainingPhraseUpdate.AsObject>) {\n      _value = _value || {};\n      this.trainingPhraseUpdate = _value.trainingPhraseUpdate\n        ? new StringUpdate(_value.trainingPhraseUpdate)\n        : undefined;\n      this.entityUpdates = (_value.entityUpdates || []).map(\n        m => new StringUpdate(m)\n      );\n      this.entitiesReannotated = (_value.entitiesReannotated || []).slice();\n      this.containsUpdateVariable = _value.containsUpdateVariable;\n      TrainingPhraseUpdate.refineValues(this);\n    }\n    get trainingPhraseUpdate(): StringUpdate | undefined {\n      return this._trainingPhraseUpdate;\n    }\n    set trainingPhraseUpdate(value: StringUpdate | undefined) {\n      this._trainingPhraseUpdate = value;\n    }\n    get entityUpdates(): StringUpdate[] | undefined {\n      return this._entityUpdates;\n    }\n    set entityUpdates(value: StringUpdate[] | undefined) {\n      this._entityUpdates = value;\n    }\n    get entitiesReannotated(): string[] | undefined {\n      return this._entitiesReannotated;\n    }\n    set entitiesReannotated(value: string[] | undefined) {\n      this._entitiesReannotated = value;\n    }\n    get containsUpdateVariable(): boolean | undefined {\n      return this._containsUpdateVariable;\n    }\n    set containsUpdateVariable(value: boolean | undefined) {\n      this._containsUpdateVariable = value;\n    }\n\n    /**\n     * Serialize message to binary data\n     * @param instance message instance\n     */\n    serializeBinary() {\n      const writer = new BinaryWriter();\n      TrainingPhraseUpdate.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(): TrainingPhraseUpdate.AsObject {\n      return {\n        trainingPhraseUpdate: this.trainingPhraseUpdate\n          ? this.trainingPhraseUpdate.toObject()\n          : undefined,\n        entityUpdates: (this.entityUpdates || []).map(m => m.toObject()),\n        entitiesReannotated: (this.entitiesReannotated || []).slice(),\n        containsUpdateVariable: this.containsUpdateVariable\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    ): TrainingPhraseUpdate.AsProtobufJSON {\n      return {\n        trainingPhraseUpdate: this.trainingPhraseUpdate\n          ? this.trainingPhraseUpdate.toProtobufJSON(options)\n          : null,\n        entityUpdates: (this.entityUpdates || []).map(m =>\n          m.toProtobufJSON(options)\n        ),\n        entitiesReannotated: (this.entitiesReannotated || []).slice(),\n        containsUpdateVariable: this.containsUpdateVariable\n      };\n    }\n  }\n  export module TrainingPhraseUpdate {\n    /**\n     * Standard JavaScript object representation for TrainingPhraseUpdate\n     */\n    export interface AsObject {\n      trainingPhraseUpdate?: StringUpdate.AsObject;\n      entityUpdates?: StringUpdate.AsObject[];\n      entitiesReannotated?: string[];\n      containsUpdateVariable?: boolean;\n    }\n\n    /**\n     * Protobuf JSON representation for TrainingPhraseUpdate\n     */\n    export interface AsProtobufJSON {\n      trainingPhraseUpdate?: StringUpdate.AsProtobufJSON | null;\n      entityUpdates?: StringUpdate.AsProtobufJSON[] | null;\n      entitiesReannotated?: string[];\n      containsUpdateVariable?: boolean;\n    }\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.EntityTypeUpdate\n */\nexport class EntityTypeUpdate implements GrpcMessage {\n  static id = 'ondewo.nlu.EntityTypeUpdate';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new EntityTypeUpdate();\n    EntityTypeUpdate.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: EntityTypeUpdate) {\n    _instance.entityTypeName = _instance.entityTypeName || '';\n    _instance.valuesUpdateList = _instance.valuesUpdateList || [];\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: EntityTypeUpdate,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.entityTypeName = _reader.readString();\n          break;\n        case 2:\n          const messageInitializer2 = new EntityTypeUpdate.EntityUpdate();\n          _reader.readMessage(\n            messageInitializer2,\n            EntityTypeUpdate.EntityUpdate.deserializeBinaryFromReader\n          );\n          (_instance.valuesUpdateList = _instance.valuesUpdateList || []).push(\n            messageInitializer2\n          );\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    EntityTypeUpdate.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: EntityTypeUpdate,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.entityTypeName) {\n      _writer.writeString(1, _instance.entityTypeName);\n    }\n    if (_instance.valuesUpdateList && _instance.valuesUpdateList.length) {\n      _writer.writeRepeatedMessage(\n        2,\n        _instance.valuesUpdateList as any,\n        EntityTypeUpdate.EntityUpdate.serializeBinaryToWriter\n      );\n    }\n  }\n\n  private _entityTypeName?: string;\n  private _valuesUpdateList?: EntityTypeUpdate.EntityUpdate[];\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of EntityTypeUpdate to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<EntityTypeUpdate.AsObject>) {\n    _value = _value || {};\n    this.entityTypeName = _value.entityTypeName;\n    this.valuesUpdateList = (_value.valuesUpdateList || []).map(\n      m => new EntityTypeUpdate.EntityUpdate(m)\n    );\n    EntityTypeUpdate.refineValues(this);\n  }\n  get entityTypeName(): string | undefined {\n    return this._entityTypeName;\n  }\n  set entityTypeName(value: string | undefined) {\n    this._entityTypeName = value;\n  }\n  get valuesUpdateList(): EntityTypeUpdate.EntityUpdate[] | undefined {\n    return this._valuesUpdateList;\n  }\n  set valuesUpdateList(value: EntityTypeUpdate.EntityUpdate[] | undefined) {\n    this._valuesUpdateList = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    EntityTypeUpdate.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(): EntityTypeUpdate.AsObject {\n    return {\n      entityTypeName: this.entityTypeName,\n      valuesUpdateList: (this.valuesUpdateList || []).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  ): EntityTypeUpdate.AsProtobufJSON {\n    return {\n      entityTypeName: this.entityTypeName,\n      valuesUpdateList: (this.valuesUpdateList || []).map(m =>\n        m.toProtobufJSON(options)\n      )\n    };\n  }\n}\nexport module EntityTypeUpdate {\n  /**\n   * Standard JavaScript object representation for EntityTypeUpdate\n   */\n  export interface AsObject {\n    entityTypeName?: string;\n    valuesUpdateList?: EntityTypeUpdate.EntityUpdate.AsObject[];\n  }\n\n  /**\n   * Protobuf JSON representation for EntityTypeUpdate\n   */\n  export interface AsProtobufJSON {\n    entityTypeName?: string;\n    valuesUpdateList?: EntityTypeUpdate.EntityUpdate.AsProtobufJSON[] | null;\n  }\n\n  /**\n   * Message implementation for ondewo.nlu.EntityUpdate\n   */\n  export class EntityUpdate implements GrpcMessage {\n    static id = 'ondewo.nlu.EntityUpdate';\n\n    /**\n     * Deserialize binary data to message\n     * @param instance message instance\n     */\n    static deserializeBinary(bytes: ByteSource) {\n      const instance = new EntityUpdate();\n      EntityUpdate.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: EntityUpdate) {\n      _instance.entityValueUpdate = _instance.entityValueUpdate || undefined;\n      _instance.entitySynonymUpdates = _instance.entitySynonymUpdates || [];\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: EntityUpdate,\n      _reader: BinaryReader\n    ) {\n      while (_reader.nextField()) {\n        if (_reader.isEndGroup()) break;\n\n        switch (_reader.getFieldNumber()) {\n          case 1:\n            _instance.entityValueUpdate = new StringUpdate();\n            _reader.readMessage(\n              _instance.entityValueUpdate,\n              StringUpdate.deserializeBinaryFromReader\n            );\n            break;\n          case 2:\n            const messageInitializer2 = new StringUpdate();\n            _reader.readMessage(\n              messageInitializer2,\n              StringUpdate.deserializeBinaryFromReader\n            );\n            (_instance.entitySynonymUpdates =\n              _instance.entitySynonymUpdates || []).push(messageInitializer2);\n            break;\n          default:\n            _reader.skipField();\n        }\n      }\n\n      EntityUpdate.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: EntityUpdate,\n      _writer: BinaryWriter\n    ) {\n      if (_instance.entityValueUpdate) {\n        _writer.writeMessage(\n          1,\n          _instance.entityValueUpdate as any,\n          StringUpdate.serializeBinaryToWriter\n        );\n      }\n      if (\n        _instance.entitySynonymUpdates &&\n        _instance.entitySynonymUpdates.length\n      ) {\n        _writer.writeRepeatedMessage(\n          2,\n          _instance.entitySynonymUpdates as any,\n          StringUpdate.serializeBinaryToWriter\n        );\n      }\n    }\n\n    private _entityValueUpdate?: StringUpdate;\n    private _entitySynonymUpdates?: StringUpdate[];\n\n    /**\n     * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n     * @param _value initial values object or instance of EntityUpdate to deeply clone from\n     */\n    constructor(_value?: RecursivePartial<EntityUpdate.AsObject>) {\n      _value = _value || {};\n      this.entityValueUpdate = _value.entityValueUpdate\n        ? new StringUpdate(_value.entityValueUpdate)\n        : undefined;\n      this.entitySynonymUpdates = (_value.entitySynonymUpdates || []).map(\n        m => new StringUpdate(m)\n      );\n      EntityUpdate.refineValues(this);\n    }\n    get entityValueUpdate(): StringUpdate | undefined {\n      return this._entityValueUpdate;\n    }\n    set entityValueUpdate(value: StringUpdate | undefined) {\n      this._entityValueUpdate = value;\n    }\n    get entitySynonymUpdates(): StringUpdate[] | undefined {\n      return this._entitySynonymUpdates;\n    }\n    set entitySynonymUpdates(value: StringUpdate[] | undefined) {\n      this._entitySynonymUpdates = value;\n    }\n\n    /**\n     * Serialize message to binary data\n     * @param instance message instance\n     */\n    serializeBinary() {\n      const writer = new BinaryWriter();\n      EntityUpdate.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(): EntityUpdate.AsObject {\n      return {\n        entityValueUpdate: this.entityValueUpdate\n          ? this.entityValueUpdate.toObject()\n          : undefined,\n        entitySynonymUpdates: (this.entitySynonymUpdates || []).map(m =>\n          m.toObject()\n        )\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    ): EntityUpdate.AsProtobufJSON {\n      return {\n        entityValueUpdate: this.entityValueUpdate\n          ? this.entityValueUpdate.toProtobufJSON(options)\n          : null,\n        entitySynonymUpdates: (this.entitySynonymUpdates || []).map(m =>\n          m.toProtobufJSON(options)\n        )\n      };\n    }\n  }\n  export module EntityUpdate {\n    /**\n     * Standard JavaScript object representation for EntityUpdate\n     */\n    export interface AsObject {\n      entityValueUpdate?: StringUpdate.AsObject;\n      entitySynonymUpdates?: StringUpdate.AsObject[];\n    }\n\n    /**\n     * Protobuf JSON representation for EntityUpdate\n     */\n    export interface AsProtobufJSON {\n      entityValueUpdate?: StringUpdate.AsProtobufJSON | null;\n      entitySynonymUpdates?: StringUpdate.AsProtobufJSON[] | null;\n    }\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.CleanAllEntityTypesRequest\n */\nexport class CleanAllEntityTypesRequest implements GrpcMessage {\n  static id = 'ondewo.nlu.CleanAllEntityTypesRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new CleanAllEntityTypesRequest();\n    CleanAllEntityTypesRequest.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: CleanAllEntityTypesRequest) {\n    _instance.parent = _instance.parent || '';\n    _instance.languageCode = _instance.languageCode || '';\n    _instance.specialCharacters = _instance.specialCharacters || '';\n    _instance.substringWhiteList = _instance.substringWhiteList || [];\n    _instance.maxEntityCountUpdate = _instance.maxEntityCountUpdate || 0;\n    _instance.forbiddenEntityTypePatterns =\n      _instance.forbiddenEntityTypePatterns || [];\n    _instance.dryRun = _instance.dryRun || false;\n    _instance.numberOfWorkers = _instance.numberOfWorkers || 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: CleanAllEntityTypesRequest,\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.languageCode = _reader.readString();\n          break;\n        case 3:\n          _instance.specialCharacters = _reader.readString();\n          break;\n        case 4:\n          (_instance.substringWhiteList =\n            _instance.substringWhiteList || []).push(_reader.readString());\n          break;\n        case 5:\n          _instance.maxEntityCountUpdate = _reader.readInt32();\n          break;\n        case 6:\n          (_instance.forbiddenEntityTypePatterns =\n            _instance.forbiddenEntityTypePatterns || []).push(\n            _reader.readString()\n          );\n          break;\n        case 7:\n          _instance.dryRun = _reader.readBool();\n          break;\n        case 8:\n          _instance.numberOfWorkers = _reader.readInt32();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    CleanAllEntityTypesRequest.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: CleanAllEntityTypesRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.parent) {\n      _writer.writeString(1, _instance.parent);\n    }\n    if (_instance.languageCode) {\n      _writer.writeString(2, _instance.languageCode);\n    }\n    if (_instance.specialCharacters) {\n      _writer.writeString(3, _instance.specialCharacters);\n    }\n    if (_instance.substringWhiteList && _instance.substringWhiteList.length) {\n      _writer.writeRepeatedString(4, _instance.substringWhiteList);\n    }\n    if (_instance.maxEntityCountUpdate) {\n      _writer.writeInt32(5, _instance.maxEntityCountUpdate);\n    }\n    if (\n      _instance.forbiddenEntityTypePatterns &&\n      _instance.forbiddenEntityTypePatterns.length\n    ) {\n      _writer.writeRepeatedString(6, _instance.forbiddenEntityTypePatterns);\n    }\n    if (_instance.dryRun) {\n      _writer.writeBool(7, _instance.dryRun);\n    }\n    if (_instance.numberOfWorkers) {\n      _writer.writeInt32(8, _instance.numberOfWorkers);\n    }\n  }\n\n  private _parent?: string;\n  private _languageCode?: string;\n  private _specialCharacters?: string;\n  private _substringWhiteList?: string[];\n  private _maxEntityCountUpdate?: number;\n  private _forbiddenEntityTypePatterns?: string[];\n  private _dryRun?: boolean;\n  private _numberOfWorkers?: number;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of CleanAllEntityTypesRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<CleanAllEntityTypesRequest.AsObject>) {\n    _value = _value || {};\n    this.parent = _value.parent;\n    this.languageCode = _value.languageCode;\n    this.specialCharacters = _value.specialCharacters;\n    this.substringWhiteList = (_value.substringWhiteList || []).slice();\n    this.maxEntityCountUpdate = _value.maxEntityCountUpdate;\n    this.forbiddenEntityTypePatterns = (\n      _value.forbiddenEntityTypePatterns || []\n    ).slice();\n    this.dryRun = _value.dryRun;\n    this.numberOfWorkers = _value.numberOfWorkers;\n    CleanAllEntityTypesRequest.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 languageCode(): string | undefined {\n    return this._languageCode;\n  }\n  set languageCode(value: string | undefined) {\n    this._languageCode = value;\n  }\n  get specialCharacters(): string | undefined {\n    return this._specialCharacters;\n  }\n  set specialCharacters(value: string | undefined) {\n    this._specialCharacters = value;\n  }\n  get substringWhiteList(): string[] | undefined {\n    return this._substringWhiteList;\n  }\n  set substringWhiteList(value: string[] | undefined) {\n    this._substringWhiteList = value;\n  }\n  get maxEntityCountUpdate(): number | undefined {\n    return this._maxEntityCountUpdate;\n  }\n  set maxEntityCountUpdate(value: number | undefined) {\n    this._maxEntityCountUpdate = value;\n  }\n  get forbiddenEntityTypePatterns(): string[] | undefined {\n    return this._forbiddenEntityTypePatterns;\n  }\n  set forbiddenEntityTypePatterns(value: string[] | undefined) {\n    this._forbiddenEntityTypePatterns = value;\n  }\n  get dryRun(): boolean | undefined {\n    return this._dryRun;\n  }\n  set dryRun(value: boolean | undefined) {\n    this._dryRun = value;\n  }\n  get numberOfWorkers(): number | undefined {\n    return this._numberOfWorkers;\n  }\n  set numberOfWorkers(value: number | undefined) {\n    this._numberOfWorkers = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    CleanAllEntityTypesRequest.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(): CleanAllEntityTypesRequest.AsObject {\n    return {\n      parent: this.parent,\n      languageCode: this.languageCode,\n      specialCharacters: this.specialCharacters,\n      substringWhiteList: (this.substringWhiteList || []).slice(),\n      maxEntityCountUpdate: this.maxEntityCountUpdate,\n      forbiddenEntityTypePatterns: (\n        this.forbiddenEntityTypePatterns || []\n      ).slice(),\n      dryRun: this.dryRun,\n      numberOfWorkers: this.numberOfWorkers\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  ): CleanAllEntityTypesRequest.AsProtobufJSON {\n    return {\n      parent: this.parent,\n      languageCode: this.languageCode,\n      specialCharacters: this.specialCharacters,\n      substringWhiteList: (this.substringWhiteList || []).slice(),\n      maxEntityCountUpdate: this.maxEntityCountUpdate,\n      forbiddenEntityTypePatterns: (\n        this.forbiddenEntityTypePatterns || []\n      ).slice(),\n      dryRun: this.dryRun,\n      numberOfWorkers: this.numberOfWorkers\n    };\n  }\n}\nexport module CleanAllEntityTypesRequest {\n  /**\n   * Standard JavaScript object representation for CleanAllEntityTypesRequest\n   */\n  export interface AsObject {\n    parent?: string;\n    languageCode?: string;\n    specialCharacters?: string;\n    substringWhiteList?: string[];\n    maxEntityCountUpdate?: number;\n    forbiddenEntityTypePatterns?: string[];\n    dryRun?: boolean;\n    numberOfWorkers?: number;\n  }\n\n  /**\n   * Protobuf JSON representation for CleanAllEntityTypesRequest\n   */\n  export interface AsProtobufJSON {\n    parent?: string;\n    languageCode?: string;\n    specialCharacters?: string;\n    substringWhiteList?: string[];\n    maxEntityCountUpdate?: number;\n    forbiddenEntityTypePatterns?: string[];\n    dryRun?: boolean;\n    numberOfWorkers?: number;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.CleanAllEntityTypesResponse\n */\nexport class CleanAllEntityTypesResponse implements GrpcMessage {\n  static id = 'ondewo.nlu.CleanAllEntityTypesResponse';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new CleanAllEntityTypesResponse();\n    CleanAllEntityTypesResponse.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: CleanAllEntityTypesResponse) {\n    _instance.cleanedEntityTypes = _instance.cleanedEntityTypes || [];\n    _instance.deletedEntityTypes = _instance.deletedEntityTypes || [];\n    _instance.entityTypeUpdates = _instance.entityTypeUpdates || [];\n    _instance.entityTypeDeletions = _instance.entityTypeDeletions || [];\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: CleanAllEntityTypesResponse,\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 ondewoNlu009.EntityType();\n          _reader.readMessage(\n            messageInitializer1,\n            ondewoNlu009.EntityType.deserializeBinaryFromReader\n          );\n          (_instance.cleanedEntityTypes =\n            _instance.cleanedEntityTypes || []).push(messageInitializer1);\n          break;\n        case 2:\n          const messageInitializer2 = new ondewoNlu009.EntityType();\n          _reader.readMessage(\n            messageInitializer2,\n            ondewoNlu009.EntityType.deserializeBinaryFromReader\n          );\n          (_instance.deletedEntityTypes =\n            _instance.deletedEntityTypes || []).push(messageInitializer2);\n          break;\n        case 3:\n          const messageInitializer3 = new EntityTypeUpdate();\n          _reader.readMessage(\n            messageInitializer3,\n            EntityTypeUpdate.deserializeBinaryFromReader\n          );\n          (_instance.entityTypeUpdates =\n            _instance.entityTypeUpdates || []).push(messageInitializer3);\n          break;\n        case 4:\n          const messageInitializer4 = new EntityTypeUpdate();\n          _reader.readMessage(\n            messageInitializer4,\n            EntityTypeUpdate.deserializeBinaryFromReader\n          );\n          (_instance.entityTypeDeletions =\n            _instance.entityTypeDeletions || []).push(messageInitializer4);\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    CleanAllEntityTypesResponse.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: CleanAllEntityTypesResponse,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.cleanedEntityTypes && _instance.cleanedEntityTypes.length) {\n      _writer.writeRepeatedMessage(\n        1,\n        _instance.cleanedEntityTypes as any,\n        ondewoNlu009.EntityType.serializeBinaryToWriter\n      );\n    }\n    if (_instance.deletedEntityTypes && _instance.deletedEntityTypes.length) {\n      _writer.writeRepeatedMessage(\n        2,\n        _instance.deletedEntityTypes as any,\n        ondewoNlu009.EntityType.serializeBinaryToWriter\n      );\n    }\n    if (_instance.entityTypeUpdates && _instance.entityTypeUpdates.length) {\n      _writer.writeRepeatedMessage(\n        3,\n        _instance.entityTypeUpdates as any,\n        EntityTypeUpdate.serializeBinaryToWriter\n      );\n    }\n    if (_instance.entityTypeDeletions && _instance.entityTypeDeletions.length) {\n      _writer.writeRepeatedMessage(\n        4,\n        _instance.entityTypeDeletions as any,\n        EntityTypeUpdate.serializeBinaryToWriter\n      );\n    }\n  }\n\n  private _cleanedEntityTypes?: ondewoNlu009.EntityType[];\n  private _deletedEntityTypes?: ondewoNlu009.EntityType[];\n  private _entityTypeUpdates?: EntityTypeUpdate[];\n  private _entityTypeDeletions?: EntityTypeUpdate[];\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of CleanAllEntityTypesResponse to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<CleanAllEntityTypesResponse.AsObject>) {\n    _value = _value || {};\n    this.cleanedEntityTypes = (_value.cleanedEntityTypes || []).map(\n      m => new ondewoNlu009.EntityType(m)\n    );\n    this.deletedEntityTypes = (_value.deletedEntityTypes || []).map(\n      m => new ondewoNlu009.EntityType(m)\n    );\n    this.entityTypeUpdates = (_value.entityTypeUpdates || []).map(\n      m => new EntityTypeUpdate(m)\n    );\n    this.entityTypeDeletions = (_value.entityTypeDeletions || []).map(\n      m => new EntityTypeUpdate(m)\n    );\n    CleanAllEntityTypesResponse.refineValues(this);\n  }\n  get cleanedEntityTypes(): ondewoNlu009.EntityType[] | undefined {\n    return this._cleanedEntityTypes;\n  }\n  set cleanedEntityTypes(value: ondewoNlu009.EntityType[] | undefined) {\n    this._cleanedEntityTypes = value;\n  }\n  get deletedEntityTypes(): ondewoNlu009.EntityType[] | undefined {\n    return this._deletedEntityTypes;\n  }\n  set deletedEntityTypes(value: ondewoNlu009.EntityType[] | undefined) {\n    this._deletedEntityTypes = value;\n  }\n  get entityTypeUpdates(): EntityTypeUpdate[] | undefined {\n    return this._entityTypeUpdates;\n  }\n  set entityTypeUpdates(value: EntityTypeUpdate[] | undefined) {\n    this._entityTypeUpdates = value;\n  }\n  get entityTypeDeletions(): EntityTypeUpdate[] | undefined {\n    return this._entityTypeDeletions;\n  }\n  set entityTypeDeletions(value: EntityTypeUpdate[] | undefined) {\n    this._entityTypeDeletions = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    CleanAllEntityTypesResponse.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(): CleanAllEntityTypesResponse.AsObject {\n    return {\n      cleanedEntityTypes: (this.cleanedEntityTypes || []).map(m =>\n        m.toObject()\n      ),\n      deletedEntityTypes: (this.deletedEntityTypes || []).map(m =>\n        m.toObject()\n      ),\n      entityTypeUpdates: (this.entityTypeUpdates || []).map(m => m.toObject()),\n      entityTypeDeletions: (this.entityTypeDeletions || []).map(m =>\n        m.toObject()\n      )\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  ): CleanAllEntityTypesResponse.AsProtobufJSON {\n    return {\n      cleanedEntityTypes: (this.cleanedEntityTypes || []).map(m =>\n        m.toProtobufJSON(options)\n      ),\n      deletedEntityTypes: (this.deletedEntityTypes || []).map(m =>\n        m.toProtobufJSON(options)\n      ),\n      entityTypeUpdates: (this.entityTypeUpdates || []).map(m =>\n        m.toProtobufJSON(options)\n      ),\n      entityTypeDeletions: (this.entityTypeDeletions || []).map(m =>\n        m.toProtobufJSON(options)\n      )\n    };\n  }\n}\nexport module CleanAllEntityTypesResponse {\n  /**\n   * Standard JavaScript object representation for CleanAllEntityTypesResponse\n   */\n  export interface AsObject {\n    cleanedEntityTypes?: ondewoNlu009.EntityType.AsObject[];\n    deletedEntityTypes?: ondewoNlu009.EntityType.AsObject[];\n    entityTypeUpdates?: EntityTypeUpdate.AsObject[];\n    entityTypeDeletions?: EntityTypeUpdate.AsObject[];\n  }\n\n  /**\n   * Protobuf JSON representation for CleanAllEntityTypesResponse\n   */\n  export interface AsProtobufJSON {\n    cleanedEntityTypes?: ondewoNlu009.EntityType.AsProtobufJSON[] | null;\n    deletedEntityTypes?: ondewoNlu009.EntityType.AsProtobufJSON[] | null;\n    entityTypeUpdates?: EntityTypeUpdate.AsProtobufJSON[] | null;\n    entityTypeDeletions?: EntityTypeUpdate.AsProtobufJSON[] | null;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.CleanEntityTypeRequest\n */\nexport class CleanEntityTypeRequest implements GrpcMessage {\n  static id = 'ondewo.nlu.CleanEntityTypeRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new CleanEntityTypeRequest();\n    CleanEntityTypeRequest.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: CleanEntityTypeRequest) {\n    _instance.parent = _instance.parent || '';\n    _instance.entityTypeName = _instance.entityTypeName || '';\n    _instance.languageCode = _instance.languageCode || '';\n    _instance.specialCharacters = _instance.specialCharacters || '';\n    _instance.substringWhiteList = _instance.substringWhiteList || [];\n    _instance.maxEntityCountUpdate = _instance.maxEntityCountUpdate || 0;\n    _instance.dryRun = _instance.dryRun || false;\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: CleanEntityTypeRequest,\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.entityTypeName = _reader.readString();\n          break;\n        case 3:\n          _instance.languageCode = _reader.readString();\n          break;\n        case 4:\n          _instance.specialCharacters = _reader.readString();\n          break;\n        case 5:\n          (_instance.substringWhiteList =\n            _instance.substringWhiteList || []).push(_reader.readString());\n          break;\n        case 6:\n          _instance.maxEntityCountUpdate = _reader.readInt32();\n          break;\n        case 7:\n          _instance.dryRun = _reader.readBool();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    CleanEntityTypeRequest.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: CleanEntityTypeRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.parent) {\n      _writer.writeString(1, _instance.parent);\n    }\n    if (_instance.entityTypeName) {\n      _writer.writeString(2, _instance.entityTypeName);\n    }\n    if (_instance.languageCode) {\n      _writer.writeString(3, _instance.languageCode);\n    }\n    if (_instance.specialCharacters) {\n      _writer.writeString(4, _instance.specialCharacters);\n    }\n    if (_instance.substringWhiteList && _instance.substringWhiteList.length) {\n      _writer.writeRepeatedString(5, _instance.substringWhiteList);\n    }\n    if (_instance.maxEntityCountUpdate) {\n      _writer.writeInt32(6, _instance.maxEntityCountUpdate);\n    }\n    if (_instance.dryRun) {\n      _writer.writeBool(7, _instance.dryRun);\n    }\n  }\n\n  private _parent?: string;\n  private _entityTypeName?: string;\n  private _languageCode?: string;\n  private _specialCharacters?: string;\n  private _substringWhiteList?: string[];\n  private _maxEntityCountUpdate?: number;\n  private _dryRun?: boolean;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of CleanEntityTypeRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<CleanEntityTypeRequest.AsObject>) {\n    _value = _value || {};\n    this.parent = _value.parent;\n    this.entityTypeName = _value.entityTypeName;\n    this.languageCode = _value.languageCode;\n    this.specialCharacters = _value.specialCharacters;\n    this.substringWhiteList = (_value.substringWhiteList || []).slice();\n    this.maxEntityCountUpdate = _value.maxEntityCountUpdate;\n    this.dryRun = _value.dryRun;\n    CleanEntityTypeRequest.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 entityTypeName(): string | undefined {\n    return this._entityTypeName;\n  }\n  set entityTypeName(value: string | undefined) {\n    this._entityTypeName = value;\n  }\n  get languageCode(): string | undefined {\n    return this._languageCode;\n  }\n  set languageCode(value: string | undefined) {\n    this._languageCode = value;\n  }\n  get specialCharacters(): string | undefined {\n    return this._specialCharacters;\n  }\n  set specialCharacters(value: string | undefined) {\n    this._specialCharacters = value;\n  }\n  get substringWhiteList(): string[] | undefined {\n    return this._substringWhiteList;\n  }\n  set substringWhiteList(value: string[] | undefined) {\n    this._substringWhiteList = value;\n  }\n  get maxEntityCountUpdate(): number | undefined {\n    return this._maxEntityCountUpdate;\n  }\n  set maxEntityCountUpdate(value: number | undefined) {\n    this._maxEntityCountUpdate = value;\n  }\n  get dryRun(): boolean | undefined {\n    return this._dryRun;\n  }\n  set dryRun(value: boolean | undefined) {\n    this._dryRun = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    CleanEntityTypeRequest.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(): CleanEntityTypeRequest.AsObject {\n    return {\n      parent: this.parent,\n      entityTypeName: this.entityTypeName,\n      languageCode: this.languageCode,\n      specialCharacters: this.specialCharacters,\n      substringWhiteList: (this.substringWhiteList || []).slice(),\n      maxEntityCountUpdate: this.maxEntityCountUpdate,\n      dryRun: this.dryRun\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  ): CleanEntityTypeRequest.AsProtobufJSON {\n    return {\n      parent: this.parent,\n      entityTypeName: this.entityTypeName,\n      languageCode: this.languageCode,\n      specialCharacters: this.specialCharacters,\n      substringWhiteList: (this.substringWhiteList || []).slice(),\n      maxEntityCountUpdate: this.maxEntityCountUpdate,\n      dryRun: this.dryRun\n    };\n  }\n}\nexport module CleanEntityTypeRequest {\n  /**\n   * Standard JavaScript object representation for CleanEntityTypeRequest\n   */\n  export interface AsObject {\n    parent?: string;\n    entityTypeName?: string;\n    languageCode?: string;\n    specialCharacters?: string;\n    substringWhiteList?: string[];\n    maxEntityCountUpdate?: number;\n    dryRun?: boolean;\n  }\n\n  /**\n   * Protobuf JSON representation for CleanEntityTypeRequest\n   */\n  export interface AsProtobufJSON {\n    parent?: string;\n    entityTypeName?: string;\n    languageCode?: string;\n    specialCharacters?: string;\n    substringWhiteList?: string[];\n    maxEntityCountUpdate?: number;\n    dryRun?: boolean;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.CleanEntityTypeResponse\n */\nexport class CleanEntityTypeResponse implements GrpcMessage {\n  static id = 'ondewo.nlu.CleanEntityTypeResponse';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new CleanEntityTypeResponse();\n    CleanEntityTypeResponse.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: CleanEntityTypeResponse) {\n    _instance.cleanedEntityType = _instance.cleanedEntityType || undefined;\n    _instance.entityTypeUpdate = _instance.entityTypeUpdate || 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: CleanEntityTypeResponse,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.cleanedEntityType = new ondewoNlu009.EntityType();\n          _reader.readMessage(\n            _instance.cleanedEntityType,\n            ondewoNlu009.EntityType.deserializeBinaryFromReader\n          );\n          break;\n        case 2:\n          _instance.entityTypeUpdate = new EntityTypeUpdate();\n          _reader.readMessage(\n            _instance.entityTypeUpdate,\n            EntityTypeUpdate.deserializeBinaryFromReader\n          );\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    CleanEntityTypeResponse.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: CleanEntityTypeResponse,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.cleanedEntityType) {\n      _writer.writeMessage(\n        1,\n        _instance.cleanedEntityType as any,\n        ondewoNlu009.EntityType.serializeBinaryToWriter\n      );\n    }\n    if (_instance.entityTypeUpdate) {\n      _writer.writeMessage(\n        2,\n        _instance.entityTypeUpdate as any,\n        EntityTypeUpdate.serializeBinaryToWriter\n      );\n    }\n  }\n\n  private _cleanedEntityType?: ondewoNlu009.EntityType;\n  private _entityTypeUpdate?: EntityTypeUpdate;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of CleanEntityTypeResponse to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<CleanEntityTypeResponse.AsObject>) {\n    _value = _value || {};\n    this.cleanedEntityType = _value.cleanedEntityType\n      ? new ondewoNlu009.EntityType(_value.cleanedEntityType)\n      : undefined;\n    this.entityTypeUpdate = _value.entityTypeUpdate\n      ? new EntityTypeUpdate(_value.entityTypeUpdate)\n      : undefined;\n    CleanEntityTypeResponse.refineValues(this);\n  }\n  get cleanedEntityType(): ondewoNlu009.EntityType | undefined {\n    return this._cleanedEntityType;\n  }\n  set cleanedEntityType(value: ondewoNlu009.EntityType | undefined) {\n    this._cleanedEntityType = value;\n  }\n  get entityTypeUpdate(): EntityTypeUpdate | undefined {\n    return this._entityTypeUpdate;\n  }\n  set entityTypeUpdate(value: EntityTypeUpdate | undefined) {\n    this._entityTypeUpdate = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    CleanEntityTypeResponse.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(): CleanEntityTypeResponse.AsObject {\n    return {\n      cleanedEntityType: this.cleanedEntityType\n        ? this.cleanedEntityType.toObject()\n        : undefined,\n      entityTypeUpdate: this.entityTypeUpdate\n        ? this.entityTypeUpdate.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  ): CleanEntityTypeResponse.AsProtobufJSON {\n    return {\n      cleanedEntityType: this.cleanedEntityType\n        ? this.cleanedEntityType.toProtobufJSON(options)\n        : null,\n      entityTypeUpdate: this.entityTypeUpdate\n        ? this.entityTypeUpdate.toProtobufJSON(options)\n        : null\n    };\n  }\n}\nexport module CleanEntityTypeResponse {\n  /**\n   * Standard JavaScript object representation for CleanEntityTypeResponse\n   */\n  export interface AsObject {\n    cleanedEntityType?: ondewoNlu009.EntityType.AsObject;\n    entityTypeUpdate?: EntityTypeUpdate.AsObject;\n  }\n\n  /**\n   * Protobuf JSON representation for CleanEntityTypeResponse\n   */\n  export interface AsProtobufJSON {\n    cleanedEntityType?: ondewoNlu009.EntityType.AsProtobufJSON | null;\n    entityTypeUpdate?: EntityTypeUpdate.AsProtobufJSON | null;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.AddTrainingPhrasesRequest\n */\nexport class AddTrainingPhrasesRequest implements GrpcMessage {\n  static id = 'ondewo.nlu.AddTrainingPhrasesRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new AddTrainingPhrasesRequest();\n    AddTrainingPhrasesRequest.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: AddTrainingPhrasesRequest) {\n    _instance.parent = _instance.parent || '';\n    _instance.languageCode = _instance.languageCode || '';\n    _instance.trainingPhraseList = _instance.trainingPhraseList || [];\n    _instance.extractEntities = _instance.extractEntities || false;\n    _instance.specialCharacters = _instance.specialCharacters || '';\n    _instance.trainingPhraseCleanerOptions =\n      _instance.trainingPhraseCleanerOptions || undefined;\n    _instance.numberOfWorkers = _instance.numberOfWorkers || 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: AddTrainingPhrasesRequest,\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.languageCode = _reader.readString();\n          break;\n        case 3:\n          const messageInitializer3 = new AddTrainingPhrasesRequest.TrainingPhraseForIntent();\n          _reader.readMessage(\n            messageInitializer3,\n            AddTrainingPhrasesRequest.TrainingPhraseForIntent\n              .deserializeBinaryFromReader\n          );\n          (_instance.trainingPhraseList =\n            _instance.trainingPhraseList || []).push(messageInitializer3);\n          break;\n        case 4:\n          _instance.extractEntities = _reader.readBool();\n          break;\n        case 5:\n          _instance.specialCharacters = _reader.readString();\n          break;\n        case 6:\n          _instance.trainingPhraseCleanerOptions = new TrainingPhraseCleanerOptions();\n          _reader.readMessage(\n            _instance.trainingPhraseCleanerOptions,\n            TrainingPhraseCleanerOptions.deserializeBinaryFromReader\n          );\n          break;\n        case 7:\n          _instance.numberOfWorkers = _reader.readInt32();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    AddTrainingPhrasesRequest.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: AddTrainingPhrasesRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.parent) {\n      _writer.writeString(1, _instance.parent);\n    }\n    if (_instance.languageCode) {\n      _writer.writeString(2, _instance.languageCode);\n    }\n    if (_instance.trainingPhraseList && _instance.trainingPhraseList.length) {\n      _writer.writeRepeatedMessage(\n        3,\n        _instance.trainingPhraseList as any,\n        AddTrainingPhrasesRequest.TrainingPhraseForIntent\n          .serializeBinaryToWriter\n      );\n    }\n    if (_instance.extractEntities) {\n      _writer.writeBool(4, _instance.extractEntities);\n    }\n    if (_instance.specialCharacters) {\n      _writer.writeString(5, _instance.specialCharacters);\n    }\n    if (_instance.trainingPhraseCleanerOptions) {\n      _writer.writeMessage(\n        6,\n        _instance.trainingPhraseCleanerOptions as any,\n        TrainingPhraseCleanerOptions.serializeBinaryToWriter\n      );\n    }\n    if (_instance.numberOfWorkers) {\n      _writer.writeInt32(7, _instance.numberOfWorkers);\n    }\n  }\n\n  private _parent?: string;\n  private _languageCode?: string;\n  private _trainingPhraseList?: AddTrainingPhrasesRequest.TrainingPhraseForIntent[];\n  private _extractEntities?: boolean;\n  private _specialCharacters?: string;\n  private _trainingPhraseCleanerOptions?: TrainingPhraseCleanerOptions;\n  private _numberOfWorkers?: number;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of AddTrainingPhrasesRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<AddTrainingPhrasesRequest.AsObject>) {\n    _value = _value || {};\n    this.parent = _value.parent;\n    this.languageCode = _value.languageCode;\n    this.trainingPhraseList = (_value.trainingPhraseList || []).map(\n      m => new AddTrainingPhrasesRequest.TrainingPhraseForIntent(m)\n    );\n    this.extractEntities = _value.extractEntities;\n    this.specialCharacters = _value.specialCharacters;\n    this.trainingPhraseCleanerOptions = _value.trainingPhraseCleanerOptions\n      ? new TrainingPhraseCleanerOptions(_value.trainingPhraseCleanerOptions)\n      : undefined;\n    this.numberOfWorkers = _value.numberOfWorkers;\n    AddTrainingPhrasesRequest.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 languageCode(): string | undefined {\n    return this._languageCode;\n  }\n  set languageCode(value: string | undefined) {\n    this._languageCode = value;\n  }\n  get trainingPhraseList():\n    | AddTrainingPhrasesRequest.TrainingPhraseForIntent[]\n    | undefined {\n    return this._trainingPhraseList;\n  }\n  set trainingPhraseList(\n    value: AddTrainingPhrasesRequest.TrainingPhraseForIntent[] | undefined\n  ) {\n    this._trainingPhraseList = value;\n  }\n  get extractEntities(): boolean | undefined {\n    return this._extractEntities;\n  }\n  set extractEntities(value: boolean | undefined) {\n    this._extractEntities = value;\n  }\n  get specialCharacters(): string | undefined {\n    return this._specialCharacters;\n  }\n  set specialCharacters(value: string | undefined) {\n    this._specialCharacters = value;\n  }\n  get trainingPhraseCleanerOptions(): TrainingPhraseCleanerOptions | undefined {\n    return this._trainingPhraseCleanerOptions;\n  }\n  set trainingPhraseCleanerOptions(\n    value: TrainingPhraseCleanerOptions | undefined\n  ) {\n    this._trainingPhraseCleanerOptions = value;\n  }\n  get numberOfWorkers(): number | undefined {\n    return this._numberOfWorkers;\n  }\n  set numberOfWorkers(value: number | undefined) {\n    this._numberOfWorkers = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    AddTrainingPhrasesRequest.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(): AddTrainingPhrasesRequest.AsObject {\n    return {\n      parent: this.parent,\n      languageCode: this.languageCode,\n      trainingPhraseList: (this.trainingPhraseList || []).map(m =>\n        m.toObject()\n      ),\n      extractEntities: this.extractEntities,\n      specialCharacters: this.specialCharacters,\n      trainingPhraseCleanerOptions: this.trainingPhraseCleanerOptions\n        ? this.trainingPhraseCleanerOptions.toObject()\n        : undefined,\n      numberOfWorkers: this.numberOfWorkers\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  ): AddTrainingPhrasesRequest.AsProtobufJSON {\n    return {\n      parent: this.parent,\n      languageCode: this.languageCode,\n      trainingPhraseList: (this.trainingPhraseList || []).map(m =>\n        m.toProtobufJSON(options)\n      ),\n      extractEntities: this.extractEntities,\n      specialCharacters: this.specialCharacters,\n      trainingPhraseCleanerOptions: this.trainingPhraseCleanerOptions\n        ? this.trainingPhraseCleanerOptions.toProtobufJSON(options)\n        : null,\n      numberOfWorkers: this.numberOfWorkers\n    };\n  }\n}\nexport module AddTrainingPhrasesRequest {\n  /**\n   * Standard JavaScript object representation for AddTrainingPhrasesRequest\n   */\n  export interface AsObject {\n    parent?: string;\n    languageCode?: string;\n    trainingPhraseList?: AddTrainingPhrasesRequest.TrainingPhraseForIntent.AsObject[];\n    extractEntities?: boolean;\n    specialCharacters?: string;\n    trainingPhraseCleanerOptions?: TrainingPhraseCleanerOptions.AsObject;\n    numberOfWorkers?: number;\n  }\n\n  /**\n   * Protobuf JSON representation for AddTrainingPhrasesRequest\n   */\n  export interface AsProtobufJSON {\n    parent?: string;\n    languageCode?: string;\n    trainingPhraseList?:\n      | AddTrainingPhrasesRequest.TrainingPhraseForIntent.AsProtobufJSON[]\n      | null;\n    extractEntities?: boolean;\n    specialCharacters?: string;\n    trainingPhraseCleanerOptions?: TrainingPhraseCleanerOptions.AsProtobufJSON | null;\n    numberOfWorkers?: number;\n  }\n\n  /**\n   * Message implementation for ondewo.nlu.TrainingPhraseForIntent\n   */\n  export class TrainingPhraseForIntent implements GrpcMessage {\n    static id = 'ondewo.nlu.TrainingPhraseForIntent';\n\n    /**\n     * Deserialize binary data to message\n     * @param instance message instance\n     */\n    static deserializeBinary(bytes: ByteSource) {\n      const instance = new TrainingPhraseForIntent();\n      TrainingPhraseForIntent.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: TrainingPhraseForIntent) {\n      _instance.trainingPhrase = _instance.trainingPhrase || '';\n      _instance.intentDisplayName = _instance.intentDisplayName || '';\n      _instance.entities = _instance.entities || [];\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: TrainingPhraseForIntent,\n      _reader: BinaryReader\n    ) {\n      while (_reader.nextField()) {\n        if (_reader.isEndGroup()) break;\n\n        switch (_reader.getFieldNumber()) {\n          case 1:\n            _instance.trainingPhrase = _reader.readString();\n            break;\n          case 2:\n            _instance.intentDisplayName = _reader.readString();\n            break;\n          case 3:\n            const messageInitializer3 = new ondewoNlu008.Intent.TrainingPhrase.Entity();\n            _reader.readMessage(\n              messageInitializer3,\n              ondewoNlu008.Intent.TrainingPhrase.Entity\n                .deserializeBinaryFromReader\n            );\n            (_instance.entities = _instance.entities || []).push(\n              messageInitializer3\n            );\n            break;\n          default:\n            _reader.skipField();\n        }\n      }\n\n      TrainingPhraseForIntent.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: TrainingPhraseForIntent,\n      _writer: BinaryWriter\n    ) {\n      if (_instance.trainingPhrase) {\n        _writer.writeString(1, _instance.trainingPhrase);\n      }\n      if (_instance.intentDisplayName) {\n        _writer.writeString(2, _instance.intentDisplayName);\n      }\n      if (_instance.entities && _instance.entities.length) {\n        _writer.writeRepeatedMessage(\n          3,\n          _instance.entities as any,\n          ondewoNlu008.Intent.TrainingPhrase.Entity.serializeBinaryToWriter\n        );\n      }\n    }\n\n    private _trainingPhrase?: string;\n    private _intentDisplayName?: string;\n    private _entities?: ondewoNlu008.Intent.TrainingPhrase.Entity[];\n\n    /**\n     * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n     * @param _value initial values object or instance of TrainingPhraseForIntent to deeply clone from\n     */\n    constructor(_value?: RecursivePartial<TrainingPhraseForIntent.AsObject>) {\n      _value = _value || {};\n      this.trainingPhrase = _value.trainingPhrase;\n      this.intentDisplayName = _value.intentDisplayName;\n      this.entities = (_value.entities || []).map(\n        m => new ondewoNlu008.Intent.TrainingPhrase.Entity(m)\n      );\n      TrainingPhraseForIntent.refineValues(this);\n    }\n    get trainingPhrase(): string | undefined {\n      return this._trainingPhrase;\n    }\n    set trainingPhrase(value: string | undefined) {\n      this._trainingPhrase = value;\n    }\n    get intentDisplayName(): string | undefined {\n      return this._intentDisplayName;\n    }\n    set intentDisplayName(value: string | undefined) {\n      this._intentDisplayName = value;\n    }\n    get entities(): ondewoNlu008.Intent.TrainingPhrase.Entity[] | undefined {\n      return this._entities;\n    }\n    set entities(\n      value: ondewoNlu008.Intent.TrainingPhrase.Entity[] | undefined\n    ) {\n      this._entities = value;\n    }\n\n    /**\n     * Serialize message to binary data\n     * @param instance message instance\n     */\n    serializeBinary() {\n      const writer = new BinaryWriter();\n      TrainingPhraseForIntent.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(): TrainingPhraseForIntent.AsObject {\n      return {\n        trainingPhrase: this.trainingPhrase,\n        intentDisplayName: this.intentDisplayName,\n        entities: (this.entities || []).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    ): TrainingPhraseForIntent.AsProtobufJSON {\n      return {\n        trainingPhrase: this.trainingPhrase,\n        intentDisplayName: this.intentDisplayName,\n        entities: (this.entities || []).map(m => m.toProtobufJSON(options))\n      };\n    }\n  }\n  export module TrainingPhraseForIntent {\n    /**\n     * Standard JavaScript object representation for TrainingPhraseForIntent\n     */\n    export interface AsObject {\n      trainingPhrase?: string;\n      intentDisplayName?: string;\n      entities?: ondewoNlu008.Intent.TrainingPhrase.Entity.AsObject[];\n    }\n\n    /**\n     * Protobuf JSON representation for TrainingPhraseForIntent\n     */\n    export interface AsProtobufJSON {\n      trainingPhrase?: string;\n      intentDisplayName?: string;\n      entities?:\n        | ondewoNlu008.Intent.TrainingPhrase.Entity.AsProtobufJSON[]\n        | null;\n    }\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.AddTrainingPhrasesResponse\n */\nexport class AddTrainingPhrasesResponse implements GrpcMessage {\n  static id = 'ondewo.nlu.AddTrainingPhrasesResponse';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new AddTrainingPhrasesResponse();\n    AddTrainingPhrasesResponse.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: AddTrainingPhrasesResponse) {\n    _instance.errorMessages = _instance.errorMessages || [];\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: AddTrainingPhrasesResponse,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          (_instance.errorMessages = _instance.errorMessages || []).push(\n            _reader.readString()\n          );\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    AddTrainingPhrasesResponse.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: AddTrainingPhrasesResponse,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.errorMessages && _instance.errorMessages.length) {\n      _writer.writeRepeatedString(1, _instance.errorMessages);\n    }\n  }\n\n  private _errorMessages?: 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 AddTrainingPhrasesResponse to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<AddTrainingPhrasesResponse.AsObject>) {\n    _value = _value || {};\n    this.errorMessages = (_value.errorMessages || []).slice();\n    AddTrainingPhrasesResponse.refineValues(this);\n  }\n  get errorMessages(): string[] | undefined {\n    return this._errorMessages;\n  }\n  set errorMessages(value: string[] | undefined) {\n    this._errorMessages = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    AddTrainingPhrasesResponse.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(): AddTrainingPhrasesResponse.AsObject {\n    return {\n      errorMessages: (this.errorMessages || []).slice()\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  ): AddTrainingPhrasesResponse.AsProtobufJSON {\n    return {\n      errorMessages: (this.errorMessages || []).slice()\n    };\n  }\n}\nexport module AddTrainingPhrasesResponse {\n  /**\n   * Standard JavaScript object representation for AddTrainingPhrasesResponse\n   */\n  export interface AsObject {\n    errorMessages?: string[];\n  }\n\n  /**\n   * Protobuf JSON representation for AddTrainingPhrasesResponse\n   */\n  export interface AsProtobufJSON {\n    errorMessages?: string[];\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.AddTrainingPhrasesFromCSVRequest\n */\nexport class AddTrainingPhrasesFromCSVRequest implements GrpcMessage {\n  static id = 'ondewo.nlu.AddTrainingPhrasesFromCSVRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new AddTrainingPhrasesFromCSVRequest();\n    AddTrainingPhrasesFromCSVRequest.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: AddTrainingPhrasesFromCSVRequest) {\n    _instance.parent = _instance.parent || '';\n    _instance.languageCode = _instance.languageCode || '';\n    _instance.csvContents = _instance.csvContents || new Uint8Array();\n    _instance.extractEntities = _instance.extractEntities || false;\n    _instance.specialCharacters = _instance.specialCharacters || '';\n    _instance.trainingPhraseCleanerOptions =\n      _instance.trainingPhraseCleanerOptions || undefined;\n    _instance.numberOfWorkers = _instance.numberOfWorkers || 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: AddTrainingPhrasesFromCSVRequest,\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.languageCode = _reader.readString();\n          break;\n        case 3:\n          _instance.csvContents = _reader.readBytes();\n          break;\n        case 4:\n          _instance.extractEntities = _reader.readBool();\n          break;\n        case 5:\n          _instance.specialCharacters = _reader.readString();\n          break;\n        case 6:\n          _instance.trainingPhraseCleanerOptions = new TrainingPhraseCleanerOptions();\n          _reader.readMessage(\n            _instance.trainingPhraseCleanerOptions,\n            TrainingPhraseCleanerOptions.deserializeBinaryFromReader\n          );\n          break;\n        case 7:\n          _instance.numberOfWorkers = _reader.readInt32();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    AddTrainingPhrasesFromCSVRequest.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: AddTrainingPhrasesFromCSVRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.parent) {\n      _writer.writeString(1, _instance.parent);\n    }\n    if (_instance.languageCode) {\n      _writer.writeString(2, _instance.languageCode);\n    }\n    if (_instance.csvContents && _instance.csvContents.length) {\n      _writer.writeBytes(3, _instance.csvContents);\n    }\n    if (_instance.extractEntities) {\n      _writer.writeBool(4, _instance.extractEntities);\n    }\n    if (_instance.specialCharacters) {\n      _writer.writeString(5, _instance.specialCharacters);\n    }\n    if (_instance.trainingPhraseCleanerOptions) {\n      _writer.writeMessage(\n        6,\n        _instance.trainingPhraseCleanerOptions as any,\n        TrainingPhraseCleanerOptions.serializeBinaryToWriter\n      );\n    }\n    if (_instance.numberOfWorkers) {\n      _writer.writeInt32(7, _instance.numberOfWorkers);\n    }\n  }\n\n  private _parent?: string;\n  private _languageCode?: string;\n  private _csvContents?: Uint8Array;\n  private _extractEntities?: boolean;\n  private _specialCharacters?: string;\n  private _trainingPhraseCleanerOptions?: TrainingPhraseCleanerOptions;\n  private _numberOfWorkers?: number;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of AddTrainingPhrasesFromCSVRequest to deeply clone from\n   */\n  constructor(\n    _value?: RecursivePartial<AddTrainingPhrasesFromCSVRequest.AsObject>\n  ) {\n    _value = _value || {};\n    this.parent = _value.parent;\n    this.languageCode = _value.languageCode;\n    this.csvContents = _value.csvContents;\n    this.extractEntities = _value.extractEntities;\n    this.specialCharacters = _value.specialCharacters;\n    this.trainingPhraseCleanerOptions = _value.trainingPhraseCleanerOptions\n      ? new TrainingPhraseCleanerOptions(_value.trainingPhraseCleanerOptions)\n      : undefined;\n    this.numberOfWorkers = _value.numberOfWorkers;\n    AddTrainingPhrasesFromCSVRequest.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 languageCode(): string | undefined {\n    return this._languageCode;\n  }\n  set languageCode(value: string | undefined) {\n    this._languageCode = value;\n  }\n  get csvContents(): Uint8Array | undefined {\n    return this._csvContents;\n  }\n  set csvContents(value: Uint8Array | undefined) {\n    this._csvContents = value;\n  }\n  get extractEntities(): boolean | undefined {\n    return this._extractEntities;\n  }\n  set extractEntities(value: boolean | undefined) {\n    this._extractEntities = value;\n  }\n  get specialCharacters(): string | undefined {\n    return this._specialCharacters;\n  }\n  set specialCharacters(value: string | undefined) {\n    this._specialCharacters = value;\n  }\n  get trainingPhraseCleanerOptions(): TrainingPhraseCleanerOptions | undefined {\n    return this._trainingPhraseCleanerOptions;\n  }\n  set trainingPhraseCleanerOptions(\n    value: TrainingPhraseCleanerOptions | undefined\n  ) {\n    this._trainingPhraseCleanerOptions = value;\n  }\n  get numberOfWorkers(): number | undefined {\n    return this._numberOfWorkers;\n  }\n  set numberOfWorkers(value: number | undefined) {\n    this._numberOfWorkers = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    AddTrainingPhrasesFromCSVRequest.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(): AddTrainingPhrasesFromCSVRequest.AsObject {\n    return {\n      parent: this.parent,\n      languageCode: this.languageCode,\n      csvContents: this.csvContents\n        ? this.csvContents.subarray(0)\n        : new Uint8Array(),\n      extractEntities: this.extractEntities,\n      specialCharacters: this.specialCharacters,\n      trainingPhraseCleanerOptions: this.trainingPhraseCleanerOptions\n        ? this.trainingPhraseCleanerOptions.toObject()\n        : undefined,\n      numberOfWorkers: this.numberOfWorkers\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  ): AddTrainingPhrasesFromCSVRequest.AsProtobufJSON {\n    return {\n      parent: this.parent,\n      languageCode: this.languageCode,\n      csvContents: this.csvContents ? uint8ArrayToBase64(this.csvContents) : '',\n      extractEntities: this.extractEntities,\n      specialCharacters: this.specialCharacters,\n      trainingPhraseCleanerOptions: this.trainingPhraseCleanerOptions\n        ? this.trainingPhraseCleanerOptions.toProtobufJSON(options)\n        : null,\n      numberOfWorkers: this.numberOfWorkers\n    };\n  }\n}\nexport module AddTrainingPhrasesFromCSVRequest {\n  /**\n   * Standard JavaScript object representation for AddTrainingPhrasesFromCSVRequest\n   */\n  export interface AsObject {\n    parent?: string;\n    languageCode?: string;\n    csvContents?: Uint8Array;\n    extractEntities?: boolean;\n    specialCharacters?: string;\n    trainingPhraseCleanerOptions?: TrainingPhraseCleanerOptions.AsObject;\n    numberOfWorkers?: number;\n  }\n\n  /**\n   * Protobuf JSON representation for AddTrainingPhrasesFromCSVRequest\n   */\n  export interface AsProtobufJSON {\n    parent?: string;\n    languageCode?: string;\n    csvContents?: string;\n    extractEntities?: boolean;\n    specialCharacters?: string;\n    trainingPhraseCleanerOptions?: TrainingPhraseCleanerOptions.AsProtobufJSON | null;\n    numberOfWorkers?: number;\n  }\n}\n"]}