@ondewo/csi-client-angular 2.3.1

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

@@ -0,0 +1,1003 @@
+import { BinaryReader, BinaryWriter } from 'google-protobuf';
+import * as googleProtobuf002 from '@ngx-grpc/well-known-types';
+import * as googleProtobuf003 from '@ngx-grpc/well-known-types';
+import * as googleRpc006 from '../../google/rpc/status.pb';
+import * as ondewoNlu007 from '../../ondewo/nlu/operation-metadata.pb';
+/**
+ * Message implementation for ondewo.nlu.Operation
+ */
+export class Operation {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of Operation to deeply clone from
+     */
+    constructor(_value) {
+        this._result = Operation.ResultCase.none;
+        _value = _value || {};
+        this.name = _value.name;
+        this.metadata = _value.metadata
+            ? new googleProtobuf002.Any(_value.metadata)
+            : undefined;
+        this.done = _value.done;
+        this.error = _value.error
+            ? new googleRpc006.Status(_value.error)
+            : undefined;
+        this.response = _value.response
+            ? new googleProtobuf002.Any(_value.response)
+            : undefined;
+        Operation.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new Operation();
+        Operation.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+        return instance;
+    }
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance) {
+        _instance.name = _instance.name || '';
+        _instance.metadata = _instance.metadata || undefined;
+        _instance.done = _instance.done || 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.name = _reader.readString();
+                    break;
+                case 2:
+                    _instance.metadata = new googleProtobuf002.Any();
+                    _reader.readMessage(_instance.metadata, googleProtobuf002.Any.deserializeBinaryFromReader);
+                    break;
+                case 3:
+                    _instance.done = _reader.readBool();
+                    break;
+                case 4:
+                    _instance.error = new googleRpc006.Status();
+                    _reader.readMessage(_instance.error, googleRpc006.Status.deserializeBinaryFromReader);
+                    break;
+                case 5:
+                    _instance.response = new googleProtobuf002.Any();
+                    _reader.readMessage(_instance.response, googleProtobuf002.Any.deserializeBinaryFromReader);
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        Operation.refineValues(_instance);
+    }
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance, _writer) {
+        if (_instance.name) {
+            _writer.writeString(1, _instance.name);
+        }
+        if (_instance.metadata) {
+            _writer.writeMessage(2, _instance.metadata, googleProtobuf002.Any.serializeBinaryToWriter);
+        }
+        if (_instance.done) {
+            _writer.writeBool(3, _instance.done);
+        }
+        if (_instance.error) {
+            _writer.writeMessage(4, _instance.error, googleRpc006.Status.serializeBinaryToWriter);
+        }
+        if (_instance.response) {
+            _writer.writeMessage(5, _instance.response, googleProtobuf002.Any.serializeBinaryToWriter);
+        }
+    }
+    get name() {
+        return this._name;
+    }
+    set name(value) {
+        this._name = value;
+    }
+    get metadata() {
+        return this._metadata;
+    }
+    set metadata(value) {
+        this._metadata = value;
+    }
+    get done() {
+        return this._done;
+    }
+    set done(value) {
+        this._done = value;
+    }
+    get error() {
+        return this._error;
+    }
+    set error(value) {
+        if (value !== undefined && value !== null) {
+            this._response = undefined;
+            this._result = Operation.ResultCase.error;
+        }
+        this._error = value;
+    }
+    get response() {
+        return this._response;
+    }
+    set response(value) {
+        if (value !== undefined && value !== null) {
+            this._error = undefined;
+            this._result = Operation.ResultCase.response;
+        }
+        this._response = value;
+    }
+    get result() {
+        return this._result;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        Operation.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            name: this.name,
+            metadata: this.metadata ? this.metadata.toObject() : undefined,
+            done: this.done,
+            error: this.error ? this.error.toObject() : undefined,
+            response: this.response ? this.response.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 {
+            name: this.name,
+            metadata: this.metadata ? this.metadata.toProtobufJSON(options) : null,
+            done: this.done,
+            error: this.error ? this.error.toProtobufJSON(options) : null,
+            response: this.response ? this.response.toProtobufJSON(options) : null
+        };
+    }
+}
+Operation.id = 'ondewo.nlu.Operation';
+(function (Operation) {
+    let ResultCase;
+    (function (ResultCase) {
+        ResultCase[ResultCase["none"] = 0] = "none";
+        ResultCase[ResultCase["error"] = 1] = "error";
+        ResultCase[ResultCase["response"] = 2] = "response";
+    })(ResultCase = Operation.ResultCase || (Operation.ResultCase = {}));
+})(Operation || (Operation = {}));
+/**
+ * Message implementation for ondewo.nlu.GetOperationRequest
+ */
+export class GetOperationRequest {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of GetOperationRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.name = _value.name;
+        GetOperationRequest.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new GetOperationRequest();
+        GetOperationRequest.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+        return instance;
+    }
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance) {
+        _instance.name = _instance.name || '';
+    }
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance, _reader) {
+        while (_reader.nextField()) {
+            if (_reader.isEndGroup())
+                break;
+            switch (_reader.getFieldNumber()) {
+                case 1:
+                    _instance.name = _reader.readString();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        GetOperationRequest.refineValues(_instance);
+    }
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance, _writer) {
+        if (_instance.name) {
+            _writer.writeString(1, _instance.name);
+        }
+    }
+    get name() {
+        return this._name;
+    }
+    set name(value) {
+        this._name = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        GetOperationRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            name: this.name
+        };
+    }
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON() {
+        return this.toObject();
+    }
+    /**
+     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+     */
+    toProtobufJSON(
+    // @ts-ignore
+    options) {
+        return {
+            name: this.name
+        };
+    }
+}
+GetOperationRequest.id = 'ondewo.nlu.GetOperationRequest';
+/**
+ * Message implementation for ondewo.nlu.ListOperationsRequest
+ */
+export class ListOperationsRequest {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of ListOperationsRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.name = _value.name;
+        this.filter = _value.filter;
+        this.pageSize = _value.pageSize;
+        this.pageToken = _value.pageToken;
+        this.operationFilter = _value.operationFilter
+            ? new OperationFilter(_value.operationFilter)
+            : undefined;
+        ListOperationsRequest.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new ListOperationsRequest();
+        ListOperationsRequest.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+        return instance;
+    }
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance) {
+        _instance.name = _instance.name || '';
+        _instance.filter = _instance.filter || '';
+        _instance.pageSize = _instance.pageSize || 0;
+        _instance.pageToken = _instance.pageToken || '';
+        _instance.operationFilter = _instance.operationFilter || 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 4:
+                    _instance.name = _reader.readString();
+                    break;
+                case 1:
+                    _instance.filter = _reader.readString();
+                    break;
+                case 2:
+                    _instance.pageSize = _reader.readInt32();
+                    break;
+                case 3:
+                    _instance.pageToken = _reader.readString();
+                    break;
+                case 5:
+                    _instance.operationFilter = new OperationFilter();
+                    _reader.readMessage(_instance.operationFilter, OperationFilter.deserializeBinaryFromReader);
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        ListOperationsRequest.refineValues(_instance);
+    }
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance, _writer) {
+        if (_instance.name) {
+            _writer.writeString(4, _instance.name);
+        }
+        if (_instance.filter) {
+            _writer.writeString(1, _instance.filter);
+        }
+        if (_instance.pageSize) {
+            _writer.writeInt32(2, _instance.pageSize);
+        }
+        if (_instance.pageToken) {
+            _writer.writeString(3, _instance.pageToken);
+        }
+        if (_instance.operationFilter) {
+            _writer.writeMessage(5, _instance.operationFilter, OperationFilter.serializeBinaryToWriter);
+        }
+    }
+    get name() {
+        return this._name;
+    }
+    set name(value) {
+        this._name = value;
+    }
+    get filter() {
+        return this._filter;
+    }
+    set filter(value) {
+        this._filter = value;
+    }
+    get pageSize() {
+        return this._pageSize;
+    }
+    set pageSize(value) {
+        this._pageSize = value;
+    }
+    get pageToken() {
+        return this._pageToken;
+    }
+    set pageToken(value) {
+        this._pageToken = value;
+    }
+    get operationFilter() {
+        return this._operationFilter;
+    }
+    set operationFilter(value) {
+        this._operationFilter = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        ListOperationsRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            name: this.name,
+            filter: this.filter,
+            pageSize: this.pageSize,
+            pageToken: this.pageToken,
+            operationFilter: this.operationFilter
+                ? this.operationFilter.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 {
+            name: this.name,
+            filter: this.filter,
+            pageSize: this.pageSize,
+            pageToken: this.pageToken,
+            operationFilter: this.operationFilter
+                ? this.operationFilter.toProtobufJSON(options)
+                : null
+        };
+    }
+}
+ListOperationsRequest.id = 'ondewo.nlu.ListOperationsRequest';
+/**
+ * Message implementation for ondewo.nlu.OperationFilter
+ */
+export class OperationFilter {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of OperationFilter to deeply clone from
+     */
+    constructor(_value) {
+        this._startTimeOneof = OperationFilter.StartTimeOneofCase.none;
+        this._endTimeOneof = OperationFilter.EndTimeOneofCase.none;
+        _value = _value || {};
+        this.projectParents = (_value.projectParents || []).slice();
+        this.statuses = (_value.statuses || []).slice();
+        this.types = (_value.types || []).slice();
+        this.startTime = _value.startTime
+            ? new googleProtobuf003.Timestamp(_value.startTime)
+            : undefined;
+        this.endTime = _value.endTime
+            ? new googleProtobuf003.Timestamp(_value.endTime)
+            : undefined;
+        this.userIds = (_value.userIds || []).slice();
+        OperationFilter.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new OperationFilter();
+        OperationFilter.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.projectParents = _instance.projectParents || [];
+        _instance.statuses = _instance.statuses || [];
+        _instance.types = _instance.types || [];
+        _instance.userIds = _instance.userIds || [];
+    }
+    /**
+     * 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.projectParents = _instance.projectParents || []).push(_reader.readString());
+                    break;
+                case 2:
+                    (_instance.statuses = _instance.statuses || []).push(...(_reader.readPackedEnum() || []));
+                    break;
+                case 3:
+                    (_instance.types = _instance.types || []).push(...(_reader.readPackedEnum() || []));
+                    break;
+                case 4:
+                    _instance.startTime = new googleProtobuf003.Timestamp();
+                    _reader.readMessage(_instance.startTime, googleProtobuf003.Timestamp.deserializeBinaryFromReader);
+                    break;
+                case 5:
+                    _instance.endTime = new googleProtobuf003.Timestamp();
+                    _reader.readMessage(_instance.endTime, googleProtobuf003.Timestamp.deserializeBinaryFromReader);
+                    break;
+                case 6:
+                    (_instance.userIds = _instance.userIds || []).push(_reader.readString());
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        OperationFilter.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.projectParents && _instance.projectParents.length) {
+            _writer.writeRepeatedString(1, _instance.projectParents);
+        }
+        if (_instance.statuses && _instance.statuses.length) {
+            _writer.writePackedEnum(2, _instance.statuses);
+        }
+        if (_instance.types && _instance.types.length) {
+            _writer.writePackedEnum(3, _instance.types);
+        }
+        if (_instance.startTime) {
+            _writer.writeMessage(4, _instance.startTime, googleProtobuf003.Timestamp.serializeBinaryToWriter);
+        }
+        if (_instance.endTime) {
+            _writer.writeMessage(5, _instance.endTime, googleProtobuf003.Timestamp.serializeBinaryToWriter);
+        }
+        if (_instance.userIds && _instance.userIds.length) {
+            _writer.writeRepeatedString(6, _instance.userIds);
+        }
+    }
+    get projectParents() {
+        return this._projectParents;
+    }
+    set projectParents(value) {
+        this._projectParents = value;
+    }
+    get statuses() {
+        return this._statuses;
+    }
+    set statuses(value) {
+        this._statuses = value;
+    }
+    get types() {
+        return this._types;
+    }
+    set types(value) {
+        this._types = value;
+    }
+    get startTime() {
+        return this._startTime;
+    }
+    set startTime(value) {
+        if (value !== undefined && value !== null) {
+            this._startTimeOneof = OperationFilter.StartTimeOneofCase.startTime;
+        }
+        this._startTime = value;
+    }
+    get endTime() {
+        return this._endTime;
+    }
+    set endTime(value) {
+        if (value !== undefined && value !== null) {
+            this._endTimeOneof = OperationFilter.EndTimeOneofCase.endTime;
+        }
+        this._endTime = value;
+    }
+    get userIds() {
+        return this._userIds;
+    }
+    set userIds(value) {
+        this._userIds = value;
+    }
+    get startTimeOneof() {
+        return this._startTimeOneof;
+    }
+    get endTimeOneof() {
+        return this._endTimeOneof;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        OperationFilter.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            projectParents: (this.projectParents || []).slice(),
+            statuses: (this.statuses || []).slice(),
+            types: (this.types || []).slice(),
+            startTime: this.startTime ? this.startTime.toObject() : undefined,
+            endTime: this.endTime ? this.endTime.toObject() : undefined,
+            userIds: (this.userIds || []).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 {
+            projectParents: (this.projectParents || []).slice(),
+            statuses: (this.statuses || []).map(v => ondewoNlu007.OperationMetadata.Status[v]),
+            types: (this.types || []).map(v => ondewoNlu007.OperationMetadata.OperationType[v]),
+            startTime: this.startTime ? this.startTime.toProtobufJSON(options) : null,
+            endTime: this.endTime ? this.endTime.toProtobufJSON(options) : null,
+            userIds: (this.userIds || []).slice()
+        };
+    }
+}
+OperationFilter.id = 'ondewo.nlu.OperationFilter';
+(function (OperationFilter) {
+    let StartTimeOneofCase;
+    (function (StartTimeOneofCase) {
+        StartTimeOneofCase[StartTimeOneofCase["none"] = 0] = "none";
+        StartTimeOneofCase[StartTimeOneofCase["startTime"] = 1] = "startTime";
+    })(StartTimeOneofCase = OperationFilter.StartTimeOneofCase || (OperationFilter.StartTimeOneofCase = {}));
+    let EndTimeOneofCase;
+    (function (EndTimeOneofCase) {
+        EndTimeOneofCase[EndTimeOneofCase["none"] = 0] = "none";
+        EndTimeOneofCase[EndTimeOneofCase["endTime"] = 1] = "endTime";
+    })(EndTimeOneofCase = OperationFilter.EndTimeOneofCase || (OperationFilter.EndTimeOneofCase = {}));
+})(OperationFilter || (OperationFilter = {}));
+/**
+ * Message implementation for ondewo.nlu.ListOperationsResponse
+ */
+export class ListOperationsResponse {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of ListOperationsResponse to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.operations = (_value.operations || []).map(m => new Operation(m));
+        this.nextPageToken = _value.nextPageToken;
+        ListOperationsResponse.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new ListOperationsResponse();
+        ListOperationsResponse.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.operations = _instance.operations || [];
+        _instance.nextPageToken = _instance.nextPageToken || '';
+    }
+    /**
+     * 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 Operation();
+                    _reader.readMessage(messageInitializer1, Operation.deserializeBinaryFromReader);
+                    (_instance.operations = _instance.operations || []).push(messageInitializer1);
+                    break;
+                case 2:
+                    _instance.nextPageToken = _reader.readString();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        ListOperationsResponse.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.operations && _instance.operations.length) {
+            _writer.writeRepeatedMessage(1, _instance.operations, Operation.serializeBinaryToWriter);
+        }
+        if (_instance.nextPageToken) {
+            _writer.writeString(2, _instance.nextPageToken);
+        }
+    }
+    get operations() {
+        return this._operations;
+    }
+    set operations(value) {
+        this._operations = value;
+    }
+    get nextPageToken() {
+        return this._nextPageToken;
+    }
+    set nextPageToken(value) {
+        this._nextPageToken = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        ListOperationsResponse.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            operations: (this.operations || []).map(m => m.toObject()),
+            nextPageToken: this.nextPageToken
+        };
+    }
+    /**
+     * 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 {
+            operations: (this.operations || []).map(m => m.toProtobufJSON(options)),
+            nextPageToken: this.nextPageToken
+        };
+    }
+}
+ListOperationsResponse.id = 'ondewo.nlu.ListOperationsResponse';
+/**
+ * Message implementation for ondewo.nlu.CancelOperationRequest
+ */
+export class CancelOperationRequest {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of CancelOperationRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.name = _value.name;
+        CancelOperationRequest.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new CancelOperationRequest();
+        CancelOperationRequest.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+        return instance;
+    }
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance) {
+        _instance.name = _instance.name || '';
+    }
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance, _reader) {
+        while (_reader.nextField()) {
+            if (_reader.isEndGroup())
+                break;
+            switch (_reader.getFieldNumber()) {
+                case 1:
+                    _instance.name = _reader.readString();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        CancelOperationRequest.refineValues(_instance);
+    }
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance, _writer) {
+        if (_instance.name) {
+            _writer.writeString(1, _instance.name);
+        }
+    }
+    get name() {
+        return this._name;
+    }
+    set name(value) {
+        this._name = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        CancelOperationRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            name: this.name
+        };
+    }
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON() {
+        return this.toObject();
+    }
+    /**
+     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+     */
+    toProtobufJSON(
+    // @ts-ignore
+    options) {
+        return {
+            name: this.name
+        };
+    }
+}
+CancelOperationRequest.id = 'ondewo.nlu.CancelOperationRequest';
+/**
+ * Message implementation for ondewo.nlu.DeleteOperationRequest
+ */
+export class DeleteOperationRequest {
+    /**
+     * Message constructor. Initializes the properties and applies default Protobuf values if necessary
+     * @param _value initial values object or instance of DeleteOperationRequest to deeply clone from
+     */
+    constructor(_value) {
+        _value = _value || {};
+        this.name = _value.name;
+        DeleteOperationRequest.refineValues(this);
+    }
+    /**
+     * Deserialize binary data to message
+     * @param instance message instance
+     */
+    static deserializeBinary(bytes) {
+        const instance = new DeleteOperationRequest();
+        DeleteOperationRequest.deserializeBinaryFromReader(instance, new BinaryReader(bytes));
+        return instance;
+    }
+    /**
+     * Check all the properties and set default protobuf values if necessary
+     * @param _instance message instance
+     */
+    static refineValues(_instance) {
+        _instance.name = _instance.name || '';
+    }
+    /**
+     * Deserializes / reads binary message into message instance using provided binary reader
+     * @param _instance message instance
+     * @param _reader binary reader instance
+     */
+    static deserializeBinaryFromReader(_instance, _reader) {
+        while (_reader.nextField()) {
+            if (_reader.isEndGroup())
+                break;
+            switch (_reader.getFieldNumber()) {
+                case 1:
+                    _instance.name = _reader.readString();
+                    break;
+                default:
+                    _reader.skipField();
+            }
+        }
+        DeleteOperationRequest.refineValues(_instance);
+    }
+    /**
+     * Serializes a message to binary format using provided binary reader
+     * @param _instance message instance
+     * @param _writer binary writer instance
+     */
+    static serializeBinaryToWriter(_instance, _writer) {
+        if (_instance.name) {
+            _writer.writeString(1, _instance.name);
+        }
+    }
+    get name() {
+        return this._name;
+    }
+    set name(value) {
+        this._name = value;
+    }
+    /**
+     * Serialize message to binary data
+     * @param instance message instance
+     */
+    serializeBinary() {
+        const writer = new BinaryWriter();
+        DeleteOperationRequest.serializeBinaryToWriter(this, writer);
+        return writer.getResultBuffer();
+    }
+    /**
+     * Cast message to standard JavaScript object (all non-primitive values are deeply cloned)
+     */
+    toObject() {
+        return {
+            name: this.name
+        };
+    }
+    /**
+     * Convenience method to support JSON.stringify(message), replicates the structure of toObject()
+     */
+    toJSON() {
+        return this.toObject();
+    }
+    /**
+     * Cast message to JSON using protobuf JSON notation: https://developers.google.com/protocol-buffers/docs/proto3#json
+     * Attention: output differs from toObject() e.g. enums are represented as names and not as numbers, Timestamp is an ISO Date string format etc.
+     * If the message itself or some of descendant messages is google.protobuf.Any, you MUST provide a message pool as options. If not, the messagePool is not required
+     */
+    toProtobufJSON(
+    // @ts-ignore
+    options) {
+        return {
+            name: this.name
+        };
+    }
+}
+DeleteOperationRequest.id = 'ondewo.nlu.DeleteOperationRequest';
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"operations.pb.js","sourceRoot":"","sources":["../../../../../api/ondewo/nlu/operations.pb.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,YAAY,EAAE,YAAY,EAAc,MAAM,iBAAiB,CAAC;AAGzE,OAAO,KAAK,iBAAiB,MAAM,4BAA4B,CAAC;AAChE,OAAO,KAAK,iBAAiB,MAAM,4BAA4B,CAAC;AAGhE,OAAO,KAAK,YAAY,MAAM,4BAA4B,CAAC;AAC3D,OAAO,KAAK,YAAY,MAAM,wCAAwC,CAAC;AACvE;;GAEG;AACH,MAAM,OAAO,SAAS;IAkHpB;;;OAGG;IACH,YAAY,MAA6C;QANjD,YAAO,GAAyB,SAAS,CAAC,UAAU,CAAC,IAAI,CAAC;QAOhE,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;QACtB,IAAI,CAAC,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC;QACxB,IAAI,CAAC,QAAQ,GAAG,MAAM,CAAC,QAAQ;YAC7B,CAAC,CAAC,IAAI,iBAAiB,CAAC,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC;YAC5C,CAAC,CAAC,SAAS,CAAC;QACd,IAAI,CAAC,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC;QACxB,IAAI,CAAC,KAAK,GAAG,MAAM,CAAC,KAAK;YACvB,CAAC,CAAC,IAAI,YAAY,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC;YACvC,CAAC,CAAC,SAAS,CAAC;QACd,IAAI,CAAC,QAAQ,GAAG,MAAM,CAAC,QAAQ;YAC7B,CAAC,CAAC,IAAI,iBAAiB,CAAC,GAAG,CAAC,MAAM,CAAC,QAAQ,CAAC;YAC5C,CAAC,CAAC,SAAS,CAAC;QACd,SAAS,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IAC/B,CAAC;IAjID;;;OAGG;IACH,MAAM,CAAC,iBAAiB,CAAC,KAAiB;QACxC,MAAM,QAAQ,GAAG,IAAI,SAAS,EAAE,CAAC;QACjC,SAAS,CAAC,2BAA2B,CAAC,QAAQ,EAAE,IAAI,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC;QACzE,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,YAAY,CAAC,SAAoB;QACtC,SAAS,CAAC,IAAI,GAAG,SAAS,CAAC,IAAI,IAAI,EAAE,CAAC;QACtC,SAAS,CAAC,QAAQ,GAAG,SAAS,CAAC,QAAQ,IAAI,SAAS,CAAC;QACrD,SAAS,CAAC,IAAI,GAAG,SAAS,CAAC,IAAI,IAAI,KAAK,CAAC;IAC3C,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,2BAA2B,CAChC,SAAoB,EACpB,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,IAAI,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;oBACtC,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,QAAQ,GAAG,IAAI,iBAAiB,CAAC,GAAG,EAAE,CAAC;oBACjD,OAAO,CAAC,WAAW,CACjB,SAAS,CAAC,QAAQ,EAClB,iBAAiB,CAAC,GAAG,CAAC,2BAA2B,CAClD,CAAC;oBACF,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,IAAI,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC;oBACpC,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,KAAK,GAAG,IAAI,YAAY,CAAC,MAAM,EAAE,CAAC;oBAC5C,OAAO,CAAC,WAAW,CACjB,SAAS,CAAC,KAAK,EACf,YAAY,CAAC,MAAM,CAAC,2BAA2B,CAChD,CAAC;oBACF,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,QAAQ,GAAG,IAAI,iBAAiB,CAAC,GAAG,EAAE,CAAC;oBACjD,OAAO,CAAC,WAAW,CACjB,SAAS,CAAC,QAAQ,EAClB,iBAAiB,CAAC,GAAG,CAAC,2BAA2B,CAClD,CAAC;oBACF,MAAM;gBACR;oBACE,OAAO,CAAC,SAAS,EAAE,CAAC;aACvB;SACF;QAED,SAAS,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;IACpC,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,uBAAuB,CAAC,SAAoB,EAAE,OAAqB;QACxE,IAAI,SAAS,CAAC,IAAI,EAAE;YAClB,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC;SACxC;QACD,IAAI,SAAS,CAAC,QAAQ,EAAE;YACtB,OAAO,CAAC,YAAY,CAClB,CAAC,EACD,SAAS,CAAC,QAAe,EACzB,iBAAiB,CAAC,GAAG,CAAC,uBAAuB,CAC9C,CAAC;SACH;QACD,IAAI,SAAS,CAAC,IAAI,EAAE;YAClB,OAAO,CAAC,SAAS,CAAC,CAAC,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC;SACtC;QACD,IAAI,SAAS,CAAC,KAAK,EAAE;YACnB,OAAO,CAAC,YAAY,CAClB,CAAC,EACD,SAAS,CAAC,KAAY,EACtB,YAAY,CAAC,MAAM,CAAC,uBAAuB,CAC5C,CAAC;SACH;QACD,IAAI,SAAS,CAAC,QAAQ,EAAE;YACtB,OAAO,CAAC,YAAY,CAClB,CAAC,EACD,SAAS,CAAC,QAAe,EACzB,iBAAiB,CAAC,GAAG,CAAC,uBAAuB,CAC9C,CAAC;SACH;IACH,CAAC;IA6BD,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IACD,IAAI,IAAI,CAAC,KAAyB;QAChC,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACrB,CAAC;IACD,IAAI,QAAQ;QACV,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IACD,IAAI,QAAQ,CAAC,KAAwC;QACnD,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;IACzB,CAAC;IACD,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IACD,IAAI,IAAI,CAAC,KAA0B;QACjC,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACrB,CAAC;IACD,IAAI,KAAK;QACP,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IACD,IAAI,KAAK,CAAC,KAAsC;QAC9C,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,IAAI,EAAE;YACzC,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;YAC3B,IAAI,CAAC,OAAO,GAAG,SAAS,CAAC,UAAU,CAAC,KAAK,CAAC;SAC3C;QACD,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;IACtB,CAAC;IACD,IAAI,QAAQ;QACV,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IACD,IAAI,QAAQ,CAAC,KAAwC;QACnD,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,IAAI,EAAE;YACzC,IAAI,CAAC,MAAM,GAAG,SAAS,CAAC;YACxB,IAAI,CAAC,OAAO,GAAG,SAAS,CAAC,UAAU,CAAC,QAAQ,CAAC;SAC9C;QACD,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;IACzB,CAAC;IACD,IAAI,MAAM;QACR,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED;;;OAGG;IACH,eAAe;QACb,MAAM,MAAM,GAAG,IAAI,YAAY,EAAE,CAAC;QAClC,SAAS,CAAC,uBAAuB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QAChD,OAAO,MAAM,CAAC,eAAe,EAAE,CAAC;IAClC,CAAC;IAED;;OAEG;IACH,QAAQ;QACN,OAAO;YACL,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,SAAS;YAC9D,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,SAAS;YACrD,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,SAAS;SAC/D,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,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI;YACtE,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI;YAC7D,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI;SACvE,CAAC;IACJ,CAAC;;AA5NM,YAAE,GAAG,sBAAsB,CAAC;AA8NrC,WAAc,SAAS;IAsBrB,IAAY,UAIX;IAJD,WAAY,UAAU;QACpB,2CAAQ,CAAA;QACR,6CAAS,CAAA;QACT,mDAAY,CAAA;IACd,CAAC,EAJW,UAAU,GAAV,oBAAU,KAAV,oBAAU,QAIrB;AACH,CAAC,EA3Ba,SAAS,KAAT,SAAS,QA2BtB;AAED;;GAEG;AACH,MAAM,OAAO,mBAAmB;IAgE9B;;;OAGG;IACH,YAAY,MAAuD;QACjE,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;QACtB,IAAI,CAAC,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC;QACxB,mBAAmB,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IACzC,CAAC;IArED;;;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,IAAI,GAAG,SAAS,CAAC,IAAI,IAAI,EAAE,CAAC;IACxC,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,IAAI,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;oBACtC,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,IAAI,EAAE;YAClB,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC;SACxC;IACH,CAAC;IAaD,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IACD,IAAI,IAAI,CAAC,KAAyB;QAChC,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACrB,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,IAAI,EAAE,IAAI,CAAC,IAAI;SAChB,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,IAAI,EAAE,IAAI,CAAC,IAAI;SAChB,CAAC;IACJ,CAAC;;AArHM,sBAAE,GAAG,gCAAgC,CAAC;AAuI/C;;GAEG;AACH,MAAM,OAAO,qBAAqB;IAwGhC;;;OAGG;IACH,YAAY,MAAyD;QACnE,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;QACtB,IAAI,CAAC,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC;QACxB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;QAC5B,IAAI,CAAC,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC;QAChC,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC,SAAS,CAAC;QAClC,IAAI,CAAC,eAAe,GAAG,MAAM,CAAC,eAAe;YAC3C,CAAC,CAAC,IAAI,eAAe,CAAC,MAAM,CAAC,eAAe,CAAC;YAC7C,CAAC,CAAC,SAAS,CAAC;QACd,qBAAqB,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IAC3C,CAAC;IAnHD;;;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,IAAI,GAAG,SAAS,CAAC,IAAI,IAAI,EAAE,CAAC;QACtC,SAAS,CAAC,MAAM,GAAG,SAAS,CAAC,MAAM,IAAI,EAAE,CAAC;QAC1C,SAAS,CAAC,QAAQ,GAAG,SAAS,CAAC,QAAQ,IAAI,CAAC,CAAC;QAC7C,SAAS,CAAC,SAAS,GAAG,SAAS,CAAC,SAAS,IAAI,EAAE,CAAC;QAChD,SAAS,CAAC,eAAe,GAAG,SAAS,CAAC,eAAe,IAAI,SAAS,CAAC;IACrE,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,SAAS,CAAC,IAAI,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;oBACtC,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,MAAM,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;oBACxC,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,QAAQ,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;oBACzC,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,SAAS,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;oBAC3C,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,eAAe,GAAG,IAAI,eAAe,EAAE,CAAC;oBAClD,OAAO,CAAC,WAAW,CACjB,SAAS,CAAC,eAAe,EACzB,eAAe,CAAC,2BAA2B,CAC5C,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,IAAI,EAAE;YAClB,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC;SACxC;QACD,IAAI,SAAS,CAAC,MAAM,EAAE;YACpB,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;SAC1C;QACD,IAAI,SAAS,CAAC,QAAQ,EAAE;YACtB,OAAO,CAAC,UAAU,CAAC,CAAC,EAAE,SAAS,CAAC,QAAQ,CAAC,CAAC;SAC3C;QACD,IAAI,SAAS,CAAC,SAAS,EAAE;YACvB,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC;SAC7C;QACD,IAAI,SAAS,CAAC,eAAe,EAAE;YAC7B,OAAO,CAAC,YAAY,CAClB,CAAC,EACD,SAAS,CAAC,eAAsB,EAChC,eAAe,CAAC,uBAAuB,CACxC,CAAC;SACH;IACH,CAAC;IAuBD,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IACD,IAAI,IAAI,CAAC,KAAyB;QAChC,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACrB,CAAC;IACD,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,QAAQ;QACV,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IACD,IAAI,QAAQ,CAAC,KAAyB;QACpC,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;IACzB,CAAC;IACD,IAAI,SAAS;QACX,OAAO,IAAI,CAAC,UAAU,CAAC;IACzB,CAAC;IACD,IAAI,SAAS,CAAC,KAAyB;QACrC,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;IAC1B,CAAC;IACD,IAAI,eAAe;QACjB,OAAO,IAAI,CAAC,gBAAgB,CAAC;IAC/B,CAAC;IACD,IAAI,eAAe,CAAC,KAAkC;QACpD,IAAI,CAAC,gBAAgB,GAAG,KAAK,CAAC;IAChC,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,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,QAAQ,EAAE,IAAI,CAAC,QAAQ;YACvB,SAAS,EAAE,IAAI,CAAC,SAAS;YACzB,eAAe,EAAE,IAAI,CAAC,eAAe;gBACnC,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC,QAAQ,EAAE;gBACjC,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,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,QAAQ,EAAE,IAAI,CAAC,QAAQ;YACvB,SAAS,EAAE,IAAI,CAAC,SAAS;YACzB,eAAe,EAAE,IAAI,CAAC,eAAe;gBACnC,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC,cAAc,CAAC,OAAO,CAAC;gBAC9C,CAAC,CAAC,IAAI;SACT,CAAC;IACJ,CAAC;;AAvMM,wBAAE,GAAG,kCAAkC,CAAC;AAiOjD;;GAEG;AACH,MAAM,OAAO,eAAe;IAoI1B;;;OAGG;IACH,YAAY,MAAmD;QATvD,oBAAe,GACrB,eAAe,CAAC,kBAAkB,CAAC,IAAI,CAAC;QAClC,kBAAa,GACnB,eAAe,CAAC,gBAAgB,CAAC,IAAI,CAAC;QAOtC,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;QACtB,IAAI,CAAC,cAAc,GAAG,CAAC,MAAM,CAAC,cAAc,IAAI,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC;QAC5D,IAAI,CAAC,QAAQ,GAAG,CAAC,MAAM,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC;QAChD,IAAI,CAAC,KAAK,GAAG,CAAC,MAAM,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC;QAC1C,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC,SAAS;YAC/B,CAAC,CAAC,IAAI,iBAAiB,CAAC,SAAS,CAAC,MAAM,CAAC,SAAS,CAAC;YACnD,CAAC,CAAC,SAAS,CAAC;QACd,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC,OAAO;YAC3B,CAAC,CAAC,IAAI,iBAAiB,CAAC,SAAS,CAAC,MAAM,CAAC,OAAO,CAAC;YACjD,CAAC,CAAC,SAAS,CAAC;QACd,IAAI,CAAC,OAAO,GAAG,CAAC,MAAM,CAAC,OAAO,IAAI,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC;QAC9C,eAAe,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IACrC,CAAC;IAlJD;;;OAGG;IACH,MAAM,CAAC,iBAAiB,CAAC,KAAiB;QACxC,MAAM,QAAQ,GAAG,IAAI,eAAe,EAAE,CAAC;QACvC,eAAe,CAAC,2BAA2B,CACzC,QAAQ,EACR,IAAI,YAAY,CAAC,KAAK,CAAC,CACxB,CAAC;QACF,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;;OAGG;IACH,MAAM,CAAC,YAAY,CAAC,SAA0B;QAC5C,SAAS,CAAC,cAAc,GAAG,SAAS,CAAC,cAAc,IAAI,EAAE,CAAC;QAC1D,SAAS,CAAC,QAAQ,GAAG,SAAS,CAAC,QAAQ,IAAI,EAAE,CAAC;QAC9C,SAAS,CAAC,KAAK,GAAG,SAAS,CAAC,KAAK,IAAI,EAAE,CAAC;QAExC,SAAS,CAAC,OAAO,GAAG,SAAS,CAAC,OAAO,IAAI,EAAE,CAAC;IAC9C,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,2BAA2B,CAChC,SAA0B,EAC1B,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,cAAc,GAAG,SAAS,CAAC,cAAc,IAAI,EAAE,CAAC,CAAC,IAAI,CAC9D,OAAO,CAAC,UAAU,EAAE,CACrB,CAAC;oBACF,MAAM;gBACR,KAAK,CAAC;oBACJ,CAAC,SAAS,CAAC,QAAQ,GAAG,SAAS,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAC,IAAI,CAClD,GAAG,CAAC,OAAO,CAAC,cAAc,EAAE,IAAI,EAAE,CAAC,CACpC,CAAC;oBACF,MAAM;gBACR,KAAK,CAAC;oBACJ,CAAC,SAAS,CAAC,KAAK,GAAG,SAAS,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC,IAAI,CAC5C,GAAG,CAAC,OAAO,CAAC,cAAc,EAAE,IAAI,EAAE,CAAC,CACpC,CAAC;oBACF,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,SAAS,GAAG,IAAI,iBAAiB,CAAC,SAAS,EAAE,CAAC;oBACxD,OAAO,CAAC,WAAW,CACjB,SAAS,CAAC,SAAS,EACnB,iBAAiB,CAAC,SAAS,CAAC,2BAA2B,CACxD,CAAC;oBACF,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,OAAO,GAAG,IAAI,iBAAiB,CAAC,SAAS,EAAE,CAAC;oBACtD,OAAO,CAAC,WAAW,CACjB,SAAS,CAAC,OAAO,EACjB,iBAAiB,CAAC,SAAS,CAAC,2BAA2B,CACxD,CAAC;oBACF,MAAM;gBACR,KAAK,CAAC;oBACJ,CAAC,SAAS,CAAC,OAAO,GAAG,SAAS,CAAC,OAAO,IAAI,EAAE,CAAC,CAAC,IAAI,CAChD,OAAO,CAAC,UAAU,EAAE,CACrB,CAAC;oBACF,MAAM;gBACR;oBACE,OAAO,CAAC,SAAS,EAAE,CAAC;aACvB;SACF;QAED,eAAe,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;IAC1C,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,uBAAuB,CAC5B,SAA0B,EAC1B,OAAqB;QAErB,IAAI,SAAS,CAAC,cAAc,IAAI,SAAS,CAAC,cAAc,CAAC,MAAM,EAAE;YAC/D,OAAO,CAAC,mBAAmB,CAAC,CAAC,EAAE,SAAS,CAAC,cAAc,CAAC,CAAC;SAC1D;QACD,IAAI,SAAS,CAAC,QAAQ,IAAI,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE;YACnD,OAAO,CAAC,eAAe,CAAC,CAAC,EAAE,SAAS,CAAC,QAAQ,CAAC,CAAC;SAChD;QACD,IAAI,SAAS,CAAC,KAAK,IAAI,SAAS,CAAC,KAAK,CAAC,MAAM,EAAE;YAC7C,OAAO,CAAC,eAAe,CAAC,CAAC,EAAE,SAAS,CAAC,KAAK,CAAC,CAAC;SAC7C;QACD,IAAI,SAAS,CAAC,SAAS,EAAE;YACvB,OAAO,CAAC,YAAY,CAClB,CAAC,EACD,SAAS,CAAC,SAAgB,EAC1B,iBAAiB,CAAC,SAAS,CAAC,uBAAuB,CACpD,CAAC;SACH;QACD,IAAI,SAAS,CAAC,OAAO,EAAE;YACrB,OAAO,CAAC,YAAY,CAClB,CAAC,EACD,SAAS,CAAC,OAAc,EACxB,iBAAiB,CAAC,SAAS,CAAC,uBAAuB,CACpD,CAAC;SACH;QACD,IAAI,SAAS,CAAC,OAAO,IAAI,SAAS,CAAC,OAAO,CAAC,MAAM,EAAE;YACjD,OAAO,CAAC,mBAAmB,CAAC,CAAC,EAAE,SAAS,CAAC,OAAO,CAAC,CAAC;SACnD;IACH,CAAC;IAgCD,IAAI,cAAc;QAChB,OAAO,IAAI,CAAC,eAAe,CAAC;IAC9B,CAAC;IACD,IAAI,cAAc,CAAC,KAA2B;QAC5C,IAAI,CAAC,eAAe,GAAG,KAAK,CAAC;IAC/B,CAAC;IACD,IAAI,QAAQ;QACV,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IACD,IAAI,QAAQ,CAAC,KAA0D;QACrE,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;IACzB,CAAC;IACD,IAAI,KAAK;QACP,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IACD,IAAI,KAAK,CAAC,KAAiE;QACzE,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;IACtB,CAAC;IACD,IAAI,SAAS;QACX,OAAO,IAAI,CAAC,UAAU,CAAC;IACzB,CAAC;IACD,IAAI,SAAS,CAAC,KAA8C;QAC1D,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,IAAI,EAAE;YACzC,IAAI,CAAC,eAAe,GAAG,eAAe,CAAC,kBAAkB,CAAC,SAAS,CAAC;SACrE;QACD,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;IAC1B,CAAC;IACD,IAAI,OAAO;QACT,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;IACD,IAAI,OAAO,CAAC,KAA8C;QACxD,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,IAAI,EAAE;YACzC,IAAI,CAAC,aAAa,GAAG,eAAe,CAAC,gBAAgB,CAAC,OAAO,CAAC;SAC/D;QACD,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;IACxB,CAAC;IACD,IAAI,OAAO;QACT,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;IACD,IAAI,OAAO,CAAC,KAA2B;QACrC,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;IACxB,CAAC;IACD,IAAI,cAAc;QAChB,OAAO,IAAI,CAAC,eAAe,CAAC;IAC9B,CAAC;IACD,IAAI,YAAY;QACd,OAAO,IAAI,CAAC,aAAa,CAAC;IAC5B,CAAC;IAED;;;OAGG;IACH,eAAe;QACb,MAAM,MAAM,GAAG,IAAI,YAAY,EAAE,CAAC;QAClC,eAAe,CAAC,uBAAuB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QACtD,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,KAAK,EAAE;YACnD,QAAQ,EAAE,CAAC,IAAI,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAC,KAAK,EAAE;YACvC,KAAK,EAAE,CAAC,IAAI,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC,KAAK,EAAE;YACjC,SAAS,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,SAAS;YACjE,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,SAAS;YAC3D,OAAO,EAAE,CAAC,IAAI,CAAC,OAAO,IAAI,EAAE,CAAC,CAAC,KAAK,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,cAAc,EAAE,CAAC,IAAI,CAAC,cAAc,IAAI,EAAE,CAAC,CAAC,KAAK,EAAE;YACnD,QAAQ,EAAE,CAAC,IAAI,CAAC,QAAQ,IAAI,EAAE,CAAC,CAAC,GAAG,CACjC,CAAC,CAAC,EAAE,CAAC,YAAY,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC,CAAC,CAC9C;YACD,KAAK,EAAE,CAAC,IAAI,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC,GAAG,CAC3B,CAAC,CAAC,EAAE,CAAC,YAAY,CAAC,iBAAiB,CAAC,aAAa,CAAC,CAAC,CAAC,CACrD;YACD,SAAS,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI;YACzE,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI;YACnE,OAAO,EAAE,CAAC,IAAI,CAAC,OAAO,IAAI,EAAE,CAAC,CAAC,KAAK,EAAE;SACtC,CAAC;IACJ,CAAC;;AA1PM,kBAAE,GAAG,4BAA4B,CAAC;AA4P3C,WAAc,eAAe;IAwB3B,IAAY,kBAGX;IAHD,WAAY,kBAAkB;QAC5B,2DAAQ,CAAA;QACR,qEAAa,CAAA;IACf,CAAC,EAHW,kBAAkB,GAAlB,kCAAkB,KAAlB,kCAAkB,QAG7B;IACD,IAAY,gBAGX;IAHD,WAAY,gBAAgB;QAC1B,uDAAQ,CAAA;QACR,6DAAW,CAAA;IACb,CAAC,EAHW,gBAAgB,GAAhB,gCAAgB,KAAhB,gCAAgB,QAG3B;AACH,CAAC,EAhCa,eAAe,KAAf,eAAe,QAgC5B;AAED;;GAEG;AACH,MAAM,OAAO,sBAAsB;IAmFjC;;;OAGG;IACH,YAAY,MAA0D;QACpE,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;QACtB,IAAI,CAAC,UAAU,GAAG,CAAC,MAAM,CAAC,UAAU,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;QACvE,IAAI,CAAC,aAAa,GAAG,MAAM,CAAC,aAAa,CAAC;QAC1C,sBAAsB,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IAC5C,CAAC;IAzFD;;;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,UAAU,GAAG,SAAS,CAAC,UAAU,IAAI,EAAE,CAAC;QAClD,SAAS,CAAC,aAAa,GAAG,SAAS,CAAC,aAAa,IAAI,EAAE,CAAC;IAC1D,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,MAAM,mBAAmB,GAAG,IAAI,SAAS,EAAE,CAAC;oBAC5C,OAAO,CAAC,WAAW,CACjB,mBAAmB,EACnB,SAAS,CAAC,2BAA2B,CACtC,CAAC;oBACF,CAAC,SAAS,CAAC,UAAU,GAAG,SAAS,CAAC,UAAU,IAAI,EAAE,CAAC,CAAC,IAAI,CACtD,mBAAmB,CACpB,CAAC;oBACF,MAAM;gBACR,KAAK,CAAC;oBACJ,SAAS,CAAC,aAAa,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;oBAC/C,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,UAAU,IAAI,SAAS,CAAC,UAAU,CAAC,MAAM,EAAE;YACvD,OAAO,CAAC,oBAAoB,CAC1B,CAAC,EACD,SAAS,CAAC,UAAiB,EAC3B,SAAS,CAAC,uBAAuB,CAClC,CAAC;SACH;QACD,IAAI,SAAS,CAAC,aAAa,EAAE;YAC3B,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,SAAS,CAAC,aAAa,CAAC,CAAC;SACjD;IACH,CAAC;IAeD,IAAI,UAAU;QACZ,OAAO,IAAI,CAAC,WAAW,CAAC;IAC1B,CAAC;IACD,IAAI,UAAU,CAAC,KAA8B;QAC3C,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC;IAC3B,CAAC;IACD,IAAI,aAAa;QACf,OAAO,IAAI,CAAC,cAAc,CAAC;IAC7B,CAAC;IACD,IAAI,aAAa,CAAC,KAAyB;QACzC,IAAI,CAAC,cAAc,GAAG,KAAK,CAAC;IAC9B,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,UAAU,EAAE,CAAC,IAAI,CAAC,UAAU,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAC;YAC1D,aAAa,EAAE,IAAI,CAAC,aAAa;SAClC,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,CAAC,IAAI,CAAC,UAAU,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;YACvE,aAAa,EAAE,IAAI,CAAC,aAAa;SAClC,CAAC;IACJ,CAAC;;AAjJM,yBAAE,GAAG,mCAAmC,CAAC;AAqKlD;;GAEG;AACH,MAAM,OAAO,sBAAsB;IAgEjC;;;OAGG;IACH,YAAY,MAA0D;QACpE,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;QACtB,IAAI,CAAC,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC;QACxB,sBAAsB,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IAC5C,CAAC;IArED;;;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,IAAI,GAAG,SAAS,CAAC,IAAI,IAAI,EAAE,CAAC;IACxC,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,IAAI,GAAG,OAAO,CAAC,UAAU,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,IAAI,EAAE;YAClB,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC;SACxC;IACH,CAAC;IAaD,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IACD,IAAI,IAAI,CAAC,KAAyB;QAChC,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACrB,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,IAAI,EAAE,IAAI,CAAC,IAAI;SAChB,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,IAAI,EAAE,IAAI,CAAC,IAAI;SAChB,CAAC;IACJ,CAAC;;AArHM,yBAAE,GAAG,mCAAmC,CAAC;AAuIlD;;GAEG;AACH,MAAM,OAAO,sBAAsB;IAgEjC;;;OAGG;IACH,YAAY,MAA0D;QACpE,MAAM,GAAG,MAAM,IAAI,EAAE,CAAC;QACtB,IAAI,CAAC,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC;QACxB,sBAAsB,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IAC5C,CAAC;IArED;;;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,IAAI,GAAG,SAAS,CAAC,IAAI,IAAI,EAAE,CAAC;IACxC,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,IAAI,GAAG,OAAO,CAAC,UAAU,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,IAAI,EAAE;YAClB,OAAO,CAAC,WAAW,CAAC,CAAC,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC;SACxC;IACH,CAAC;IAaD,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IACD,IAAI,IAAI,CAAC,KAAyB;QAChC,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACrB,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,IAAI,EAAE,IAAI,CAAC,IAAI;SAChB,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,IAAI,EAAE,IAAI,CAAC,IAAI;SAChB,CAAC;IACJ,CAAC;;AArHM,yBAAE,GAAG,mCAAmC,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} from '@ngx-grpc/common';\nimport { BinaryReader, BinaryWriter, ByteSource } from 'google-protobuf';\nimport * as googleApi000 from '../../google/api/http.pb';\nimport * as googleProtobuf001 from '@ngx-grpc/well-known-types';\nimport * as googleProtobuf002 from '@ngx-grpc/well-known-types';\nimport * as googleProtobuf003 from '@ngx-grpc/well-known-types';\nimport * as googleApi004 from '../../google/api/annotations.pb';\nimport * as googleProtobuf005 from '@ngx-grpc/well-known-types';\nimport * as googleRpc006 from '../../google/rpc/status.pb';\nimport * as ondewoNlu007 from '../../ondewo/nlu/operation-metadata.pb';\n/**\n * Message implementation for ondewo.nlu.Operation\n */\nexport class Operation implements GrpcMessage {\n  static id = 'ondewo.nlu.Operation';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new Operation();\n    Operation.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: Operation) {\n    _instance.name = _instance.name || '';\n    _instance.metadata = _instance.metadata || undefined;\n    _instance.done = _instance.done || 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: Operation,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.name = _reader.readString();\n          break;\n        case 2:\n          _instance.metadata = new googleProtobuf002.Any();\n          _reader.readMessage(\n            _instance.metadata,\n            googleProtobuf002.Any.deserializeBinaryFromReader\n          );\n          break;\n        case 3:\n          _instance.done = _reader.readBool();\n          break;\n        case 4:\n          _instance.error = new googleRpc006.Status();\n          _reader.readMessage(\n            _instance.error,\n            googleRpc006.Status.deserializeBinaryFromReader\n          );\n          break;\n        case 5:\n          _instance.response = new googleProtobuf002.Any();\n          _reader.readMessage(\n            _instance.response,\n            googleProtobuf002.Any.deserializeBinaryFromReader\n          );\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    Operation.refineValues(_instance);\n  }\n\n  /**\n   * Serializes a message to binary format using provided binary reader\n   * @param _instance message instance\n   * @param _writer binary writer instance\n   */\n  static serializeBinaryToWriter(_instance: Operation, _writer: BinaryWriter) {\n    if (_instance.name) {\n      _writer.writeString(1, _instance.name);\n    }\n    if (_instance.metadata) {\n      _writer.writeMessage(\n        2,\n        _instance.metadata as any,\n        googleProtobuf002.Any.serializeBinaryToWriter\n      );\n    }\n    if (_instance.done) {\n      _writer.writeBool(3, _instance.done);\n    }\n    if (_instance.error) {\n      _writer.writeMessage(\n        4,\n        _instance.error as any,\n        googleRpc006.Status.serializeBinaryToWriter\n      );\n    }\n    if (_instance.response) {\n      _writer.writeMessage(\n        5,\n        _instance.response as any,\n        googleProtobuf002.Any.serializeBinaryToWriter\n      );\n    }\n  }\n\n  private _name?: string;\n  private _metadata?: googleProtobuf002.Any;\n  private _done?: boolean;\n  private _error?: googleRpc006.Status;\n  private _response?: googleProtobuf002.Any;\n\n  private _result: Operation.ResultCase = Operation.ResultCase.none;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of Operation to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<Operation.AsObject>) {\n    _value = _value || {};\n    this.name = _value.name;\n    this.metadata = _value.metadata\n      ? new googleProtobuf002.Any(_value.metadata)\n      : undefined;\n    this.done = _value.done;\n    this.error = _value.error\n      ? new googleRpc006.Status(_value.error)\n      : undefined;\n    this.response = _value.response\n      ? new googleProtobuf002.Any(_value.response)\n      : undefined;\n    Operation.refineValues(this);\n  }\n  get name(): string | undefined {\n    return this._name;\n  }\n  set name(value: string | undefined) {\n    this._name = value;\n  }\n  get metadata(): googleProtobuf002.Any | undefined {\n    return this._metadata;\n  }\n  set metadata(value: googleProtobuf002.Any | undefined) {\n    this._metadata = value;\n  }\n  get done(): boolean | undefined {\n    return this._done;\n  }\n  set done(value: boolean | undefined) {\n    this._done = value;\n  }\n  get error(): googleRpc006.Status | undefined {\n    return this._error;\n  }\n  set error(value: googleRpc006.Status | undefined) {\n    if (value !== undefined && value !== null) {\n      this._response = undefined;\n      this._result = Operation.ResultCase.error;\n    }\n    this._error = value;\n  }\n  get response(): googleProtobuf002.Any | undefined {\n    return this._response;\n  }\n  set response(value: googleProtobuf002.Any | undefined) {\n    if (value !== undefined && value !== null) {\n      this._error = undefined;\n      this._result = Operation.ResultCase.response;\n    }\n    this._response = value;\n  }\n  get result() {\n    return this._result;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    Operation.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(): Operation.AsObject {\n    return {\n      name: this.name,\n      metadata: this.metadata ? this.metadata.toObject() : undefined,\n      done: this.done,\n      error: this.error ? this.error.toObject() : undefined,\n      response: this.response ? this.response.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  ): Operation.AsProtobufJSON {\n    return {\n      name: this.name,\n      metadata: this.metadata ? this.metadata.toProtobufJSON(options) : null,\n      done: this.done,\n      error: this.error ? this.error.toProtobufJSON(options) : null,\n      response: this.response ? this.response.toProtobufJSON(options) : null\n    };\n  }\n}\nexport module Operation {\n  /**\n   * Standard JavaScript object representation for Operation\n   */\n  export interface AsObject {\n    name?: string;\n    metadata?: googleProtobuf002.Any.AsObject;\n    done?: boolean;\n    error?: googleRpc006.Status.AsObject;\n    response?: googleProtobuf002.Any.AsObject;\n  }\n\n  /**\n   * Protobuf JSON representation for Operation\n   */\n  export interface AsProtobufJSON {\n    name?: string;\n    metadata?: googleProtobuf002.Any.AsProtobufJSON | null;\n    done?: boolean;\n    error?: googleRpc006.Status.AsProtobufJSON | null;\n    response?: googleProtobuf002.Any.AsProtobufJSON | null;\n  }\n  export enum ResultCase {\n    none = 0,\n    error = 1,\n    response = 2\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.GetOperationRequest\n */\nexport class GetOperationRequest implements GrpcMessage {\n  static id = 'ondewo.nlu.GetOperationRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new GetOperationRequest();\n    GetOperationRequest.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: GetOperationRequest) {\n    _instance.name = _instance.name || '';\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: GetOperationRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.name = _reader.readString();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    GetOperationRequest.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: GetOperationRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.name) {\n      _writer.writeString(1, _instance.name);\n    }\n  }\n\n  private _name?: 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 GetOperationRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<GetOperationRequest.AsObject>) {\n    _value = _value || {};\n    this.name = _value.name;\n    GetOperationRequest.refineValues(this);\n  }\n  get name(): string | undefined {\n    return this._name;\n  }\n  set name(value: string | undefined) {\n    this._name = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    GetOperationRequest.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(): GetOperationRequest.AsObject {\n    return {\n      name: this.name\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  ): GetOperationRequest.AsProtobufJSON {\n    return {\n      name: this.name\n    };\n  }\n}\nexport module GetOperationRequest {\n  /**\n   * Standard JavaScript object representation for GetOperationRequest\n   */\n  export interface AsObject {\n    name?: string;\n  }\n\n  /**\n   * Protobuf JSON representation for GetOperationRequest\n   */\n  export interface AsProtobufJSON {\n    name?: string;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.ListOperationsRequest\n */\nexport class ListOperationsRequest implements GrpcMessage {\n  static id = 'ondewo.nlu.ListOperationsRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new ListOperationsRequest();\n    ListOperationsRequest.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: ListOperationsRequest) {\n    _instance.name = _instance.name || '';\n    _instance.filter = _instance.filter || '';\n    _instance.pageSize = _instance.pageSize || 0;\n    _instance.pageToken = _instance.pageToken || '';\n    _instance.operationFilter = _instance.operationFilter || 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: ListOperationsRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 4:\n          _instance.name = _reader.readString();\n          break;\n        case 1:\n          _instance.filter = _reader.readString();\n          break;\n        case 2:\n          _instance.pageSize = _reader.readInt32();\n          break;\n        case 3:\n          _instance.pageToken = _reader.readString();\n          break;\n        case 5:\n          _instance.operationFilter = new OperationFilter();\n          _reader.readMessage(\n            _instance.operationFilter,\n            OperationFilter.deserializeBinaryFromReader\n          );\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    ListOperationsRequest.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: ListOperationsRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.name) {\n      _writer.writeString(4, _instance.name);\n    }\n    if (_instance.filter) {\n      _writer.writeString(1, _instance.filter);\n    }\n    if (_instance.pageSize) {\n      _writer.writeInt32(2, _instance.pageSize);\n    }\n    if (_instance.pageToken) {\n      _writer.writeString(3, _instance.pageToken);\n    }\n    if (_instance.operationFilter) {\n      _writer.writeMessage(\n        5,\n        _instance.operationFilter as any,\n        OperationFilter.serializeBinaryToWriter\n      );\n    }\n  }\n\n  private _name?: string;\n  private _filter?: string;\n  private _pageSize?: number;\n  private _pageToken?: string;\n  private _operationFilter?: OperationFilter;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of ListOperationsRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<ListOperationsRequest.AsObject>) {\n    _value = _value || {};\n    this.name = _value.name;\n    this.filter = _value.filter;\n    this.pageSize = _value.pageSize;\n    this.pageToken = _value.pageToken;\n    this.operationFilter = _value.operationFilter\n      ? new OperationFilter(_value.operationFilter)\n      : undefined;\n    ListOperationsRequest.refineValues(this);\n  }\n  get name(): string | undefined {\n    return this._name;\n  }\n  set name(value: string | undefined) {\n    this._name = value;\n  }\n  get filter(): string | undefined {\n    return this._filter;\n  }\n  set filter(value: string | undefined) {\n    this._filter = value;\n  }\n  get pageSize(): number | undefined {\n    return this._pageSize;\n  }\n  set pageSize(value: number | undefined) {\n    this._pageSize = value;\n  }\n  get pageToken(): string | undefined {\n    return this._pageToken;\n  }\n  set pageToken(value: string | undefined) {\n    this._pageToken = value;\n  }\n  get operationFilter(): OperationFilter | undefined {\n    return this._operationFilter;\n  }\n  set operationFilter(value: OperationFilter | undefined) {\n    this._operationFilter = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    ListOperationsRequest.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(): ListOperationsRequest.AsObject {\n    return {\n      name: this.name,\n      filter: this.filter,\n      pageSize: this.pageSize,\n      pageToken: this.pageToken,\n      operationFilter: this.operationFilter\n        ? this.operationFilter.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  ): ListOperationsRequest.AsProtobufJSON {\n    return {\n      name: this.name,\n      filter: this.filter,\n      pageSize: this.pageSize,\n      pageToken: this.pageToken,\n      operationFilter: this.operationFilter\n        ? this.operationFilter.toProtobufJSON(options)\n        : null\n    };\n  }\n}\nexport module ListOperationsRequest {\n  /**\n   * Standard JavaScript object representation for ListOperationsRequest\n   */\n  export interface AsObject {\n    name?: string;\n    filter?: string;\n    pageSize?: number;\n    pageToken?: string;\n    operationFilter?: OperationFilter.AsObject;\n  }\n\n  /**\n   * Protobuf JSON representation for ListOperationsRequest\n   */\n  export interface AsProtobufJSON {\n    name?: string;\n    filter?: string;\n    pageSize?: number;\n    pageToken?: string;\n    operationFilter?: OperationFilter.AsProtobufJSON | null;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.OperationFilter\n */\nexport class OperationFilter implements GrpcMessage {\n  static id = 'ondewo.nlu.OperationFilter';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new OperationFilter();\n    OperationFilter.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: OperationFilter) {\n    _instance.projectParents = _instance.projectParents || [];\n    _instance.statuses = _instance.statuses || [];\n    _instance.types = _instance.types || [];\n\n    _instance.userIds = _instance.userIds || [];\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: OperationFilter,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          (_instance.projectParents = _instance.projectParents || []).push(\n            _reader.readString()\n          );\n          break;\n        case 2:\n          (_instance.statuses = _instance.statuses || []).push(\n            ...(_reader.readPackedEnum() || [])\n          );\n          break;\n        case 3:\n          (_instance.types = _instance.types || []).push(\n            ...(_reader.readPackedEnum() || [])\n          );\n          break;\n        case 4:\n          _instance.startTime = new googleProtobuf003.Timestamp();\n          _reader.readMessage(\n            _instance.startTime,\n            googleProtobuf003.Timestamp.deserializeBinaryFromReader\n          );\n          break;\n        case 5:\n          _instance.endTime = new googleProtobuf003.Timestamp();\n          _reader.readMessage(\n            _instance.endTime,\n            googleProtobuf003.Timestamp.deserializeBinaryFromReader\n          );\n          break;\n        case 6:\n          (_instance.userIds = _instance.userIds || []).push(\n            _reader.readString()\n          );\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    OperationFilter.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: OperationFilter,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.projectParents && _instance.projectParents.length) {\n      _writer.writeRepeatedString(1, _instance.projectParents);\n    }\n    if (_instance.statuses && _instance.statuses.length) {\n      _writer.writePackedEnum(2, _instance.statuses);\n    }\n    if (_instance.types && _instance.types.length) {\n      _writer.writePackedEnum(3, _instance.types);\n    }\n    if (_instance.startTime) {\n      _writer.writeMessage(\n        4,\n        _instance.startTime as any,\n        googleProtobuf003.Timestamp.serializeBinaryToWriter\n      );\n    }\n    if (_instance.endTime) {\n      _writer.writeMessage(\n        5,\n        _instance.endTime as any,\n        googleProtobuf003.Timestamp.serializeBinaryToWriter\n      );\n    }\n    if (_instance.userIds && _instance.userIds.length) {\n      _writer.writeRepeatedString(6, _instance.userIds);\n    }\n  }\n\n  private _projectParents?: string[];\n  private _statuses?: ondewoNlu007.OperationMetadata.Status[];\n  private _types?: ondewoNlu007.OperationMetadata.OperationType[];\n  private _startTime?: googleProtobuf003.Timestamp;\n  private _endTime?: googleProtobuf003.Timestamp;\n  private _userIds?: string[];\n\n  private _startTimeOneof: OperationFilter.StartTimeOneofCase =\n    OperationFilter.StartTimeOneofCase.none;\n  private _endTimeOneof: OperationFilter.EndTimeOneofCase =\n    OperationFilter.EndTimeOneofCase.none;\n\n  /**\n   * Message constructor. Initializes the properties and applies default Protobuf values if necessary\n   * @param _value initial values object or instance of OperationFilter to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<OperationFilter.AsObject>) {\n    _value = _value || {};\n    this.projectParents = (_value.projectParents || []).slice();\n    this.statuses = (_value.statuses || []).slice();\n    this.types = (_value.types || []).slice();\n    this.startTime = _value.startTime\n      ? new googleProtobuf003.Timestamp(_value.startTime)\n      : undefined;\n    this.endTime = _value.endTime\n      ? new googleProtobuf003.Timestamp(_value.endTime)\n      : undefined;\n    this.userIds = (_value.userIds || []).slice();\n    OperationFilter.refineValues(this);\n  }\n  get projectParents(): string[] | undefined {\n    return this._projectParents;\n  }\n  set projectParents(value: string[] | undefined) {\n    this._projectParents = value;\n  }\n  get statuses(): ondewoNlu007.OperationMetadata.Status[] | undefined {\n    return this._statuses;\n  }\n  set statuses(value: ondewoNlu007.OperationMetadata.Status[] | undefined) {\n    this._statuses = value;\n  }\n  get types(): ondewoNlu007.OperationMetadata.OperationType[] | undefined {\n    return this._types;\n  }\n  set types(value: ondewoNlu007.OperationMetadata.OperationType[] | undefined) {\n    this._types = value;\n  }\n  get startTime(): googleProtobuf003.Timestamp | undefined {\n    return this._startTime;\n  }\n  set startTime(value: googleProtobuf003.Timestamp | undefined) {\n    if (value !== undefined && value !== null) {\n      this._startTimeOneof = OperationFilter.StartTimeOneofCase.startTime;\n    }\n    this._startTime = value;\n  }\n  get endTime(): googleProtobuf003.Timestamp | undefined {\n    return this._endTime;\n  }\n  set endTime(value: googleProtobuf003.Timestamp | undefined) {\n    if (value !== undefined && value !== null) {\n      this._endTimeOneof = OperationFilter.EndTimeOneofCase.endTime;\n    }\n    this._endTime = value;\n  }\n  get userIds(): string[] | undefined {\n    return this._userIds;\n  }\n  set userIds(value: string[] | undefined) {\n    this._userIds = value;\n  }\n  get startTimeOneof() {\n    return this._startTimeOneof;\n  }\n  get endTimeOneof() {\n    return this._endTimeOneof;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    OperationFilter.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(): OperationFilter.AsObject {\n    return {\n      projectParents: (this.projectParents || []).slice(),\n      statuses: (this.statuses || []).slice(),\n      types: (this.types || []).slice(),\n      startTime: this.startTime ? this.startTime.toObject() : undefined,\n      endTime: this.endTime ? this.endTime.toObject() : undefined,\n      userIds: (this.userIds || []).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  ): OperationFilter.AsProtobufJSON {\n    return {\n      projectParents: (this.projectParents || []).slice(),\n      statuses: (this.statuses || []).map(\n        v => ondewoNlu007.OperationMetadata.Status[v]\n      ),\n      types: (this.types || []).map(\n        v => ondewoNlu007.OperationMetadata.OperationType[v]\n      ),\n      startTime: this.startTime ? this.startTime.toProtobufJSON(options) : null,\n      endTime: this.endTime ? this.endTime.toProtobufJSON(options) : null,\n      userIds: (this.userIds || []).slice()\n    };\n  }\n}\nexport module OperationFilter {\n  /**\n   * Standard JavaScript object representation for OperationFilter\n   */\n  export interface AsObject {\n    projectParents?: string[];\n    statuses?: ondewoNlu007.OperationMetadata.Status[];\n    types?: ondewoNlu007.OperationMetadata.OperationType[];\n    startTime?: googleProtobuf003.Timestamp.AsObject;\n    endTime?: googleProtobuf003.Timestamp.AsObject;\n    userIds?: string[];\n  }\n\n  /**\n   * Protobuf JSON representation for OperationFilter\n   */\n  export interface AsProtobufJSON {\n    projectParents?: string[];\n    statuses?: string[];\n    types?: string[];\n    startTime?: googleProtobuf003.Timestamp.AsProtobufJSON | null;\n    endTime?: googleProtobuf003.Timestamp.AsProtobufJSON | null;\n    userIds?: string[];\n  }\n  export enum StartTimeOneofCase {\n    none = 0,\n    startTime = 1\n  }\n  export enum EndTimeOneofCase {\n    none = 0,\n    endTime = 1\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.ListOperationsResponse\n */\nexport class ListOperationsResponse implements GrpcMessage {\n  static id = 'ondewo.nlu.ListOperationsResponse';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new ListOperationsResponse();\n    ListOperationsResponse.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: ListOperationsResponse) {\n    _instance.operations = _instance.operations || [];\n    _instance.nextPageToken = _instance.nextPageToken || '';\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: ListOperationsResponse,\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 Operation();\n          _reader.readMessage(\n            messageInitializer1,\n            Operation.deserializeBinaryFromReader\n          );\n          (_instance.operations = _instance.operations || []).push(\n            messageInitializer1\n          );\n          break;\n        case 2:\n          _instance.nextPageToken = _reader.readString();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    ListOperationsResponse.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: ListOperationsResponse,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.operations && _instance.operations.length) {\n      _writer.writeRepeatedMessage(\n        1,\n        _instance.operations as any,\n        Operation.serializeBinaryToWriter\n      );\n    }\n    if (_instance.nextPageToken) {\n      _writer.writeString(2, _instance.nextPageToken);\n    }\n  }\n\n  private _operations?: Operation[];\n  private _nextPageToken?: 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 ListOperationsResponse to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<ListOperationsResponse.AsObject>) {\n    _value = _value || {};\n    this.operations = (_value.operations || []).map(m => new Operation(m));\n    this.nextPageToken = _value.nextPageToken;\n    ListOperationsResponse.refineValues(this);\n  }\n  get operations(): Operation[] | undefined {\n    return this._operations;\n  }\n  set operations(value: Operation[] | undefined) {\n    this._operations = value;\n  }\n  get nextPageToken(): string | undefined {\n    return this._nextPageToken;\n  }\n  set nextPageToken(value: string | undefined) {\n    this._nextPageToken = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    ListOperationsResponse.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(): ListOperationsResponse.AsObject {\n    return {\n      operations: (this.operations || []).map(m => m.toObject()),\n      nextPageToken: this.nextPageToken\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  ): ListOperationsResponse.AsProtobufJSON {\n    return {\n      operations: (this.operations || []).map(m => m.toProtobufJSON(options)),\n      nextPageToken: this.nextPageToken\n    };\n  }\n}\nexport module ListOperationsResponse {\n  /**\n   * Standard JavaScript object representation for ListOperationsResponse\n   */\n  export interface AsObject {\n    operations?: Operation.AsObject[];\n    nextPageToken?: string;\n  }\n\n  /**\n   * Protobuf JSON representation for ListOperationsResponse\n   */\n  export interface AsProtobufJSON {\n    operations?: Operation.AsProtobufJSON[] | null;\n    nextPageToken?: string;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.CancelOperationRequest\n */\nexport class CancelOperationRequest implements GrpcMessage {\n  static id = 'ondewo.nlu.CancelOperationRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new CancelOperationRequest();\n    CancelOperationRequest.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: CancelOperationRequest) {\n    _instance.name = _instance.name || '';\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: CancelOperationRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.name = _reader.readString();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    CancelOperationRequest.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: CancelOperationRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.name) {\n      _writer.writeString(1, _instance.name);\n    }\n  }\n\n  private _name?: 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 CancelOperationRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<CancelOperationRequest.AsObject>) {\n    _value = _value || {};\n    this.name = _value.name;\n    CancelOperationRequest.refineValues(this);\n  }\n  get name(): string | undefined {\n    return this._name;\n  }\n  set name(value: string | undefined) {\n    this._name = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    CancelOperationRequest.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(): CancelOperationRequest.AsObject {\n    return {\n      name: this.name\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  ): CancelOperationRequest.AsProtobufJSON {\n    return {\n      name: this.name\n    };\n  }\n}\nexport module CancelOperationRequest {\n  /**\n   * Standard JavaScript object representation for CancelOperationRequest\n   */\n  export interface AsObject {\n    name?: string;\n  }\n\n  /**\n   * Protobuf JSON representation for CancelOperationRequest\n   */\n  export interface AsProtobufJSON {\n    name?: string;\n  }\n}\n\n/**\n * Message implementation for ondewo.nlu.DeleteOperationRequest\n */\nexport class DeleteOperationRequest implements GrpcMessage {\n  static id = 'ondewo.nlu.DeleteOperationRequest';\n\n  /**\n   * Deserialize binary data to message\n   * @param instance message instance\n   */\n  static deserializeBinary(bytes: ByteSource) {\n    const instance = new DeleteOperationRequest();\n    DeleteOperationRequest.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: DeleteOperationRequest) {\n    _instance.name = _instance.name || '';\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: DeleteOperationRequest,\n    _reader: BinaryReader\n  ) {\n    while (_reader.nextField()) {\n      if (_reader.isEndGroup()) break;\n\n      switch (_reader.getFieldNumber()) {\n        case 1:\n          _instance.name = _reader.readString();\n          break;\n        default:\n          _reader.skipField();\n      }\n    }\n\n    DeleteOperationRequest.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: DeleteOperationRequest,\n    _writer: BinaryWriter\n  ) {\n    if (_instance.name) {\n      _writer.writeString(1, _instance.name);\n    }\n  }\n\n  private _name?: 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 DeleteOperationRequest to deeply clone from\n   */\n  constructor(_value?: RecursivePartial<DeleteOperationRequest.AsObject>) {\n    _value = _value || {};\n    this.name = _value.name;\n    DeleteOperationRequest.refineValues(this);\n  }\n  get name(): string | undefined {\n    return this._name;\n  }\n  set name(value: string | undefined) {\n    this._name = value;\n  }\n\n  /**\n   * Serialize message to binary data\n   * @param instance message instance\n   */\n  serializeBinary() {\n    const writer = new BinaryWriter();\n    DeleteOperationRequest.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(): DeleteOperationRequest.AsObject {\n    return {\n      name: this.name\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  ): DeleteOperationRequest.AsProtobufJSON {\n    return {\n      name: this.name\n    };\n  }\n}\nexport module DeleteOperationRequest {\n  /**\n   * Standard JavaScript object representation for DeleteOperationRequest\n   */\n  export interface AsObject {\n    name?: string;\n  }\n\n  /**\n   * Protobuf JSON representation for DeleteOperationRequest\n   */\n  export interface AsProtobufJSON {\n    name?: string;\n  }\n}\n"]}