@milaboratories/pl-client 2.11.8 → 2.11.10

package/dist/proto/github.com/milaboratory/pl/plapi/plapiproto/api_types.js

@@ -0,0 +1,1113 @@
+import { MessageType, reflectionMergePartial, UnknownFieldHandler, WireType } from '@protobuf-ts/runtime';
+import { NotificationFilter_Payload } from './resource_types.js';
+import { ResourceType, FieldRef, FieldType } from './base_types.js';
+import { Timestamp } from '../../../../../google/protobuf/timestamp.js';
+
+/**
+ * @generated from protobuf enum MiLaboratories.PL.API.Resource.Kind
+ */
+var Resource_Kind;
+(function (Resource_Kind) {
+    /**
+     * @generated from protobuf enum value: KIND_INVALID = 0;
+     */
+    Resource_Kind[Resource_Kind["INVALID"] = 0] = "INVALID";
+    /**
+     * @generated from protobuf enum value: KIND_STRUCTURAL = 1;
+     */
+    Resource_Kind[Resource_Kind["STRUCTURAL"] = 1] = "STRUCTURAL";
+    /**
+     * @generated from protobuf enum value: KIND_VALUE = 2;
+     */
+    Resource_Kind[Resource_Kind["VALUE"] = 2] = "VALUE";
+})(Resource_Kind || (Resource_Kind = {}));
+/**
+ * @generated from protobuf enum MiLaboratories.PL.API.Field.ValueStatus
+ */
+var Field_ValueStatus;
+(function (Field_ValueStatus) {
+    /**
+     * @generated from protobuf enum value: INVALID = 0;
+     */
+    Field_ValueStatus[Field_ValueStatus["INVALID"] = 0] = "INVALID";
+    /**
+     * @generated from protobuf enum value: EMPTY = 1;
+     */
+    Field_ValueStatus[Field_ValueStatus["EMPTY"] = 1] = "EMPTY";
+    /**
+     * @generated from protobuf enum value: ASSIGNED = 2;
+     */
+    Field_ValueStatus[Field_ValueStatus["ASSIGNED"] = 2] = "ASSIGNED";
+    /**
+     * @generated from protobuf enum value: RESOLVED = 3;
+     */
+    Field_ValueStatus[Field_ValueStatus["RESOLVED"] = 3] = "RESOLVED";
+})(Field_ValueStatus || (Field_ValueStatus = {}));
+// @generated message type with reflection information, may provide speed optimized methods
+class Tx$Type extends MessageType {
+    constructor() {
+        super("MiLaboratories.PL.API.Tx", [
+            { no: 1, name: "is_valid", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 2, name: "id", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.isValid = false;
+        message.id = 0n;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* bool is_valid */ 1:
+                    message.isValid = reader.bool();
+                    break;
+                case /* uint64 id */ 2:
+                    message.id = reader.uint64().toBigInt();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* bool is_valid = 1; */
+        if (message.isValid !== false)
+            writer.tag(1, WireType.Varint).bool(message.isValid);
+        /* uint64 id = 2; */
+        if (message.id !== 0n)
+            writer.tag(2, WireType.Varint).uint64(message.id);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message MiLaboratories.PL.API.Tx
+ */
+const Tx = new Tx$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Resource$Type extends MessageType {
+    constructor() {
+        super("MiLaboratories.PL.API.Resource", [
+            { no: 2, name: "id", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 17, name: "canonical_id", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
+            { no: 3, name: "kind", kind: "enum", T: () => ["MiLaboratories.PL.API.Resource.Kind", Resource_Kind, "KIND_"] },
+            { no: 4, name: "type", kind: "message", T: () => ResourceType },
+            { no: 5, name: "data", kind: "scalar", T: 12 /*ScalarType.BYTES*/ },
+            { no: 16, name: "features", kind: "message", T: () => Resource_Features },
+            { no: 6, name: "fields", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => Field },
+            { no: 7, name: "has_errors", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 8, name: "inputs_locked", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 9, name: "outputs_locked", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 14, name: "resource_ready", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 15, name: "is_final", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 10, name: "original_resource_id", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 11, name: "parent_resource_id", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 12, name: "created_time", kind: "message", T: () => Timestamp },
+            { no: 13, name: "deleted_time", kind: "message", T: () => Timestamp }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.id = 0n;
+        message.canonicalId = new Uint8Array(0);
+        message.kind = 0;
+        message.data = new Uint8Array(0);
+        message.fields = [];
+        message.hasErrors = false;
+        message.inputsLocked = false;
+        message.outputsLocked = false;
+        message.resourceReady = false;
+        message.isFinal = false;
+        message.originalResourceId = 0n;
+        message.parentResourceId = 0n;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* uint64 id */ 2:
+                    message.id = reader.uint64().toBigInt();
+                    break;
+                case /* bytes canonical_id */ 17:
+                    message.canonicalId = reader.bytes();
+                    break;
+                case /* MiLaboratories.PL.API.Resource.Kind kind */ 3:
+                    message.kind = reader.int32();
+                    break;
+                case /* MiLaboratories.PL.Base.ResourceType type */ 4:
+                    message.type = ResourceType.internalBinaryRead(reader, reader.uint32(), options, message.type);
+                    break;
+                case /* bytes data */ 5:
+                    message.data = reader.bytes();
+                    break;
+                case /* MiLaboratories.PL.API.Resource.Features features */ 16:
+                    message.features = Resource_Features.internalBinaryRead(reader, reader.uint32(), options, message.features);
+                    break;
+                case /* repeated MiLaboratories.PL.API.Field fields */ 6:
+                    message.fields.push(Field.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                case /* bool has_errors */ 7:
+                    message.hasErrors = reader.bool();
+                    break;
+                case /* bool inputs_locked */ 8:
+                    message.inputsLocked = reader.bool();
+                    break;
+                case /* bool outputs_locked */ 9:
+                    message.outputsLocked = reader.bool();
+                    break;
+                case /* bool resource_ready */ 14:
+                    message.resourceReady = reader.bool();
+                    break;
+                case /* bool is_final */ 15:
+                    message.isFinal = reader.bool();
+                    break;
+                case /* uint64 original_resource_id */ 10:
+                    message.originalResourceId = reader.uint64().toBigInt();
+                    break;
+                case /* uint64 parent_resource_id */ 11:
+                    message.parentResourceId = reader.uint64().toBigInt();
+                    break;
+                case /* google.protobuf.Timestamp created_time */ 12:
+                    message.createdTime = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.createdTime);
+                    break;
+                case /* google.protobuf.Timestamp deleted_time */ 13:
+                    message.deletedTime = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.deletedTime);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* uint64 id = 2; */
+        if (message.id !== 0n)
+            writer.tag(2, WireType.Varint).uint64(message.id);
+        /* MiLaboratories.PL.API.Resource.Kind kind = 3; */
+        if (message.kind !== 0)
+            writer.tag(3, WireType.Varint).int32(message.kind);
+        /* MiLaboratories.PL.Base.ResourceType type = 4; */
+        if (message.type)
+            ResourceType.internalBinaryWrite(message.type, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+        /* bytes data = 5; */
+        if (message.data.length)
+            writer.tag(5, WireType.LengthDelimited).bytes(message.data);
+        /* repeated MiLaboratories.PL.API.Field fields = 6; */
+        for (let i = 0; i < message.fields.length; i++)
+            Field.internalBinaryWrite(message.fields[i], writer.tag(6, WireType.LengthDelimited).fork(), options).join();
+        /* bool has_errors = 7; */
+        if (message.hasErrors !== false)
+            writer.tag(7, WireType.Varint).bool(message.hasErrors);
+        /* bool inputs_locked = 8; */
+        if (message.inputsLocked !== false)
+            writer.tag(8, WireType.Varint).bool(message.inputsLocked);
+        /* bool outputs_locked = 9; */
+        if (message.outputsLocked !== false)
+            writer.tag(9, WireType.Varint).bool(message.outputsLocked);
+        /* uint64 original_resource_id = 10; */
+        if (message.originalResourceId !== 0n)
+            writer.tag(10, WireType.Varint).uint64(message.originalResourceId);
+        /* uint64 parent_resource_id = 11; */
+        if (message.parentResourceId !== 0n)
+            writer.tag(11, WireType.Varint).uint64(message.parentResourceId);
+        /* google.protobuf.Timestamp created_time = 12; */
+        if (message.createdTime)
+            Timestamp.internalBinaryWrite(message.createdTime, writer.tag(12, WireType.LengthDelimited).fork(), options).join();
+        /* google.protobuf.Timestamp deleted_time = 13; */
+        if (message.deletedTime)
+            Timestamp.internalBinaryWrite(message.deletedTime, writer.tag(13, WireType.LengthDelimited).fork(), options).join();
+        /* bool resource_ready = 14; */
+        if (message.resourceReady !== false)
+            writer.tag(14, WireType.Varint).bool(message.resourceReady);
+        /* bool is_final = 15; */
+        if (message.isFinal !== false)
+            writer.tag(15, WireType.Varint).bool(message.isFinal);
+        /* MiLaboratories.PL.API.Resource.Features features = 16; */
+        if (message.features)
+            Resource_Features.internalBinaryWrite(message.features, writer.tag(16, WireType.LengthDelimited).fork(), options).join();
+        /* bytes canonical_id = 17; */
+        if (message.canonicalId.length)
+            writer.tag(17, WireType.LengthDelimited).bytes(message.canonicalId);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message MiLaboratories.PL.API.Resource
+ */
+const Resource = new Resource$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Resource_Features$Type extends MessageType {
+    constructor() {
+        super("MiLaboratories.PL.API.Resource.Features", [
+            { no: 1, name: "ephemeral", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.ephemeral = false;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* bool ephemeral */ 1:
+                    message.ephemeral = reader.bool();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* bool ephemeral = 1; */
+        if (message.ephemeral !== false)
+            writer.tag(1, WireType.Varint).bool(message.ephemeral);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message MiLaboratories.PL.API.Resource.Features
+ */
+const Resource_Features = new Resource_Features$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Field$Type extends MessageType {
+    constructor() {
+        super("MiLaboratories.PL.API.Field", [
+            { no: 1, name: "id", kind: "message", T: () => FieldRef },
+            { no: 2, name: "type", kind: "enum", T: () => ["MiLaboratories.PL.Base.FieldType", FieldType] },
+            { no: 3, name: "features", kind: "message", T: () => Resource_Features },
+            { no: 5, name: "value", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 7, name: "value_status", kind: "enum", T: () => ["MiLaboratories.PL.API.Field.ValueStatus", Field_ValueStatus] },
+            { no: 8, name: "value_is_final", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 6, name: "error", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.type = 0;
+        message.value = 0n;
+        message.valueStatus = 0;
+        message.valueIsFinal = false;
+        message.error = 0n;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* MiLaboratories.PL.Base.FieldRef id */ 1:
+                    message.id = FieldRef.internalBinaryRead(reader, reader.uint32(), options, message.id);
+                    break;
+                case /* MiLaboratories.PL.Base.FieldType type */ 2:
+                    message.type = reader.int32();
+                    break;
+                case /* MiLaboratories.PL.API.Resource.Features features */ 3:
+                    message.features = Resource_Features.internalBinaryRead(reader, reader.uint32(), options, message.features);
+                    break;
+                case /* uint64 value */ 5:
+                    message.value = reader.uint64().toBigInt();
+                    break;
+                case /* MiLaboratories.PL.API.Field.ValueStatus value_status */ 7:
+                    message.valueStatus = reader.int32();
+                    break;
+                case /* bool value_is_final */ 8:
+                    message.valueIsFinal = reader.bool();
+                    break;
+                case /* uint64 error */ 6:
+                    message.error = reader.uint64().toBigInt();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* MiLaboratories.PL.Base.FieldRef id = 1; */
+        if (message.id)
+            FieldRef.internalBinaryWrite(message.id, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* MiLaboratories.PL.Base.FieldType type = 2; */
+        if (message.type !== 0)
+            writer.tag(2, WireType.Varint).int32(message.type);
+        /* MiLaboratories.PL.API.Resource.Features features = 3; */
+        if (message.features)
+            Resource_Features.internalBinaryWrite(message.features, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* uint64 value = 5; */
+        if (message.value !== 0n)
+            writer.tag(5, WireType.Varint).uint64(message.value);
+        /* uint64 error = 6; */
+        if (message.error !== 0n)
+            writer.tag(6, WireType.Varint).uint64(message.error);
+        /* MiLaboratories.PL.API.Field.ValueStatus value_status = 7; */
+        if (message.valueStatus !== 0)
+            writer.tag(7, WireType.Varint).int32(message.valueStatus);
+        /* bool value_is_final = 8; */
+        if (message.valueIsFinal !== false)
+            writer.tag(8, WireType.Varint).bool(message.valueIsFinal);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message MiLaboratories.PL.API.Field
+ */
+const Field = new Field$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Notification$Type extends MessageType {
+    constructor() {
+        super("MiLaboratories.PL.API.Notification", [
+            { no: 1, name: "subscription_id", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 2, name: "event_id", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 3, name: "resource_id", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 4, name: "resource_type", kind: "message", T: () => ResourceType },
+            { no: 5, name: "events", kind: "message", T: () => Notification_Events },
+            { no: 6, name: "field_changes", kind: "map", K: 9 /*ScalarType.STRING*/, V: { kind: "message", T: () => Notification_FieldChange } },
+            { no: 7, name: "payload", kind: "message", T: () => NotificationFilter_Payload },
+            { no: 8, name: "filter_name", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 9, name: "tx_span", kind: "message", T: () => SpanInfo }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.subscriptionId = 0n;
+        message.eventId = 0n;
+        message.resourceId = 0n;
+        message.fieldChanges = {};
+        message.filterName = "";
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* uint64 subscription_id */ 1:
+                    message.subscriptionId = reader.uint64().toBigInt();
+                    break;
+                case /* uint64 event_id */ 2:
+                    message.eventId = reader.uint64().toBigInt();
+                    break;
+                case /* uint64 resource_id */ 3:
+                    message.resourceId = reader.uint64().toBigInt();
+                    break;
+                case /* MiLaboratories.PL.Base.ResourceType resource_type */ 4:
+                    message.resourceType = ResourceType.internalBinaryRead(reader, reader.uint32(), options, message.resourceType);
+                    break;
+                case /* MiLaboratories.PL.API.Notification.Events events */ 5:
+                    message.events = Notification_Events.internalBinaryRead(reader, reader.uint32(), options, message.events);
+                    break;
+                case /* map<string, MiLaboratories.PL.API.Notification.FieldChange> field_changes */ 6:
+                    this.binaryReadMap6(message.fieldChanges, reader, options);
+                    break;
+                case /* MiLaboratories.PL.RTypes.NotificationFilter.Payload payload */ 7:
+                    message.payload = NotificationFilter_Payload.internalBinaryRead(reader, reader.uint32(), options, message.payload);
+                    break;
+                case /* string filter_name */ 8:
+                    message.filterName = reader.string();
+                    break;
+                case /* MiLaboratories.PL.API.SpanInfo tx_span */ 9:
+                    message.txSpan = SpanInfo.internalBinaryRead(reader, reader.uint32(), options, message.txSpan);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    binaryReadMap6(map, reader, options) {
+        let len = reader.uint32(), end = reader.pos + len, key, val;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case 1:
+                    key = reader.string();
+                    break;
+                case 2:
+                    val = Notification_FieldChange.internalBinaryRead(reader, reader.uint32(), options);
+                    break;
+                default: throw new globalThis.Error("unknown map entry field for MiLaboratories.PL.API.Notification.field_changes");
+            }
+        }
+        map[key ?? ""] = val ?? Notification_FieldChange.create();
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* uint64 subscription_id = 1; */
+        if (message.subscriptionId !== 0n)
+            writer.tag(1, WireType.Varint).uint64(message.subscriptionId);
+        /* uint64 event_id = 2; */
+        if (message.eventId !== 0n)
+            writer.tag(2, WireType.Varint).uint64(message.eventId);
+        /* uint64 resource_id = 3; */
+        if (message.resourceId !== 0n)
+            writer.tag(3, WireType.Varint).uint64(message.resourceId);
+        /* MiLaboratories.PL.Base.ResourceType resource_type = 4; */
+        if (message.resourceType)
+            ResourceType.internalBinaryWrite(message.resourceType, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+        /* MiLaboratories.PL.API.Notification.Events events = 5; */
+        if (message.events)
+            Notification_Events.internalBinaryWrite(message.events, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+        /* map<string, MiLaboratories.PL.API.Notification.FieldChange> field_changes = 6; */
+        for (let k of globalThis.Object.keys(message.fieldChanges)) {
+            writer.tag(6, WireType.LengthDelimited).fork().tag(1, WireType.LengthDelimited).string(k);
+            writer.tag(2, WireType.LengthDelimited).fork();
+            Notification_FieldChange.internalBinaryWrite(message.fieldChanges[k], writer, options);
+            writer.join().join();
+        }
+        /* MiLaboratories.PL.RTypes.NotificationFilter.Payload payload = 7; */
+        if (message.payload)
+            NotificationFilter_Payload.internalBinaryWrite(message.payload, writer.tag(7, WireType.LengthDelimited).fork(), options).join();
+        /* string filter_name = 8; */
+        if (message.filterName !== "")
+            writer.tag(8, WireType.LengthDelimited).string(message.filterName);
+        /* MiLaboratories.PL.API.SpanInfo tx_span = 9; */
+        if (message.txSpan)
+            SpanInfo.internalBinaryWrite(message.txSpan, writer.tag(9, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message MiLaboratories.PL.API.Notification
+ */
+const Notification = new Notification$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Notification_Events$Type extends MessageType {
+    constructor() {
+        super("MiLaboratories.PL.API.Notification.Events", [
+            { no: 1, name: "resource_created", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 2, name: "resource_deleted", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 4, name: "resource_ready", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 5, name: "resource_duplicate", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 15, name: "resource_error", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 12, name: "inputs_locked", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 13, name: "outputs_locked", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 11, name: "field_created", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 16, name: "field_got_error", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 6, name: "input_set", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 7, name: "all_inputs_set", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 8, name: "output_set", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 9, name: "all_outputs_set", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 14, name: "generic_otw_set", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 10, name: "dynamic_changed", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.resourceCreated = false;
+        message.resourceDeleted = false;
+        message.resourceReady = false;
+        message.resourceDuplicate = false;
+        message.resourceError = false;
+        message.inputsLocked = false;
+        message.outputsLocked = false;
+        message.fieldCreated = false;
+        message.fieldGotError = false;
+        message.inputSet = false;
+        message.allInputsSet = false;
+        message.outputSet = false;
+        message.allOutputsSet = false;
+        message.genericOtwSet = false;
+        message.dynamicChanged = false;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* bool resource_created */ 1:
+                    message.resourceCreated = reader.bool();
+                    break;
+                case /* bool resource_deleted */ 2:
+                    message.resourceDeleted = reader.bool();
+                    break;
+                case /* bool resource_ready */ 4:
+                    message.resourceReady = reader.bool();
+                    break;
+                case /* bool resource_duplicate */ 5:
+                    message.resourceDuplicate = reader.bool();
+                    break;
+                case /* bool resource_error */ 15:
+                    message.resourceError = reader.bool();
+                    break;
+                case /* bool inputs_locked */ 12:
+                    message.inputsLocked = reader.bool();
+                    break;
+                case /* bool outputs_locked */ 13:
+                    message.outputsLocked = reader.bool();
+                    break;
+                case /* bool field_created */ 11:
+                    message.fieldCreated = reader.bool();
+                    break;
+                case /* bool field_got_error */ 16:
+                    message.fieldGotError = reader.bool();
+                    break;
+                case /* bool input_set */ 6:
+                    message.inputSet = reader.bool();
+                    break;
+                case /* bool all_inputs_set */ 7:
+                    message.allInputsSet = reader.bool();
+                    break;
+                case /* bool output_set */ 8:
+                    message.outputSet = reader.bool();
+                    break;
+                case /* bool all_outputs_set */ 9:
+                    message.allOutputsSet = reader.bool();
+                    break;
+                case /* bool generic_otw_set */ 14:
+                    message.genericOtwSet = reader.bool();
+                    break;
+                case /* bool dynamic_changed */ 10:
+                    message.dynamicChanged = reader.bool();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* bool resource_created = 1; */
+        if (message.resourceCreated !== false)
+            writer.tag(1, WireType.Varint).bool(message.resourceCreated);
+        /* bool resource_deleted = 2; */
+        if (message.resourceDeleted !== false)
+            writer.tag(2, WireType.Varint).bool(message.resourceDeleted);
+        /* bool resource_ready = 4; */
+        if (message.resourceReady !== false)
+            writer.tag(4, WireType.Varint).bool(message.resourceReady);
+        /* bool resource_duplicate = 5; */
+        if (message.resourceDuplicate !== false)
+            writer.tag(5, WireType.Varint).bool(message.resourceDuplicate);
+        /* bool input_set = 6; */
+        if (message.inputSet !== false)
+            writer.tag(6, WireType.Varint).bool(message.inputSet);
+        /* bool all_inputs_set = 7; */
+        if (message.allInputsSet !== false)
+            writer.tag(7, WireType.Varint).bool(message.allInputsSet);
+        /* bool output_set = 8; */
+        if (message.outputSet !== false)
+            writer.tag(8, WireType.Varint).bool(message.outputSet);
+        /* bool all_outputs_set = 9; */
+        if (message.allOutputsSet !== false)
+            writer.tag(9, WireType.Varint).bool(message.allOutputsSet);
+        /* bool dynamic_changed = 10; */
+        if (message.dynamicChanged !== false)
+            writer.tag(10, WireType.Varint).bool(message.dynamicChanged);
+        /* bool field_created = 11; */
+        if (message.fieldCreated !== false)
+            writer.tag(11, WireType.Varint).bool(message.fieldCreated);
+        /* bool inputs_locked = 12; */
+        if (message.inputsLocked !== false)
+            writer.tag(12, WireType.Varint).bool(message.inputsLocked);
+        /* bool outputs_locked = 13; */
+        if (message.outputsLocked !== false)
+            writer.tag(13, WireType.Varint).bool(message.outputsLocked);
+        /* bool generic_otw_set = 14; */
+        if (message.genericOtwSet !== false)
+            writer.tag(14, WireType.Varint).bool(message.genericOtwSet);
+        /* bool resource_error = 15; */
+        if (message.resourceError !== false)
+            writer.tag(15, WireType.Varint).bool(message.resourceError);
+        /* bool field_got_error = 16; */
+        if (message.fieldGotError !== false)
+            writer.tag(16, WireType.Varint).bool(message.fieldGotError);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message MiLaboratories.PL.API.Notification.Events
+ */
+const Notification_Events = new Notification_Events$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Notification_FieldChange$Type extends MessageType {
+    constructor() {
+        super("MiLaboratories.PL.API.Notification.FieldChange", [
+            { no: 1, name: "old", kind: "message", T: () => Field },
+            { no: 2, name: "new", kind: "message", T: () => Field }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* MiLaboratories.PL.API.Field old */ 1:
+                    message.old = Field.internalBinaryRead(reader, reader.uint32(), options, message.old);
+                    break;
+                case /* MiLaboratories.PL.API.Field new */ 2:
+                    message.new = Field.internalBinaryRead(reader, reader.uint32(), options, message.new);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* MiLaboratories.PL.API.Field old = 1; */
+        if (message.old)
+            Field.internalBinaryWrite(message.old, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* MiLaboratories.PL.API.Field new = 2; */
+        if (message.new)
+            Field.internalBinaryWrite(message.new, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message MiLaboratories.PL.API.Notification.FieldChange
+ */
+const Notification_FieldChange = new Notification_FieldChange$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class SpanInfo$Type extends MessageType {
+    constructor() {
+        super("MiLaboratories.PL.API.SpanInfo", [
+            { no: 1, name: "path", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "carrier", kind: "map", K: 9 /*ScalarType.STRING*/, V: { kind: "scalar", T: 9 /*ScalarType.STRING*/ } }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.path = "";
+        message.carrier = {};
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string path */ 1:
+                    message.path = reader.string();
+                    break;
+                case /* map<string, string> carrier */ 2:
+                    this.binaryReadMap2(message.carrier, reader, options);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    binaryReadMap2(map, reader, options) {
+        let len = reader.uint32(), end = reader.pos + len, key, val;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case 1:
+                    key = reader.string();
+                    break;
+                case 2:
+                    val = reader.string();
+                    break;
+                default: throw new globalThis.Error("unknown map entry field for MiLaboratories.PL.API.SpanInfo.carrier");
+            }
+        }
+        map[key ?? ""] = val ?? "";
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string path = 1; */
+        if (message.path !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.path);
+        /* map<string, string> carrier = 2; */
+        for (let k of globalThis.Object.keys(message.carrier))
+            writer.tag(2, WireType.LengthDelimited).fork().tag(1, WireType.LengthDelimited).string(k).tag(2, WireType.LengthDelimited).string(message.carrier[k]).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message MiLaboratories.PL.API.SpanInfo
+ */
+const SpanInfo = new SpanInfo$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Subscription$Type extends MessageType {
+    constructor() {
+        super("MiLaboratories.PL.API.Subscription", [
+            { no: 1, name: "id", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 3, name: "blocking", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.id = 0n;
+        message.blocking = false;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* uint64 id */ 1:
+                    message.id = reader.uint64().toBigInt();
+                    break;
+                case /* bool blocking */ 3:
+                    message.blocking = reader.bool();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* uint64 id = 1; */
+        if (message.id !== 0n)
+            writer.tag(1, WireType.Varint).uint64(message.id);
+        /* bool blocking = 3; */
+        if (message.blocking !== false)
+            writer.tag(3, WireType.Varint).bool(message.blocking);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message MiLaboratories.PL.API.Subscription
+ */
+const Subscription = new Subscription$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Controller$Type extends MessageType {
+    constructor() {
+        super("MiLaboratories.PL.API.Controller", [
+            { no: 1, name: "type", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "id", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 3, name: "subscriptionID", kind: "scalar", T: 4 /*ScalarType.UINT64*/, L: 0 /*LongType.BIGINT*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.type = "";
+        message.id = 0n;
+        message.subscriptionID = 0n;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string type */ 1:
+                    message.type = reader.string();
+                    break;
+                case /* uint64 id */ 2:
+                    message.id = reader.uint64().toBigInt();
+                    break;
+                case /* uint64 subscriptionID */ 3:
+                    message.subscriptionID = reader.uint64().toBigInt();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string type = 1; */
+        if (message.type !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.type);
+        /* uint64 id = 2; */
+        if (message.id !== 0n)
+            writer.tag(2, WireType.Varint).uint64(message.id);
+        /* uint64 subscriptionID = 3; */
+        if (message.subscriptionID !== 0n)
+            writer.tag(3, WireType.Varint).uint64(message.subscriptionID);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message MiLaboratories.PL.API.Controller
+ */
+const Controller = new Controller$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ResourceSchema$Type extends MessageType {
+    constructor() {
+        super("MiLaboratories.PL.API.ResourceSchema", [
+            { no: 1, name: "type", kind: "message", T: () => ResourceType },
+            { no: 2, name: "fields", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => FieldSchema }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.fields = [];
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* MiLaboratories.PL.Base.ResourceType type */ 1:
+                    message.type = ResourceType.internalBinaryRead(reader, reader.uint32(), options, message.type);
+                    break;
+                case /* repeated MiLaboratories.PL.API.FieldSchema fields */ 2:
+                    message.fields.push(FieldSchema.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* MiLaboratories.PL.Base.ResourceType type = 1; */
+        if (message.type)
+            ResourceType.internalBinaryWrite(message.type, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* repeated MiLaboratories.PL.API.FieldSchema fields = 2; */
+        for (let i = 0; i < message.fields.length; i++)
+            FieldSchema.internalBinaryWrite(message.fields[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message MiLaboratories.PL.API.ResourceSchema
+ */
+const ResourceSchema = new ResourceSchema$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class FieldSchema$Type extends MessageType {
+    constructor() {
+        super("MiLaboratories.PL.API.FieldSchema", [
+            { no: 1, name: "type", kind: "enum", T: () => ["MiLaboratories.PL.Base.FieldType", FieldType] },
+            { no: 2, name: "name", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.type = 0;
+        message.name = "";
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* MiLaboratories.PL.Base.FieldType type */ 1:
+                    message.type = reader.int32();
+                    break;
+                case /* string name */ 2:
+                    message.name = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* MiLaboratories.PL.Base.FieldType type = 1; */
+        if (message.type !== 0)
+            writer.tag(1, WireType.Varint).int32(message.type);
+        /* string name = 2; */
+        if (message.name !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.name);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message MiLaboratories.PL.API.FieldSchema
+ */
+const FieldSchema = new FieldSchema$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ResourceAPIFeature$Type extends MessageType {
+    constructor() {
+        super("MiLaboratories.PL.API.ResourceAPIFeature", [
+            { no: 1, name: "controller_type", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "feature_name", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "resource_type", kind: "message", T: () => ResourceType },
+            { no: 4, name: "endpoint", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.controllerType = "";
+        message.featureName = "";
+        message.endpoint = "";
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string controller_type */ 1:
+                    message.controllerType = reader.string();
+                    break;
+                case /* string feature_name */ 2:
+                    message.featureName = reader.string();
+                    break;
+                case /* MiLaboratories.PL.Base.ResourceType resource_type */ 3:
+                    message.resourceType = ResourceType.internalBinaryRead(reader, reader.uint32(), options, message.resourceType);
+                    break;
+                case /* string endpoint */ 4:
+                    message.endpoint = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string controller_type = 1; */
+        if (message.controllerType !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.controllerType);
+        /* string feature_name = 2; */
+        if (message.featureName !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.featureName);
+        /* MiLaboratories.PL.Base.ResourceType resource_type = 3; */
+        if (message.resourceType)
+            ResourceType.internalBinaryWrite(message.resourceType, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* string endpoint = 4; */
+        if (message.endpoint !== "")
+            writer.tag(4, WireType.LengthDelimited).string(message.endpoint);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message MiLaboratories.PL.API.ResourceAPIFeature
+ */
+const ResourceAPIFeature = new ResourceAPIFeature$Type();
+
+export { Controller, Field, FieldSchema, Field_ValueStatus, Notification, Notification_Events, Notification_FieldChange, Resource, ResourceAPIFeature, ResourceSchema, Resource_Features, Resource_Kind, SpanInfo, Subscription, Tx };
+//# sourceMappingURL=api_types.js.map