@otonoma/paranet-client 2.11.0-rc.18

package/src/proto/pncp.ts

@@ -0,0 +1,1333 @@
+// @generated by protobuf-ts 2.9.4
+// @generated from protobuf file "pncp.proto" (package "pncp.v1", syntax proto3)
+// tslint:disable
+import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
+import type { IBinaryWriter } from "@protobuf-ts/runtime";
+import { WireType } from "@protobuf-ts/runtime";
+import type { BinaryReadOptions } from "@protobuf-ts/runtime";
+import type { IBinaryReader } from "@protobuf-ts/runtime";
+import { UnknownFieldHandler } from "@protobuf-ts/runtime";
+import type { PartialMessage } 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";
+/**
+ * A core packet comprised of either a request or a message. Some APIs make use of this wrapped type
+ * instead of providing specific APIs for either request or messages.
+ *
+ * @generated from protobuf message pncp.v1.PncpPacket
+ */
+export interface PncpPacket {
+    /**
+     * @generated from protobuf oneof: body
+     */
+    body: {
+        oneofKind: "request";
+        /**
+         * @generated from protobuf field: pncp.v1.PncpRequest request = 1;
+         */
+        request: PncpRequest;
+    } | {
+        oneofKind: "message";
+        /**
+         * @generated from protobuf field: pncp.v1.PncpMessage message = 2;
+         */
+        message: PncpMessage;
+    } | {
+        oneofKind: undefined;
+    };
+}
+/**
+ * A PNCP request begins a conversation between two actors.
+ *
+ * @generated from protobuf message pncp.v1.PncpRequest
+ */
+export interface PncpRequest {
+    /**
+     * The core body to the request.
+     *
+     * @generated from protobuf field: pncp.v1.PncpSkillMessage body = 1;
+     */
+    body?: PncpSkillMessage;
+    /**
+     * Callback information provided on subsequent PNCP responses.
+     * This is mostly used to associate a request with a response on the actor side.
+     *
+     * @generated from protobuf field: optional otonoma.common.Value callback = 2;
+     */
+    callback?: Value;
+    /**
+     * Parent conversation ID, if this request is a sub request. If this is a new request this field
+     * must be left blank.
+     *
+     * @generated from protobuf field: optional pncp.v1.ConversationId parent_id = 3;
+     */
+    parentId?: ConversationId;
+    /**
+     * Identity of the base actor is determined through the provided authentication token on the request.
+     * However, paraflow actors are able to run multiple versions of an actor at once and they will be
+     * marshalled through the same connection and authentication. As such, we need the actor to provide
+     * the author information in such cases.
+     *
+     * @generated from protobuf field: optional pncp.v1.EntityId author = 4;
+     */
+    author?: EntityId;
+    /**
+     * @generated from protobuf field: pncp.v1.SkillMatchStrategy match_strategy = 5;
+     */
+    matchStrategy: SkillMatchStrategy;
+    /**
+     * version request spec for the (subject, action) pair. If not provided, the default (typically latest)
+     * is used instead.
+     *
+     * @generated from protobuf field: optional string version_req = 6;
+     */
+    versionReq?: string;
+    /**
+     * Optionally specify the exact actor that should match.
+     *
+     * @generated from protobuf field: optional string target_actor_id = 7;
+     */
+    targetActorId?: string;
+    /**
+     * TODO: We might not need these fields anymore. We will see.
+     *
+     * @generated from protobuf field: optional otonoma.common.Value key = 8;
+     */
+    key?: Value;
+    /**
+     * @generated from protobuf field: optional pncp.v1.PncpRequestMediumInfo medium_info = 9;
+     */
+    mediumInfo?: PncpRequestMediumInfo;
+    /**
+     * If this is true, a match is required to be made upon the initial request. If it is false, the
+     * broker can store the message and conversation in an unmatched state and rematch it at a later
+     * time based on later actor availability.
+     * If the corresponding skill is a `Broadcast` skill, this field is not considered as they are
+     * not matched.
+     *
+     * @generated from protobuf field: bool must_match = 10;
+     */
+    mustMatch: boolean;
+    /**
+     * Specifies whether this request should use the provided actor lock or not.
+     *
+     * @generated from protobuf field: bool use_lock = 11;
+     */
+    useLock: boolean;
+    /**
+     * If this is true, then the request can use open networking and search other open nodes on the
+     * network for a fulfiller if this node doesn't know of a fulfiller.
+     *
+     * @generated from protobuf field: bool allow_open_match = 12;
+     */
+    allowOpenMatch: boolean;
+}
+/**
+ * @generated from protobuf message pncp.v1.PncpRequestMediumInfo
+ */
+export interface PncpRequestMediumInfo {
+    /**
+     * ID of the medium that made the request.
+     *
+     * @generated from protobuf field: pncp.v1.EntityId id = 1;
+     */
+    id?: EntityId;
+    /**
+     * Unique information identifying the user from the medium.
+     *
+     * @generated from protobuf field: optional otonoma.common.Value user_info = 2;
+     */
+    userInfo?: Value;
+}
+/**
+ * Represents a skill request message. This message is the core "body" of a `PncpRequest`.
+ *
+ * @generated from protobuf message pncp.v1.PncpSkillMessage
+ */
+export interface PncpSkillMessage {
+    /**
+     * Subject of the request.
+     *
+     * @generated from protobuf field: string subject = 1;
+     */
+    subject: string;
+    /**
+     * Action associated with the request.
+     *
+     * @generated from protobuf field: string action = 2;
+     */
+    action: string;
+    /**
+     * The request data.
+     *
+     * @generated from protobuf field: otonoma.common.Value body = 5;
+     */
+    body?: Value;
+    /**
+     * Taint data labels
+     *
+     * @generated from protobuf field: optional string taint = 6;
+     */
+    taint?: string;
+}
+/**
+ * A PNCP Message is a message internal to a conversation. Notably, this does not include requests, which
+ * begin a conversation automatically per their request.
+ *
+ * @generated from protobuf message pncp.v1.PncpMessage
+ */
+export interface PncpMessage {
+    /**
+     * The ID associated with this message.
+     *
+     * @generated from protobuf field: pncp.v1.ConversationId id = 1;
+     */
+    id?: ConversationId;
+    /**
+     * The kind of message. Certain other fields are only optionally present depending on the value
+     * of this field.
+     *
+     * @generated from protobuf field: pncp.v1.PncpMessageKind kind = 10;
+     */
+    kind: PncpMessageKind;
+    /**
+     * The core data of the message.
+     *
+     * @generated from protobuf field: otonoma.common.Value body = 11;
+     */
+    body?: Value;
+    /**
+     * @generated from protobuf oneof: extra
+     */
+    extra: {
+        oneofKind: "question";
+        /**
+         * @generated from protobuf field: pncp.v1.PncpQuestionEx question = 12;
+         */
+        question: PncpQuestionEx;
+    } | {
+        oneofKind: "answer";
+        /**
+         * @generated from protobuf field: pncp.v1.PncpAnswerEx answer = 13;
+         */
+        answer: PncpAnswerEx;
+    } | {
+        oneofKind: undefined;
+    };
+    /**
+     * Taint data labels
+     *
+     * @generated from protobuf field: optional string taint = 14;
+     */
+    taint?: string;
+}
+/**
+ * @generated from protobuf message pncp.v1.PncpQuestionEx
+ */
+export interface PncpQuestionEx {
+    /**
+     * ID of the question.
+     *
+     * @generated from protobuf field: string id = 1;
+     */
+    id: string;
+    /**
+     * @generated from protobuf field: optional otonoma.common.Value callback = 2;
+     */
+    callback?: Value;
+}
+/**
+ * @generated from protobuf message pncp.v1.PncpAnswerEx
+ */
+export interface PncpAnswerEx {
+    /**
+     * Message ID of the question being replied to.
+     *
+     * @generated from protobuf field: string reply_to = 1;
+     */
+    replyTo: string;
+}
+/**
+ * Response on the callback is a stream of these messages.
+ * The message format is a bit cumbersome as we are required to have one stream of messages.
+ *
+ * @generated from protobuf message pncp.v1.PncpCallback
+ */
+export interface PncpCallback {
+    /**
+     * @generated from protobuf oneof: body
+     */
+    body: {
+        oneofKind: "skill";
+        /**
+         * @generated from protobuf field: pncp.v1.PncpRequestCallback skill = 1;
+         */
+        skill: PncpRequestCallback;
+    } | {
+        oneofKind: "message";
+        /**
+         * @generated from protobuf field: pncp.v1.PncpMessageCallback message = 2;
+         */
+        message: PncpMessageCallback;
+    } | {
+        oneofKind: undefined;
+    };
+}
+/**
+ * PncpRequestCallback is how skill requests are sent to actors for fulfillment.
+ *
+ * @generated from protobuf message pncp.v1.PncpRequestCallback
+ */
+export interface PncpRequestCallback {
+    /**
+     * @generated from protobuf field: pncp.v1.ConversationId id = 1;
+     */
+    id?: ConversationId;
+    /**
+     * @generated from protobuf field: string message_id = 2;
+     */
+    messageId: string;
+    /**
+     * The core PNCP request body.
+     *
+     * @generated from protobuf field: pncp.v1.PncpSkillMessage body = 3;
+     */
+    body?: PncpSkillMessage;
+    /**
+     * Parent ID of the conversation that triggered this one, if one exists.
+     *
+     * @generated from protobuf field: optional pncp.v1.ConversationId parent_id = 4;
+     */
+    parentId?: ConversationId;
+    /**
+     * Time the conversation was created.
+     *
+     * @generated from protobuf field: google.protobuf.Timestamp time_created = 5;
+     */
+    timeCreated?: Timestamp;
+    /**
+     * Author of the request.
+     *
+     * @generated from protobuf field: pncp.v1.EntityId author_id = 6;
+     */
+    authorId?: EntityId;
+    /**
+     * The actor ID of the receiving actor. This is the reflection of the PncpRequest author field.
+     * See notes on PncpRequest.author for why this is necessary.
+     *
+     * @generated from protobuf field: optional pncp.v1.EntityId target_actor_id = 7;
+     */
+    targetActorId?: EntityId;
+    /**
+     * Parameter data. These fields are actor or skill specific metadata populated dynamically
+     * by the broker.
+     *
+     * @generated from protobuf field: pncp.v1.ParameterData parameters = 8;
+     */
+    parameters?: ParameterData;
+    /**
+     * @generated from protobuf field: uint32 flags = 9;
+     */
+    flags: number;
+}
+/**
+ * Context flags (default 0)
+ *
+ * @generated from protobuf enum pncp.v1.PncpRequestCallback.CallbackFlags
+ */
+export enum PncpRequestCallback_CallbackFlags {
+    /**
+     * @generated from protobuf enum value: FLAG_NONE = 0;
+     */
+    FLAG_NONE = 0,
+    /**
+     * privileged actor request
+     *
+     * @generated from protobuf enum value: FLAG_PRIVILEGED = 1;
+     */
+    FLAG_PRIVILEGED = 1
+}
+/**
+ * A message callback is a callback containing a message sent to an actor.
+ * This is how PncpMessages are routed to an actor.
+ *
+ * @generated from protobuf message pncp.v1.PncpMessageCallback
+ */
+export interface PncpMessageCallback {
+    /**
+     * @generated from protobuf field: pncp.v1.ConversationId id = 1;
+     */
+    id?: ConversationId;
+    /**
+     * @generated from protobuf field: string message_id = 2;
+     */
+    messageId: string;
+    /**
+     * @generated from protobuf field: google.protobuf.Timestamp time_created = 3;
+     */
+    timeCreated?: Timestamp;
+    /**
+     * Returned key from initial request.
+     *
+     * @generated from protobuf field: optional otonoma.common.Value key = 4;
+     */
+    key?: Value;
+    /**
+     * The core body of the message.
+     *
+     * @generated from protobuf field: pncp.v1.PncpMessage message = 5;
+     */
+    message?: PncpMessage;
+    /**
+     * Certain message types (notably: Question) can provide params.
+     *
+     * @generated from protobuf field: optional otonoma.common.Value params = 6;
+     */
+    params?: Value;
+    /**
+     * Callback provided on the initial message.
+     *
+     * @generated from protobuf field: optional otonoma.common.Value callback = 7;
+     */
+    callback?: Value;
+    /**
+     * TODO: Do we need this?
+     *
+     * @generated from protobuf field: optional otonoma.common.Value medium = 8;
+     */
+    medium?: Value;
+    /**
+     * @generated from protobuf field: pncp.v1.ConversationState conversation_state = 9;
+     */
+    conversationState: ConversationState;
+}
+/**
+ * @generated from protobuf message pncp.v1.ParameterData
+ */
+export interface ParameterData {
+    /**
+     * @generated from protobuf field: optional otonoma.common.Value provider = 1;
+     */
+    provider?: Value;
+    /**
+     * @generated from protobuf field: optional otonoma.common.Value skill = 2;
+     */
+    skill?: Value;
+    /**
+     * @generated from protobuf field: optional otonoma.common.Value medium = 3;
+     */
+    medium?: Value;
+}
+/**
+ * Match strategy. Defaults to `BEST`.
+ *
+ * @generated from protobuf enum pncp.v1.SkillMatchStrategy
+ */
+export enum SkillMatchStrategy {
+    /**
+     * @generated from protobuf enum value: BEST = 0;
+     */
+    BEST = 0,
+    /**
+     * @generated from protobuf enum value: FIRST = 1;
+     */
+    FIRST = 1,
+    /**
+     * @generated from protobuf enum value: STRICT = 2;
+     */
+    STRICT = 2
+}
+// 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 enum PncpMessageKind {
+    /**
+     * @generated from protobuf enum value: PNCP_RESPONSE = 0;
+     */
+    PNCP_RESPONSE = 0,
+    /**
+     * @generated from protobuf enum value: PNCP_STATUS = 1;
+     */
+    PNCP_STATUS = 1,
+    /**
+     * @generated from protobuf enum value: PNCP_CANCEL = 2;
+     */
+    PNCP_CANCEL = 2,
+    /**
+     * @generated from protobuf enum value: PNCP_ERROR = 3;
+     */
+    PNCP_ERROR = 3,
+    /**
+     * @generated from protobuf enum value: PNCP_QUESTION = 4;
+     */
+    PNCP_QUESTION = 4,
+    /**
+     * @generated from protobuf enum value: PNCP_ANSWER = 5;
+     */
+    PNCP_ANSWER = 5
+}
+// These messages represent messages sent back to the actor from the broker.
+
+/**
+ * @generated from protobuf enum pncp.v1.ConversationState
+ */
+export enum ConversationState {
+    /**
+     * @generated from protobuf enum value: STATE_IN_PROGRESS = 0;
+     */
+    STATE_IN_PROGRESS = 0,
+    /**
+     * @generated from protobuf enum value: STATE_COMPLETED = 1;
+     */
+    STATE_COMPLETED = 1,
+    /**
+     * @generated from protobuf enum value: STATE_ERRORED = 2;
+     */
+    STATE_ERRORED = 2,
+    /**
+     * @generated from protobuf enum value: STATE_CANCELED = 3;
+     */
+    STATE_CANCELED = 3,
+    /**
+     * @generated from protobuf enum value: STATE_UNMATCHED = 4;
+     */
+    STATE_UNMATCHED = 4,
+    /**
+     * @generated from protobuf enum value: STATE_NETWORKING = 5;
+     */
+    STATE_NETWORKING = 5
+}
+// @generated message type with reflection information, may provide speed optimized methods
+class PncpPacket$Type extends MessageType<PncpPacket> {
+    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?: PartialMessage<PncpPacket>): PncpPacket {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.body = { oneofKind: undefined };
+        if (value !== undefined)
+            reflectionMergePartial<PncpPacket>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: PncpPacket): PncpPacket {
+        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 as any).request)
+                    };
+                    break;
+                case /* pncp.v1.PncpMessage message */ 2:
+                    message.body = {
+                        oneofKind: "message",
+                        message: PncpMessage.internalBinaryRead(reader, reader.uint32(), options, (message.body as any).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: PncpPacket, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* 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<PncpRequest> {
+    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?: PartialMessage<PncpRequest>): PncpRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.matchStrategy = 0;
+        message.mustMatch = false;
+        message.useLock = false;
+        message.allowOpenMatch = false;
+        if (value !== undefined)
+            reflectionMergePartial<PncpRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: PncpRequest): PncpRequest {
+        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: PncpRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* 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<PncpRequestMediumInfo> {
+    constructor() {
+        super("pncp.v1.PncpRequestMediumInfo", [
+            { no: 1, name: "id", kind: "message", T: () => EntityId },
+            { no: 2, name: "user_info", kind: "message", T: () => Value }
+        ]);
+    }
+    create(value?: PartialMessage<PncpRequestMediumInfo>): PncpRequestMediumInfo {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<PncpRequestMediumInfo>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: PncpRequestMediumInfo): PncpRequestMediumInfo {
+        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: PncpRequestMediumInfo, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* 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<PncpSkillMessage> {
+    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?: PartialMessage<PncpSkillMessage>): PncpSkillMessage {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.subject = "";
+        message.action = "";
+        if (value !== undefined)
+            reflectionMergePartial<PncpSkillMessage>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: PncpSkillMessage): PncpSkillMessage {
+        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: PncpSkillMessage, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* 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<PncpMessage> {
+    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?: PartialMessage<PncpMessage>): PncpMessage {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.kind = 0;
+        message.extra = { oneofKind: undefined };
+        if (value !== undefined)
+            reflectionMergePartial<PncpMessage>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: PncpMessage): PncpMessage {
+        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 as any).question)
+                    };
+                    break;
+                case /* pncp.v1.PncpAnswerEx answer */ 13:
+                    message.extra = {
+                        oneofKind: "answer",
+                        answer: PncpAnswerEx.internalBinaryRead(reader, reader.uint32(), options, (message.extra as any).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: PncpMessage, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* 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<PncpQuestionEx> {
+    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?: PartialMessage<PncpQuestionEx>): PncpQuestionEx {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.id = "";
+        if (value !== undefined)
+            reflectionMergePartial<PncpQuestionEx>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: PncpQuestionEx): PncpQuestionEx {
+        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: PncpQuestionEx, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* 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<PncpAnswerEx> {
+    constructor() {
+        super("pncp.v1.PncpAnswerEx", [
+            { no: 1, name: "reply_to", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<PncpAnswerEx>): PncpAnswerEx {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.replyTo = "";
+        if (value !== undefined)
+            reflectionMergePartial<PncpAnswerEx>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: PncpAnswerEx): PncpAnswerEx {
+        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: PncpAnswerEx, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* 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<PncpCallback> {
+    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?: PartialMessage<PncpCallback>): PncpCallback {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.body = { oneofKind: undefined };
+        if (value !== undefined)
+            reflectionMergePartial<PncpCallback>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: PncpCallback): PncpCallback {
+        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 as any).skill)
+                    };
+                    break;
+                case /* pncp.v1.PncpMessageCallback message */ 2:
+                    message.body = {
+                        oneofKind: "message",
+                        message: PncpMessageCallback.internalBinaryRead(reader, reader.uint32(), options, (message.body as any).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: PncpCallback, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* 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<PncpRequestCallback> {
+    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?: PartialMessage<PncpRequestCallback>): PncpRequestCallback {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.messageId = "";
+        message.flags = 0;
+        if (value !== undefined)
+            reflectionMergePartial<PncpRequestCallback>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: PncpRequestCallback): PncpRequestCallback {
+        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: PncpRequestCallback, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* 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<PncpMessageCallback> {
+    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?: PartialMessage<PncpMessageCallback>): PncpMessageCallback {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.messageId = "";
+        message.conversationState = 0;
+        if (value !== undefined)
+            reflectionMergePartial<PncpMessageCallback>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: PncpMessageCallback): PncpMessageCallback {
+        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: PncpMessageCallback, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* 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<ParameterData> {
+    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?: PartialMessage<ParameterData>): ParameterData {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<ParameterData>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ParameterData): ParameterData {
+        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: ParameterData, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* 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();