@otonoma/paranet-client 2.11.0-rc.18

package/dist/proto/pncp.js

@@ -0,0 +1,936 @@
+import { WireType } from "@protobuf-ts/runtime";
+import { UnknownFieldHandler } from "@protobuf-ts/runtime";
+import { reflectionMergePartial } from "@protobuf-ts/runtime";
+import { MessageType } from "@protobuf-ts/runtime";
+import { Timestamp } from "./google/protobuf/timestamp";
+import { EntityId } from "./identifiers";
+import { ConversationId } from "./identifiers";
+import { Value } from "./otonoma/common/value";
+/**
+ * Context flags (default 0)
+ *
+ * @generated from protobuf enum pncp.v1.PncpRequestCallback.CallbackFlags
+ */
+export var PncpRequestCallback_CallbackFlags;
+(function (PncpRequestCallback_CallbackFlags) {
+    /**
+     * @generated from protobuf enum value: FLAG_NONE = 0;
+     */
+    PncpRequestCallback_CallbackFlags[PncpRequestCallback_CallbackFlags["FLAG_NONE"] = 0] = "FLAG_NONE";
+    /**
+     * privileged actor request
+     *
+     * @generated from protobuf enum value: FLAG_PRIVILEGED = 1;
+     */
+    PncpRequestCallback_CallbackFlags[PncpRequestCallback_CallbackFlags["FLAG_PRIVILEGED"] = 1] = "FLAG_PRIVILEGED";
+})(PncpRequestCallback_CallbackFlags || (PncpRequestCallback_CallbackFlags = {}));
+/**
+ * Match strategy. Defaults to `BEST`.
+ *
+ * @generated from protobuf enum pncp.v1.SkillMatchStrategy
+ */
+export var SkillMatchStrategy;
+(function (SkillMatchStrategy) {
+    /**
+     * @generated from protobuf enum value: BEST = 0;
+     */
+    SkillMatchStrategy[SkillMatchStrategy["BEST"] = 0] = "BEST";
+    /**
+     * @generated from protobuf enum value: FIRST = 1;
+     */
+    SkillMatchStrategy[SkillMatchStrategy["FIRST"] = 1] = "FIRST";
+    /**
+     * @generated from protobuf enum value: STRICT = 2;
+     */
+    SkillMatchStrategy[SkillMatchStrategy["STRICT"] = 2] = "STRICT";
+})(SkillMatchStrategy || (SkillMatchStrategy = {}));
+// NOTE (JAB, 2024-07-08): Protobuf uses C++ scoping rules for enum variants, meaning the name of the enum
+// does not sub-namespace them and two enums next to each other in the same module have the same scope.
+/**
+ * @generated from protobuf enum pncp.v1.PncpMessageKind
+ */
+export var PncpMessageKind;
+(function (PncpMessageKind) {
+    /**
+     * @generated from protobuf enum value: PNCP_RESPONSE = 0;
+     */
+    PncpMessageKind[PncpMessageKind["PNCP_RESPONSE"] = 0] = "PNCP_RESPONSE";
+    /**
+     * @generated from protobuf enum value: PNCP_STATUS = 1;
+     */
+    PncpMessageKind[PncpMessageKind["PNCP_STATUS"] = 1] = "PNCP_STATUS";
+    /**
+     * @generated from protobuf enum value: PNCP_CANCEL = 2;
+     */
+    PncpMessageKind[PncpMessageKind["PNCP_CANCEL"] = 2] = "PNCP_CANCEL";
+    /**
+     * @generated from protobuf enum value: PNCP_ERROR = 3;
+     */
+    PncpMessageKind[PncpMessageKind["PNCP_ERROR"] = 3] = "PNCP_ERROR";
+    /**
+     * @generated from protobuf enum value: PNCP_QUESTION = 4;
+     */
+    PncpMessageKind[PncpMessageKind["PNCP_QUESTION"] = 4] = "PNCP_QUESTION";
+    /**
+     * @generated from protobuf enum value: PNCP_ANSWER = 5;
+     */
+    PncpMessageKind[PncpMessageKind["PNCP_ANSWER"] = 5] = "PNCP_ANSWER";
+})(PncpMessageKind || (PncpMessageKind = {}));
+// These messages represent messages sent back to the actor from the broker.
+/**
+ * @generated from protobuf enum pncp.v1.ConversationState
+ */
+export var ConversationState;
+(function (ConversationState) {
+    /**
+     * @generated from protobuf enum value: STATE_IN_PROGRESS = 0;
+     */
+    ConversationState[ConversationState["STATE_IN_PROGRESS"] = 0] = "STATE_IN_PROGRESS";
+    /**
+     * @generated from protobuf enum value: STATE_COMPLETED = 1;
+     */
+    ConversationState[ConversationState["STATE_COMPLETED"] = 1] = "STATE_COMPLETED";
+    /**
+     * @generated from protobuf enum value: STATE_ERRORED = 2;
+     */
+    ConversationState[ConversationState["STATE_ERRORED"] = 2] = "STATE_ERRORED";
+    /**
+     * @generated from protobuf enum value: STATE_CANCELED = 3;
+     */
+    ConversationState[ConversationState["STATE_CANCELED"] = 3] = "STATE_CANCELED";
+    /**
+     * @generated from protobuf enum value: STATE_UNMATCHED = 4;
+     */
+    ConversationState[ConversationState["STATE_UNMATCHED"] = 4] = "STATE_UNMATCHED";
+    /**
+     * @generated from protobuf enum value: STATE_NETWORKING = 5;
+     */
+    ConversationState[ConversationState["STATE_NETWORKING"] = 5] = "STATE_NETWORKING";
+})(ConversationState || (ConversationState = {}));
+// @generated message type with reflection information, may provide speed optimized methods
+class PncpPacket$Type extends MessageType {
+    constructor() {
+        super("pncp.v1.PncpPacket", [
+            { no: 1, name: "request", kind: "message", oneof: "body", T: () => PncpRequest },
+            { no: 2, name: "message", kind: "message", oneof: "body", T: () => PncpMessage }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.body = { oneofKind: undefined };
+        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 /* pncp.v1.PncpRequest request */ 1:
+                    message.body = {
+                        oneofKind: "request",
+                        request: PncpRequest.internalBinaryRead(reader, reader.uint32(), options, message.body.request)
+                    };
+                    break;
+                case /* pncp.v1.PncpMessage message */ 2:
+                    message.body = {
+                        oneofKind: "message",
+                        message: PncpMessage.internalBinaryRead(reader, reader.uint32(), options, message.body.message)
+                    };
+                    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) {
+        /* pncp.v1.PncpRequest request = 1; */
+        if (message.body.oneofKind === "request")
+            PncpRequest.internalBinaryWrite(message.body.request, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* pncp.v1.PncpMessage message = 2; */
+        if (message.body.oneofKind === "message")
+            PncpMessage.internalBinaryWrite(message.body.message, 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 pncp.v1.PncpPacket
+ */
+export const PncpPacket = new PncpPacket$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class PncpRequest$Type extends MessageType {
+    constructor() {
+        super("pncp.v1.PncpRequest", [
+            { no: 1, name: "body", kind: "message", T: () => PncpSkillMessage },
+            { no: 2, name: "callback", kind: "message", T: () => Value },
+            { no: 3, name: "parent_id", kind: "message", T: () => ConversationId },
+            { no: 4, name: "author", kind: "message", T: () => EntityId },
+            { no: 5, name: "match_strategy", kind: "enum", T: () => ["pncp.v1.SkillMatchStrategy", SkillMatchStrategy] },
+            { no: 6, name: "version_req", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
+            { no: 7, name: "target_actor_id", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ },
+            { no: 8, name: "key", kind: "message", T: () => Value },
+            { no: 9, name: "medium_info", kind: "message", T: () => PncpRequestMediumInfo },
+            { no: 10, name: "must_match", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 11, name: "use_lock", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 12, name: "allow_open_match", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.matchStrategy = 0;
+        message.mustMatch = false;
+        message.useLock = false;
+        message.allowOpenMatch = 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 /* pncp.v1.PncpSkillMessage body */ 1:
+                    message.body = PncpSkillMessage.internalBinaryRead(reader, reader.uint32(), options, message.body);
+                    break;
+                case /* optional otonoma.common.Value callback */ 2:
+                    message.callback = Value.internalBinaryRead(reader, reader.uint32(), options, message.callback);
+                    break;
+                case /* optional pncp.v1.ConversationId parent_id */ 3:
+                    message.parentId = ConversationId.internalBinaryRead(reader, reader.uint32(), options, message.parentId);
+                    break;
+                case /* optional pncp.v1.EntityId author */ 4:
+                    message.author = EntityId.internalBinaryRead(reader, reader.uint32(), options, message.author);
+                    break;
+                case /* pncp.v1.SkillMatchStrategy match_strategy */ 5:
+                    message.matchStrategy = reader.int32();
+                    break;
+                case /* optional string version_req */ 6:
+                    message.versionReq = reader.string();
+                    break;
+                case /* optional string target_actor_id */ 7:
+                    message.targetActorId = reader.string();
+                    break;
+                case /* optional otonoma.common.Value key */ 8:
+                    message.key = Value.internalBinaryRead(reader, reader.uint32(), options, message.key);
+                    break;
+                case /* optional pncp.v1.PncpRequestMediumInfo medium_info */ 9:
+                    message.mediumInfo = PncpRequestMediumInfo.internalBinaryRead(reader, reader.uint32(), options, message.mediumInfo);
+                    break;
+                case /* bool must_match */ 10:
+                    message.mustMatch = reader.bool();
+                    break;
+                case /* bool use_lock */ 11:
+                    message.useLock = reader.bool();
+                    break;
+                case /* bool allow_open_match */ 12:
+                    message.allowOpenMatch = 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) {
+        /* pncp.v1.PncpSkillMessage body = 1; */
+        if (message.body)
+            PncpSkillMessage.internalBinaryWrite(message.body, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* optional otonoma.common.Value callback = 2; */
+        if (message.callback)
+            Value.internalBinaryWrite(message.callback, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* optional pncp.v1.ConversationId parent_id = 3; */
+        if (message.parentId)
+            ConversationId.internalBinaryWrite(message.parentId, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* optional pncp.v1.EntityId author = 4; */
+        if (message.author)
+            EntityId.internalBinaryWrite(message.author, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+        /* pncp.v1.SkillMatchStrategy match_strategy = 5; */
+        if (message.matchStrategy !== 0)
+            writer.tag(5, WireType.Varint).int32(message.matchStrategy);
+        /* optional string version_req = 6; */
+        if (message.versionReq !== undefined)
+            writer.tag(6, WireType.LengthDelimited).string(message.versionReq);
+        /* optional string target_actor_id = 7; */
+        if (message.targetActorId !== undefined)
+            writer.tag(7, WireType.LengthDelimited).string(message.targetActorId);
+        /* optional otonoma.common.Value key = 8; */
+        if (message.key)
+            Value.internalBinaryWrite(message.key, writer.tag(8, WireType.LengthDelimited).fork(), options).join();
+        /* optional pncp.v1.PncpRequestMediumInfo medium_info = 9; */
+        if (message.mediumInfo)
+            PncpRequestMediumInfo.internalBinaryWrite(message.mediumInfo, writer.tag(9, WireType.LengthDelimited).fork(), options).join();
+        /* bool must_match = 10; */
+        if (message.mustMatch !== false)
+            writer.tag(10, WireType.Varint).bool(message.mustMatch);
+        /* bool use_lock = 11; */
+        if (message.useLock !== false)
+            writer.tag(11, WireType.Varint).bool(message.useLock);
+        /* bool allow_open_match = 12; */
+        if (message.allowOpenMatch !== false)
+            writer.tag(12, WireType.Varint).bool(message.allowOpenMatch);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message pncp.v1.PncpRequest
+ */
+export const PncpRequest = new PncpRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class PncpRequestMediumInfo$Type extends MessageType {
+    constructor() {
+        super("pncp.v1.PncpRequestMediumInfo", [
+            { no: 1, name: "id", kind: "message", T: () => EntityId },
+            { no: 2, name: "user_info", kind: "message", T: () => Value }
+        ]);
+    }
+    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 /* pncp.v1.EntityId id */ 1:
+                    message.id = EntityId.internalBinaryRead(reader, reader.uint32(), options, message.id);
+                    break;
+                case /* optional otonoma.common.Value user_info */ 2:
+                    message.userInfo = Value.internalBinaryRead(reader, reader.uint32(), options, message.userInfo);
+                    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) {
+        /* pncp.v1.EntityId id = 1; */
+        if (message.id)
+            EntityId.internalBinaryWrite(message.id, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* optional otonoma.common.Value user_info = 2; */
+        if (message.userInfo)
+            Value.internalBinaryWrite(message.userInfo, 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 pncp.v1.PncpRequestMediumInfo
+ */
+export const PncpRequestMediumInfo = new PncpRequestMediumInfo$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class PncpSkillMessage$Type extends MessageType {
+    constructor() {
+        super("pncp.v1.PncpSkillMessage", [
+            { no: 1, name: "subject", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "action", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 5, name: "body", kind: "message", T: () => Value },
+            { no: 6, name: "taint", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.subject = "";
+        message.action = "";
+        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 subject */ 1:
+                    message.subject = reader.string();
+                    break;
+                case /* string action */ 2:
+                    message.action = reader.string();
+                    break;
+                case /* otonoma.common.Value body */ 5:
+                    message.body = Value.internalBinaryRead(reader, reader.uint32(), options, message.body);
+                    break;
+                case /* optional string taint */ 6:
+                    message.taint = 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 subject = 1; */
+        if (message.subject !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.subject);
+        /* string action = 2; */
+        if (message.action !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.action);
+        /* otonoma.common.Value body = 5; */
+        if (message.body)
+            Value.internalBinaryWrite(message.body, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+        /* optional string taint = 6; */
+        if (message.taint !== undefined)
+            writer.tag(6, WireType.LengthDelimited).string(message.taint);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message pncp.v1.PncpSkillMessage
+ */
+export const PncpSkillMessage = new PncpSkillMessage$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class PncpMessage$Type extends MessageType {
+    constructor() {
+        super("pncp.v1.PncpMessage", [
+            { no: 1, name: "id", kind: "message", T: () => ConversationId },
+            { no: 10, name: "kind", kind: "enum", T: () => ["pncp.v1.PncpMessageKind", PncpMessageKind] },
+            { no: 11, name: "body", kind: "message", T: () => Value },
+            { no: 12, name: "question", kind: "message", oneof: "extra", T: () => PncpQuestionEx },
+            { no: 13, name: "answer", kind: "message", oneof: "extra", T: () => PncpAnswerEx },
+            { no: 14, name: "taint", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.kind = 0;
+        message.extra = { oneofKind: undefined };
+        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 /* pncp.v1.ConversationId id */ 1:
+                    message.id = ConversationId.internalBinaryRead(reader, reader.uint32(), options, message.id);
+                    break;
+                case /* pncp.v1.PncpMessageKind kind */ 10:
+                    message.kind = reader.int32();
+                    break;
+                case /* otonoma.common.Value body */ 11:
+                    message.body = Value.internalBinaryRead(reader, reader.uint32(), options, message.body);
+                    break;
+                case /* pncp.v1.PncpQuestionEx question */ 12:
+                    message.extra = {
+                        oneofKind: "question",
+                        question: PncpQuestionEx.internalBinaryRead(reader, reader.uint32(), options, message.extra.question)
+                    };
+                    break;
+                case /* pncp.v1.PncpAnswerEx answer */ 13:
+                    message.extra = {
+                        oneofKind: "answer",
+                        answer: PncpAnswerEx.internalBinaryRead(reader, reader.uint32(), options, message.extra.answer)
+                    };
+                    break;
+                case /* optional string taint */ 14:
+                    message.taint = 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) {
+        /* pncp.v1.ConversationId id = 1; */
+        if (message.id)
+            ConversationId.internalBinaryWrite(message.id, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* pncp.v1.PncpMessageKind kind = 10; */
+        if (message.kind !== 0)
+            writer.tag(10, WireType.Varint).int32(message.kind);
+        /* otonoma.common.Value body = 11; */
+        if (message.body)
+            Value.internalBinaryWrite(message.body, writer.tag(11, WireType.LengthDelimited).fork(), options).join();
+        /* pncp.v1.PncpQuestionEx question = 12; */
+        if (message.extra.oneofKind === "question")
+            PncpQuestionEx.internalBinaryWrite(message.extra.question, writer.tag(12, WireType.LengthDelimited).fork(), options).join();
+        /* pncp.v1.PncpAnswerEx answer = 13; */
+        if (message.extra.oneofKind === "answer")
+            PncpAnswerEx.internalBinaryWrite(message.extra.answer, writer.tag(13, WireType.LengthDelimited).fork(), options).join();
+        /* optional string taint = 14; */
+        if (message.taint !== undefined)
+            writer.tag(14, WireType.LengthDelimited).string(message.taint);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message pncp.v1.PncpMessage
+ */
+export const PncpMessage = new PncpMessage$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class PncpQuestionEx$Type extends MessageType {
+    constructor() {
+        super("pncp.v1.PncpQuestionEx", [
+            { no: 1, name: "id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "callback", kind: "message", T: () => Value }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.id = "";
+        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 id */ 1:
+                    message.id = reader.string();
+                    break;
+                case /* optional otonoma.common.Value callback */ 2:
+                    message.callback = Value.internalBinaryRead(reader, reader.uint32(), options, message.callback);
+                    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 id = 1; */
+        if (message.id !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.id);
+        /* optional otonoma.common.Value callback = 2; */
+        if (message.callback)
+            Value.internalBinaryWrite(message.callback, 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 pncp.v1.PncpQuestionEx
+ */
+export const PncpQuestionEx = new PncpQuestionEx$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class PncpAnswerEx$Type extends MessageType {
+    constructor() {
+        super("pncp.v1.PncpAnswerEx", [
+            { no: 1, name: "reply_to", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.replyTo = "";
+        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 reply_to */ 1:
+                    message.replyTo = 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 reply_to = 1; */
+        if (message.replyTo !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.replyTo);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message pncp.v1.PncpAnswerEx
+ */
+export const PncpAnswerEx = new PncpAnswerEx$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class PncpCallback$Type extends MessageType {
+    constructor() {
+        super("pncp.v1.PncpCallback", [
+            { no: 1, name: "skill", kind: "message", oneof: "body", T: () => PncpRequestCallback },
+            { no: 2, name: "message", kind: "message", oneof: "body", T: () => PncpMessageCallback }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.body = { oneofKind: undefined };
+        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 /* pncp.v1.PncpRequestCallback skill */ 1:
+                    message.body = {
+                        oneofKind: "skill",
+                        skill: PncpRequestCallback.internalBinaryRead(reader, reader.uint32(), options, message.body.skill)
+                    };
+                    break;
+                case /* pncp.v1.PncpMessageCallback message */ 2:
+                    message.body = {
+                        oneofKind: "message",
+                        message: PncpMessageCallback.internalBinaryRead(reader, reader.uint32(), options, message.body.message)
+                    };
+                    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) {
+        /* pncp.v1.PncpRequestCallback skill = 1; */
+        if (message.body.oneofKind === "skill")
+            PncpRequestCallback.internalBinaryWrite(message.body.skill, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* pncp.v1.PncpMessageCallback message = 2; */
+        if (message.body.oneofKind === "message")
+            PncpMessageCallback.internalBinaryWrite(message.body.message, 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 pncp.v1.PncpCallback
+ */
+export const PncpCallback = new PncpCallback$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class PncpRequestCallback$Type extends MessageType {
+    constructor() {
+        super("pncp.v1.PncpRequestCallback", [
+            { no: 1, name: "id", kind: "message", T: () => ConversationId },
+            { no: 2, name: "message_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "body", kind: "message", T: () => PncpSkillMessage },
+            { no: 4, name: "parent_id", kind: "message", T: () => ConversationId },
+            { no: 5, name: "time_created", kind: "message", T: () => Timestamp },
+            { no: 6, name: "author_id", kind: "message", T: () => EntityId },
+            { no: 7, name: "target_actor_id", kind: "message", T: () => EntityId },
+            { no: 8, name: "parameters", kind: "message", T: () => ParameterData },
+            { no: 9, name: "flags", kind: "scalar", T: 13 /*ScalarType.UINT32*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.messageId = "";
+        message.flags = 0;
+        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 /* pncp.v1.ConversationId id */ 1:
+                    message.id = ConversationId.internalBinaryRead(reader, reader.uint32(), options, message.id);
+                    break;
+                case /* string message_id */ 2:
+                    message.messageId = reader.string();
+                    break;
+                case /* pncp.v1.PncpSkillMessage body */ 3:
+                    message.body = PncpSkillMessage.internalBinaryRead(reader, reader.uint32(), options, message.body);
+                    break;
+                case /* optional pncp.v1.ConversationId parent_id */ 4:
+                    message.parentId = ConversationId.internalBinaryRead(reader, reader.uint32(), options, message.parentId);
+                    break;
+                case /* google.protobuf.Timestamp time_created */ 5:
+                    message.timeCreated = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.timeCreated);
+                    break;
+                case /* pncp.v1.EntityId author_id */ 6:
+                    message.authorId = EntityId.internalBinaryRead(reader, reader.uint32(), options, message.authorId);
+                    break;
+                case /* optional pncp.v1.EntityId target_actor_id */ 7:
+                    message.targetActorId = EntityId.internalBinaryRead(reader, reader.uint32(), options, message.targetActorId);
+                    break;
+                case /* pncp.v1.ParameterData parameters */ 8:
+                    message.parameters = ParameterData.internalBinaryRead(reader, reader.uint32(), options, message.parameters);
+                    break;
+                case /* uint32 flags */ 9:
+                    message.flags = reader.uint32();
+                    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) {
+        /* pncp.v1.ConversationId id = 1; */
+        if (message.id)
+            ConversationId.internalBinaryWrite(message.id, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* string message_id = 2; */
+        if (message.messageId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.messageId);
+        /* pncp.v1.PncpSkillMessage body = 3; */
+        if (message.body)
+            PncpSkillMessage.internalBinaryWrite(message.body, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* optional pncp.v1.ConversationId parent_id = 4; */
+        if (message.parentId)
+            ConversationId.internalBinaryWrite(message.parentId, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+        /* google.protobuf.Timestamp time_created = 5; */
+        if (message.timeCreated)
+            Timestamp.internalBinaryWrite(message.timeCreated, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+        /* pncp.v1.EntityId author_id = 6; */
+        if (message.authorId)
+            EntityId.internalBinaryWrite(message.authorId, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
+        /* optional pncp.v1.EntityId target_actor_id = 7; */
+        if (message.targetActorId)
+            EntityId.internalBinaryWrite(message.targetActorId, writer.tag(7, WireType.LengthDelimited).fork(), options).join();
+        /* pncp.v1.ParameterData parameters = 8; */
+        if (message.parameters)
+            ParameterData.internalBinaryWrite(message.parameters, writer.tag(8, WireType.LengthDelimited).fork(), options).join();
+        /* uint32 flags = 9; */
+        if (message.flags !== 0)
+            writer.tag(9, WireType.Varint).uint32(message.flags);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message pncp.v1.PncpRequestCallback
+ */
+export const PncpRequestCallback = new PncpRequestCallback$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class PncpMessageCallback$Type extends MessageType {
+    constructor() {
+        super("pncp.v1.PncpMessageCallback", [
+            { no: 1, name: "id", kind: "message", T: () => ConversationId },
+            { no: 2, name: "message_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "time_created", kind: "message", T: () => Timestamp },
+            { no: 4, name: "key", kind: "message", T: () => Value },
+            { no: 5, name: "message", kind: "message", T: () => PncpMessage },
+            { no: 6, name: "params", kind: "message", T: () => Value },
+            { no: 7, name: "callback", kind: "message", T: () => Value },
+            { no: 8, name: "medium", kind: "message", T: () => Value },
+            { no: 9, name: "conversation_state", kind: "enum", T: () => ["pncp.v1.ConversationState", ConversationState] }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.messageId = "";
+        message.conversationState = 0;
+        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 /* pncp.v1.ConversationId id */ 1:
+                    message.id = ConversationId.internalBinaryRead(reader, reader.uint32(), options, message.id);
+                    break;
+                case /* string message_id */ 2:
+                    message.messageId = reader.string();
+                    break;
+                case /* google.protobuf.Timestamp time_created */ 3:
+                    message.timeCreated = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.timeCreated);
+                    break;
+                case /* optional otonoma.common.Value key */ 4:
+                    message.key = Value.internalBinaryRead(reader, reader.uint32(), options, message.key);
+                    break;
+                case /* pncp.v1.PncpMessage message */ 5:
+                    message.message = PncpMessage.internalBinaryRead(reader, reader.uint32(), options, message.message);
+                    break;
+                case /* optional otonoma.common.Value params */ 6:
+                    message.params = Value.internalBinaryRead(reader, reader.uint32(), options, message.params);
+                    break;
+                case /* optional otonoma.common.Value callback */ 7:
+                    message.callback = Value.internalBinaryRead(reader, reader.uint32(), options, message.callback);
+                    break;
+                case /* optional otonoma.common.Value medium */ 8:
+                    message.medium = Value.internalBinaryRead(reader, reader.uint32(), options, message.medium);
+                    break;
+                case /* pncp.v1.ConversationState conversation_state */ 9:
+                    message.conversationState = reader.int32();
+                    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) {
+        /* pncp.v1.ConversationId id = 1; */
+        if (message.id)
+            ConversationId.internalBinaryWrite(message.id, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* string message_id = 2; */
+        if (message.messageId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.messageId);
+        /* google.protobuf.Timestamp time_created = 3; */
+        if (message.timeCreated)
+            Timestamp.internalBinaryWrite(message.timeCreated, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* optional otonoma.common.Value key = 4; */
+        if (message.key)
+            Value.internalBinaryWrite(message.key, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+        /* pncp.v1.PncpMessage message = 5; */
+        if (message.message)
+            PncpMessage.internalBinaryWrite(message.message, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+        /* optional otonoma.common.Value params = 6; */
+        if (message.params)
+            Value.internalBinaryWrite(message.params, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
+        /* optional otonoma.common.Value callback = 7; */
+        if (message.callback)
+            Value.internalBinaryWrite(message.callback, writer.tag(7, WireType.LengthDelimited).fork(), options).join();
+        /* optional otonoma.common.Value medium = 8; */
+        if (message.medium)
+            Value.internalBinaryWrite(message.medium, writer.tag(8, WireType.LengthDelimited).fork(), options).join();
+        /* pncp.v1.ConversationState conversation_state = 9; */
+        if (message.conversationState !== 0)
+            writer.tag(9, WireType.Varint).int32(message.conversationState);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message pncp.v1.PncpMessageCallback
+ */
+export const PncpMessageCallback = new PncpMessageCallback$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ParameterData$Type extends MessageType {
+    constructor() {
+        super("pncp.v1.ParameterData", [
+            { no: 1, name: "provider", kind: "message", T: () => Value },
+            { no: 2, name: "skill", kind: "message", T: () => Value },
+            { no: 3, name: "medium", kind: "message", T: () => Value }
+        ]);
+    }
+    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 /* optional otonoma.common.Value provider */ 1:
+                    message.provider = Value.internalBinaryRead(reader, reader.uint32(), options, message.provider);
+                    break;
+                case /* optional otonoma.common.Value skill */ 2:
+                    message.skill = Value.internalBinaryRead(reader, reader.uint32(), options, message.skill);
+                    break;
+                case /* optional otonoma.common.Value medium */ 3:
+                    message.medium = Value.internalBinaryRead(reader, reader.uint32(), options, message.medium);
+                    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) {
+        /* optional otonoma.common.Value provider = 1; */
+        if (message.provider)
+            Value.internalBinaryWrite(message.provider, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* optional otonoma.common.Value skill = 2; */
+        if (message.skill)
+            Value.internalBinaryWrite(message.skill, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* optional otonoma.common.Value medium = 3; */
+        if (message.medium)
+            Value.internalBinaryWrite(message.medium, writer.tag(3, 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 pncp.v1.ParameterData
+ */
+export const ParameterData = new ParameterData$Type();