@otonoma/paranet-client 2.11.0-rc.18

package/dist/proto/broker_api.js

@@ -0,0 +1,566 @@
+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 { PncpPacket } from "./pncp";
+import { EntityId } from "./identifiers";
+import { ConversationState } from "./pncp";
+import { Timestamp } from "./google/protobuf/timestamp";
+import { ConversationId } from "./identifiers";
+/**
+ * @generated from protobuf enum pncp.v1.ResponseKind
+ */
+export var ResponseKind;
+(function (ResponseKind) {
+    /**
+     * @generated from protobuf enum value: MATCH = 0;
+     */
+    ResponseKind[ResponseKind["MATCH"] = 0] = "MATCH";
+    /**
+     * @generated from protobuf enum value: BROADCAST = 1;
+     */
+    ResponseKind[ResponseKind["BROADCAST"] = 1] = "BROADCAST";
+    /**
+     * @generated from protobuf enum value: DATA = 2;
+     */
+    ResponseKind[ResponseKind["DATA"] = 2] = "DATA";
+    /**
+     * @generated from protobuf enum value: UNMATCHED = 3;
+     */
+    ResponseKind[ResponseKind["UNMATCHED"] = 3] = "UNMATCHED";
+    /**
+     * @generated from protobuf enum value: NETWORKED = 4;
+     */
+    ResponseKind[ResponseKind["NETWORKED"] = 4] = "NETWORKED";
+})(ResponseKind || (ResponseKind = {}));
+// @generated message type with reflection information, may provide speed optimized methods
+class MessageResponse$Type extends MessageType {
+    constructor() {
+        super("pncp.v1.MessageResponse", [
+            { 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: "state", kind: "enum", T: () => ["pncp.v1.ConversationState", ConversationState] },
+            { no: 5, name: "kind", kind: "enum", T: () => ["pncp.v1.ResponseKind", ResponseKind] },
+            { no: 6, name: "matched_id", kind: "message", T: () => EntityId }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.messageId = "";
+        message.state = 0;
+        message.kind = 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 /* pncp.v1.ConversationState state */ 4:
+                    message.state = reader.int32();
+                    break;
+                case /* pncp.v1.ResponseKind kind */ 5:
+                    message.kind = reader.int32();
+                    break;
+                case /* optional pncp.v1.EntityId matched_id */ 6:
+                    message.matchedId = EntityId.internalBinaryRead(reader, reader.uint32(), options, message.matchedId);
+                    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();
+        /* pncp.v1.ConversationState state = 4; */
+        if (message.state !== 0)
+            writer.tag(4, WireType.Varint).int32(message.state);
+        /* pncp.v1.ResponseKind kind = 5; */
+        if (message.kind !== 0)
+            writer.tag(5, WireType.Varint).int32(message.kind);
+        /* optional pncp.v1.EntityId matched_id = 6; */
+        if (message.matchedId)
+            EntityId.internalBinaryWrite(message.matchedId, writer.tag(6, 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.MessageResponse
+ */
+export const MessageResponse = new MessageResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class PncpCallbackRequest$Type extends MessageType {
+    constructor() {
+        super("pncp.v1.PncpCallbackRequest", [
+            { no: 1, name: "disable_skill_forwarding", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.disableSkillForwarding = false;
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* bool disable_skill_forwarding */ 1:
+                    message.disableSkillForwarding = reader.bool();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* bool disable_skill_forwarding = 1; */
+        if (message.disableSkillForwarding !== false)
+            writer.tag(1, WireType.Varint).bool(message.disableSkillForwarding);
+        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.PncpCallbackRequest
+ */
+export const PncpCallbackRequest = new PncpCallbackRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class LoginRequest$Type extends MessageType {
+    constructor() {
+        super("pncp.v1.LoginRequest", [
+            { no: 1, name: "actor_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "password", kind: "scalar", oneof: "secret", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "token", kind: "scalar", oneof: "secret", T: 9 /*ScalarType.STRING*/ },
+            { no: 4, name: "jwt", kind: "scalar", oneof: "secret", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.actorId = "";
+        message.secret = { 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 /* string actor_id */ 1:
+                    message.actorId = reader.string();
+                    break;
+                case /* string password */ 2:
+                    message.secret = {
+                        oneofKind: "password",
+                        password: reader.string()
+                    };
+                    break;
+                case /* string token */ 3:
+                    message.secret = {
+                        oneofKind: "token",
+                        token: reader.string()
+                    };
+                    break;
+                case /* string jwt */ 4:
+                    message.secret = {
+                        oneofKind: "jwt",
+                        jwt: 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 actor_id = 1; */
+        if (message.actorId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.actorId);
+        /* string password = 2; */
+        if (message.secret.oneofKind === "password")
+            writer.tag(2, WireType.LengthDelimited).string(message.secret.password);
+        /* string token = 3; */
+        if (message.secret.oneofKind === "token")
+            writer.tag(3, WireType.LengthDelimited).string(message.secret.token);
+        /* string jwt = 4; */
+        if (message.secret.oneofKind === "jwt")
+            writer.tag(4, WireType.LengthDelimited).string(message.secret.jwt);
+        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.LoginRequest
+ */
+export const LoginRequest = new LoginRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class RefreshTokenRequest$Type extends MessageType {
+    constructor() {
+        super("pncp.v1.RefreshTokenRequest", [
+            { no: 1, name: "token", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "refresh_token", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.token = "";
+        message.refreshToken = "";
+        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 token */ 1:
+                    message.token = reader.string();
+                    break;
+                case /* string refresh_token */ 2:
+                    message.refreshToken = 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 token = 1; */
+        if (message.token !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.token);
+        /* string refresh_token = 2; */
+        if (message.refreshToken !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.refreshToken);
+        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.RefreshTokenRequest
+ */
+export const RefreshTokenRequest = new RefreshTokenRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class LoginResponse$Type extends MessageType {
+    constructor() {
+        super("pncp.v1.LoginResponse", [
+            { no: 1, name: "token", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "refresh_token", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.token = "";
+        message.refreshToken = "";
+        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 token */ 1:
+                    message.token = reader.string();
+                    break;
+                case /* string refresh_token */ 2:
+                    message.refreshToken = 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 token = 1; */
+        if (message.token !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.token);
+        /* string refresh_token = 2; */
+        if (message.refreshToken !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.refreshToken);
+        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.LoginResponse
+ */
+export const LoginResponse = new LoginResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class CrossDomainMessage$Type extends MessageType {
+    constructor() {
+        super("pncp.v1.CrossDomainMessage", [
+            { no: 1, name: "id", kind: "message", T: () => ConversationId },
+            { no: 2, name: "author", kind: "message", T: () => EntityId },
+            { no: 3, name: "body", kind: "message", T: () => PncpPacket }
+        ]);
+    }
+    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.ConversationId id */ 1:
+                    message.id = ConversationId.internalBinaryRead(reader, reader.uint32(), options, message.id);
+                    break;
+                case /* pncp.v1.EntityId author */ 2:
+                    message.author = EntityId.internalBinaryRead(reader, reader.uint32(), options, message.author);
+                    break;
+                case /* pncp.v1.PncpPacket body */ 3:
+                    message.body = PncpPacket.internalBinaryRead(reader, reader.uint32(), options, message.body);
+                    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.EntityId author = 2; */
+        if (message.author)
+            EntityId.internalBinaryWrite(message.author, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* pncp.v1.PncpPacket body = 3; */
+        if (message.body)
+            PncpPacket.internalBinaryWrite(message.body, 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.CrossDomainMessage
+ */
+export const CrossDomainMessage = new CrossDomainMessage$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class CrossDomainResponse$Type extends MessageType {
+    constructor() {
+        super("pncp.v1.CrossDomainResponse", [
+            { no: 1, name: "id", kind: "message", T: () => ConversationId },
+            { no: 2, name: "response", kind: "message", oneof: "body", T: () => MessageResponse },
+            { no: 3, name: "error", kind: "scalar", oneof: "body", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    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.ConversationId id */ 1:
+                    message.id = ConversationId.internalBinaryRead(reader, reader.uint32(), options, message.id);
+                    break;
+                case /* pncp.v1.MessageResponse response */ 2:
+                    message.body = {
+                        oneofKind: "response",
+                        response: MessageResponse.internalBinaryRead(reader, reader.uint32(), options, message.body.response)
+                    };
+                    break;
+                case /* string error */ 3:
+                    message.body = {
+                        oneofKind: "error",
+                        error: 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.MessageResponse response = 2; */
+        if (message.body.oneofKind === "response")
+            MessageResponse.internalBinaryWrite(message.body.response, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* string error = 3; */
+        if (message.body.oneofKind === "error")
+            writer.tag(3, WireType.LengthDelimited).string(message.body.error);
+        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.CrossDomainResponse
+ */
+export const CrossDomainResponse = new CrossDomainResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class CrossDomainStreamMessage$Type extends MessageType {
+    constructor() {
+        super("pncp.v1.CrossDomainStreamMessage", [
+            { no: 1, name: "msg", kind: "message", oneof: "body", T: () => CrossDomainMessage },
+            { no: 2, name: "federation_sync", kind: "message", oneof: "body", T: () => CrossDomainFederationSync }
+        ]);
+    }
+    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.CrossDomainMessage msg */ 1:
+                    message.body = {
+                        oneofKind: "msg",
+                        msg: CrossDomainMessage.internalBinaryRead(reader, reader.uint32(), options, message.body.msg)
+                    };
+                    break;
+                case /* pncp.v1.CrossDomainFederationSync federation_sync */ 2:
+                    message.body = {
+                        oneofKind: "federationSync",
+                        federationSync: CrossDomainFederationSync.internalBinaryRead(reader, reader.uint32(), options, message.body.federationSync)
+                    };
+                    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.CrossDomainMessage msg = 1; */
+        if (message.body.oneofKind === "msg")
+            CrossDomainMessage.internalBinaryWrite(message.body.msg, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* pncp.v1.CrossDomainFederationSync federation_sync = 2; */
+        if (message.body.oneofKind === "federationSync")
+            CrossDomainFederationSync.internalBinaryWrite(message.body.federationSync, 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.CrossDomainStreamMessage
+ */
+export const CrossDomainStreamMessage = new CrossDomainStreamMessage$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class CrossDomainFederationSync$Type extends MessageType {
+    constructor() {
+        super("pncp.v1.CrossDomainFederationSync", []);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        return target ?? this.create();
+    }
+    internalBinaryWrite(message, writer, options) {
+        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.CrossDomainFederationSync
+ */
+export const CrossDomainFederationSync = new CrossDomainFederationSync$Type();