@otonoma/paranet-client 2.11.0-rc.18

package/src/graphql.ts

@@ -0,0 +1,103 @@
+import { PncpMessageBody, PncpMessageObject, PncpRequestObject, PncpPacketObject } from "./pncp";
+import * as schema from "./schema/paranet";
+import * as proto from "./proto/pncp";
+import { ConversationId, ConversationMembership } from "./proto/identifiers";
+
+export function gqlSimplifyPncpPacket(req: schema.PncpPacket): PncpPacketObject {
+  switch (req.type) {
+    case "request": return { type: "request", body: gqlSimplifyPncpRequest(req.body) };
+    case "message": return { type: "message", body: gqlSimplifyPncpMessage(req.body) };
+  }
+}
+
+// Provide conversions from graphql returned objects into the equivalent pncp objects.
+export function gqlSimplifyPncpRequest(req: schema.PncpRequest): PncpRequestObject {
+  return {
+    body: {
+      subject: req.body.subject,
+      action: req.body.action,
+      body: req.body.body,
+    },
+    key: req.key,
+    author: req.author,
+    callback: req.callback,
+    parentId: req.parentId ? req.parentId : undefined,
+    mediumInfo: req.mediumInfo ? { id: req.mediumInfo.id, userInfo: req.mediumInfo.userInfo } : undefined,
+    versionReq: req.versionReq ? req.versionReq : undefined,
+    matchStrategy: req.matchStrategy ? simplifyMatchStrategy(req.matchStrategy) : proto.SkillMatchStrategy.BEST,
+  };
+}
+
+function simplifyMatchStrategy(matchStrategy: schema.SkillMatchStrategy): proto.SkillMatchStrategy {
+  switch (matchStrategy) {
+    case "BEST": return proto.SkillMatchStrategy.BEST;
+    case "FIRST": return proto.SkillMatchStrategy.FIRST;
+    case "STRICT": return proto.SkillMatchStrategy.STRICT;
+  }
+}
+
+export function gqlSimplifyPncpMessage(req: schema.PncpMessage): PncpMessageObject {
+  let body: PncpMessageBody;
+  let b = req.message.body;
+  switch (req.message.type) {
+    case "response": body = { type: proto.PncpMessageKind.PNCP_RESPONSE, value: { data: b.data } }; break;
+    case "error": body = { type: proto.PncpMessageKind.PNCP_ERROR, value: { data: b.data } }; break;
+    case "status": body = { type: proto.PncpMessageKind.PNCP_STATUS, value: { data: b.data } }; break;
+    case "cancel": body = { type: proto.PncpMessageKind.PNCP_CANCEL, value: { data: b.data } }; break;
+    case "answer": body = { type: proto.PncpMessageKind.PNCP_ANSWER, value: { data: b.data, reply_to: b.replyTo } }; break;
+    case "question": body = { type: proto.PncpMessageKind.PNCP_QUESTION, value: { data: b.data, id: b.id, callback: b.callback } }; break;
+  }
+  return {
+    id: splitConversationId(req.id),
+    body,
+  };
+}
+
+export function splitConversationId(convId: string): ConversationId {
+  let [id, tag] = convId.split('@');
+  let membership: ConversationMembership = ConversationMembership.REQUESTER;
+  switch (tag) {
+    case "requester": membership = ConversationMembership.REQUESTER; break;
+    case "fulfiller": membership = ConversationMembership.FULFILLER; break;
+    case "observer": membership = ConversationMembership.OBSERVER; break;
+    default: throw new Error("Unexpected conversation tag: " + tag);
+  }
+
+  return { id, membership };
+}
+/*
+// Simple constructors for a graphql client to the service to auto manage login and such.
+
+// import { HttpLink, ApolloLink, ApolloClient, gql } from "@apollo/client";
+// import { setContext } from "@apollo/client/link/context";
+// import { PncpClient } from "./client";
+
+// Creates an `ApolloLink` which can connect to the paranet with appropriate authentication.
+// export function createParanetApolloLink(cl: PncpClient): ApolloLink {
+//   const paranetServiceLink = new HttpLink({
+//     uri: `${cl.serviceEndpoint()}/graphql`,
+//   });
+// 
+//   const authLink = setContext(async (_, { headers }) => {
+//     if (!cl.hasTokens()) {
+//       return {
+//         headers,
+//       };
+//     }
+//     if (!cl.isTokenValid()) {
+//       console.log("GQL LINK: ATTEMPTING TOKEN REFRESH");
+//       await cl.refreshAuth();
+//     }
+//     let { token } = cl.getTokens();
+//     return {
+//       headers: {
+//         ...headers,
+//         Authorization: token ? `Bearer ${token}` : "",
+//       },
+//     };
+//   });
+// 
+//   return authLink.concat(paranetServiceLink);
+// }
+
+*/

package/src/index.ts

@@ -0,0 +1,14 @@
+export * from "./client";
+export * from "./graphql";
+
+export * from './proto/pncp';
+export * from './proto/otonoma/common/value';
+export * from './proto/google/protobuf/timestamp';
+export * from './proto/identifiers';
+export * from './proto/mediums';
+export * from './proto/broker_api';
+export * from './proto/observation';
+
+export * from './util';
+
+export * from './pncp';

package/src/pncp.ts

@@ -0,0 +1,236 @@
+import { Timestamp } from "./proto/google/protobuf/timestamp";
+import { Value } from "./proto/otonoma/common/value";
+import { ConversationId, EntityId } from "./proto/identifiers";
+import { ObservationCallback } from "./proto/observation";
+import { ConversationState, PncpCallback, PncpMessage, PncpMessageCallback, PncpMessageKind, PncpRequestCallback, SkillMatchStrategy } from "./proto/pncp";
+
+// Type exports for working with PNCP request data in more typescript/javascript friendly ways.
+export interface SkillRequest {
+  actorVersion?: string;
+  subject: string;
+  action: string;
+  body: any;
+  versionReq?: string;
+  callback?: any;
+  parentConversationId?: ConversationId;
+  targetId?: string;
+  matchStrategy?: SkillMatchStrategy;
+  mustMatch?: boolean;
+  useLock?: boolean;
+  allowOpenMatch?: boolean;
+}
+
+// Useful for reading data out of the ledger.
+export type PncpPacketObject = {
+  type: "request",
+  body: PncpRequestObject,
+} | {
+  type: "message",
+  body: PncpMessageObject,
+};
+
+export type PncpRequestObject = {
+  body: PncpSkillMessageObject;
+  callback?: any;
+  parentId?: string;
+  author: string;
+  matchStrategy: SkillMatchStrategy;
+  versionReq?: string;
+  targetActorId?: string;
+  key?: any;
+  targetInstanceId?: string;
+  mediumInfo?: PncpRequestMediumInfoObject;
+};
+
+export type PncpRequestMediumInfoObject = {
+  id: string;
+  userInfo: any;
+};
+
+export type PncpSkillMessageObject = {
+  subject: string;
+  action: string;
+  body: any;
+};
+
+export interface MessageRequest {
+  conversation: string;
+  message: PncpMessageBody;
+}
+
+export interface PncpDataMessage {
+  data: any;
+}
+
+export interface PncpQuestionMessage {
+  id: string;
+  data: any;
+  callback?: any;
+}
+
+export interface PncpAnswerMessage {
+  reply_to: string;
+  data: any;
+}
+
+export type PncpMessageBody =
+  | { type: typeof PncpMessageKind.PNCP_RESPONSE; value: PncpDataMessage }
+  | { type: typeof PncpMessageKind.PNCP_STATUS; value: PncpDataMessage }
+  | { type: typeof PncpMessageKind.PNCP_CANCEL; value: PncpDataMessage }
+  | { type: typeof PncpMessageKind.PNCP_ERROR; value: PncpDataMessage }
+  | { type: typeof PncpMessageKind.PNCP_QUESTION; value: PncpQuestionMessage }
+  | { type: typeof PncpMessageKind.PNCP_ANSWER; value: PncpAnswerMessage };
+
+
+export type PncpCallbackObject = PncpRequestCallbackObject | PncpMessageCallbackObject;
+
+export type PncpRequestCallbackObject = {
+  type: "skill";
+  id: ConversationId;
+  messageId: string;
+  parentId?: ConversationId;
+  body: PncpSkillMessageObject;
+  timeCreated: Date;
+  authorId: EntityId;
+  targetActorId: EntityId;
+  parameters: {
+    provider?: any;
+    skill?: any;
+    medium?: any;
+  }
+};
+
+export type PncpMessageCallbackObject = {
+  type: "message";
+  id: ConversationId;
+  messageId: string;
+  timeCreated: Date;
+  key?: any;
+  message: PncpMessageObject;
+  params?: any;
+  callback?: any;
+  medium?: any;
+  conversationState: ConversationState;
+};
+
+export type PncpMessageObject = {
+  id: ConversationId;
+  body: PncpMessageBody;
+};
+
+
+export function simplifyPncpCallback(cb: PncpCallback): PncpCallbackObject {
+  switch (cb.body.oneofKind) {
+    case "skill": return simplifyPncpRequestCallback(cb.body.skill);
+    case "message": return simplifyPncpMessageCallback(cb.body.message);
+    default: throw Error("Unreachable");
+  }
+}
+
+export function simplifyPncpRequestCallback(cb: PncpRequestCallback): PncpRequestCallbackObject {
+  return {
+    type: "skill",
+    id: cb.id!,
+    messageId: cb.messageId,
+    parentId: cb.parentId,
+    body: {
+      subject: cb.body!.subject,
+      action: cb.body!.action,
+      body: Value.toJson(cb.body!.body!),
+    },
+    authorId: cb.authorId!,
+    timeCreated: Timestamp.toDate(cb.timeCreated!),
+    targetActorId: cb.targetActorId!,
+    parameters: {
+      provider: cb.parameters?.provider && Value.toJson(cb.parameters.provider),
+      skill: cb.parameters?.skill && Value.toJson(cb.parameters.skill),
+      medium: cb.parameters?.medium && Value.toJson(cb.parameters.medium),
+    },
+  };
+}
+
+export function simplifyPncpMessageCallback(cb: PncpMessageCallback): PncpMessageCallbackObject {
+  return {
+    type: "message",
+    id: cb.id!,
+    messageId: cb.messageId,
+    timeCreated: Timestamp.toDate(cb.timeCreated!),
+    key: cb.key && Value.toJson(cb.key),
+    message: simplifyPncpMessage(cb.message!),
+    params: cb.params && Value.toJson(cb.params),
+    callback: cb.callback && Value.toJson(cb.callback),
+    medium: cb.medium && Value.toJson(cb.medium),
+    conversationState: cb.conversationState,
+  };
+}
+
+export function simplifyPncpMessage(msg: PncpMessage): PncpMessageObject {
+  let body: PncpMessageBody;
+  switch (msg.kind) {
+    case PncpMessageKind.PNCP_CANCEL:
+    case PncpMessageKind.PNCP_STATUS:
+    case PncpMessageKind.PNCP_ERROR:
+    case PncpMessageKind.PNCP_RESPONSE: {
+      body = {
+        type: msg.kind, value: { data: Value.toJson(msg.body!) }
+      };
+      break;
+    }
+    case PncpMessageKind.PNCP_QUESTION: {
+      let extra = msg.extra;
+      if (extra.oneofKind != "question") throw Error("Invalid PNCP");
+      body = {
+        type: msg.kind,
+        value: {
+          data: Value.toJson(msg.body!),
+          id: extra.question.id,
+          callback: extra.question.callback && Value.toJson(extra.question.callback)
+        }
+      };
+      break;
+    }
+    case PncpMessageKind.PNCP_ANSWER: {
+      let extra = msg.extra;
+      if (extra.oneofKind != "answer") throw Error("Invalid PNCP");
+      body = {
+        type: msg.kind,
+        value: {
+          data: Value.toJson(msg.body!),
+          reply_to: extra.answer.replyTo,
+        },
+      };
+      break;
+    }
+  }
+
+  return { id: msg.id!, body };
+}
+
+
+
+
+export type ObservationCallbackObject = {
+  subject: string;
+  action: string;
+  requester: EntityId;
+  fulfiller: EntityId;
+  message: PncpCallbackObject;
+  id: ConversationId;
+  callback?: any;
+  prevMid?: string;
+  skillId: EntityId;
+};
+
+export function simplifyObservationCallback(cb: ObservationCallback): ObservationCallbackObject {
+  return {
+    subject: cb.subject,
+    action: cb.action,
+    requester: cb.requester!,
+    fulfiller: cb.fulfiller!,
+    message: simplifyPncpCallback(cb.message!),
+    id: cb.id!,
+    callback: cb.callback && Value.toJson(cb.callback),
+    prevMid: cb.prevMid,
+    skillId: cb.skillId!,
+  };
+}

package/src/proto/broker.grpc.client.ts

@@ -0,0 +1,193 @@
+// @generated by protobuf-ts 2.9.4
+// @generated from protobuf file "broker.grpc.proto" (package "pncp.v1", syntax proto3)
+// tslint:disable
+import type { RpcTransport } from "@protobuf-ts/runtime-rpc";
+import type { ServiceInfo } from "@protobuf-ts/runtime-rpc";
+import { Broker } from "./broker.grpc";
+import type { PncpMediumMessage } from "./mediums";
+import type { RefreshTokenRequest } from "./broker_api";
+import type { LoginResponse } from "./broker_api";
+import type { LoginRequest } from "./broker_api";
+import type { CrossDomainStreamMessage } from "./broker_api";
+import type { DuplexStreamingCall } from "@protobuf-ts/runtime-rpc";
+import type { CrossDomainResponse } from "./broker_api";
+import type { CrossDomainMessage } from "./broker_api";
+import type { ObservationMessageWrapper } from "./observation";
+import type { ObservationRequest } from "./observation";
+import type { PncpCallback } from "./pncp";
+import type { PncpCallbackRequest } from "./broker_api";
+import type { ServerStreamingCall } from "@protobuf-ts/runtime-rpc";
+import type { PncpMessage } from "./pncp";
+import { stackIntercept } from "@protobuf-ts/runtime-rpc";
+import type { MessageResponse } from "./broker_api";
+import type { PncpRequest } from "./pncp";
+import type { UnaryCall } from "@protobuf-ts/runtime-rpc";
+import type { RpcOptions } from "@protobuf-ts/runtime-rpc";
+// NOTE (JAB, 2024-06-11): Some protobuf compilers (notably, protoc) don't like it when your rpc and
+// messages have the same name. We ran into this with rpc PncpMessageRequest being originally named
+// PncpMessage. This produces a cryptic error message like:
+//   broker.grpc.proto:22:19: "PncpMessage" is not a message type.
+
+/**
+ * @generated from protobuf service pncp.v1.Broker
+ */
+export interface IBrokerClient {
+    /**
+     * A skill request initiates a conversation between the requesting actor and the corresponding matched
+     * actor. Any further messages within the conversation are sent via PncpMessage.
+     * Messages are forwarded to actors depending on the actor configuration, but the majority of actors
+     * will receive their messages as a callback on `PncpCallbackStream`.
+     *
+     * @generated from protobuf rpc: SkillRequest(pncp.v1.PncpRequest) returns (pncp.v1.MessageResponse);
+     */
+    skillRequest(input: PncpRequest, options?: RpcOptions): UnaryCall<PncpRequest, MessageResponse>;
+    /**
+     * Follow up messages within a conversation are sent with via this endpoint.
+     *
+     * @generated from protobuf rpc: PncpMessageRequest(pncp.v1.PncpMessage) returns (pncp.v1.MessageResponse);
+     */
+    pncpMessageRequest(input: PncpMessage, options?: RpcOptions): UnaryCall<PncpMessage, MessageResponse>;
+    /**
+     * The callback stream for an actor to receive all Pncp type messages. This includes skill requests
+     * and all additional Pncp messages sent in the conversation thread.
+     *
+     * @generated from protobuf rpc: PncpCallbackStream(pncp.v1.PncpCallbackRequest) returns (stream pncp.v1.PncpCallback);
+     */
+    pncpCallbackStream(input: PncpCallbackRequest, options?: RpcOptions): ServerStreamingCall<PncpCallbackRequest, PncpCallback>;
+    /**
+     * Creates a new observation stream.
+     *
+     * @generated from protobuf rpc: CreateObserverStream(pncp.v1.ObservationRequest) returns (stream pncp.v1.ObservationMessageWrapper);
+     */
+    createObserverStream(input: ObservationRequest, options?: RpcOptions): ServerStreamingCall<ObservationRequest, ObservationMessageWrapper>;
+    /**
+     * A direct cross domain request, posted from one node to another. The other node is often expected to post
+     * the results back.
+     *
+     * @generated from protobuf rpc: CrossDomainRequest(pncp.v1.CrossDomainMessage) returns (pncp.v1.CrossDomainResponse);
+     */
+    crossDomainRequest(input: CrossDomainMessage, options?: RpcOptions): UnaryCall<CrossDomainMessage, CrossDomainResponse>;
+    /**
+     * Inverted API for an edge node to connect to another node. It creates this stream so that the node it
+     * connects to can stream messages back to the edge node. The edge node is then required to stream
+     * `MessageResponse` to each incoming message back to the connected node.
+     *
+     * @generated from protobuf rpc: CrossDomainStream(stream pncp.v1.CrossDomainResponse) returns (stream pncp.v1.CrossDomainStreamMessage);
+     */
+    crossDomainStream(options?: RpcOptions): DuplexStreamingCall<CrossDomainResponse, CrossDomainStreamMessage>;
+    /**
+     * @generated from protobuf rpc: Login(pncp.v1.LoginRequest) returns (pncp.v1.LoginResponse);
+     */
+    login(input: LoginRequest, options?: RpcOptions): UnaryCall<LoginRequest, LoginResponse>;
+    /**
+     * @generated from protobuf rpc: RefreshToken(pncp.v1.RefreshTokenRequest) returns (pncp.v1.LoginResponse);
+     */
+    refreshToken(input: RefreshTokenRequest, options?: RpcOptions): UnaryCall<RefreshTokenRequest, LoginResponse>;
+    /**
+     * A PNCP message received from a medium. Note, that we are likely to rework mediums.
+     * Given currently limitations with mediums this route is left unauthenticated.
+     *
+     * @generated from protobuf rpc: PncpMediumMessageRequest(pncp.v1.PncpMediumMessage) returns (pncp.v1.MessageResponse);
+     */
+    pncpMediumMessageRequest(input: PncpMediumMessage, options?: RpcOptions): UnaryCall<PncpMediumMessage, MessageResponse>;
+}
+// NOTE (JAB, 2024-06-11): Some protobuf compilers (notably, protoc) don't like it when your rpc and
+// messages have the same name. We ran into this with rpc PncpMessageRequest being originally named
+// PncpMessage. This produces a cryptic error message like:
+//   broker.grpc.proto:22:19: "PncpMessage" is not a message type.
+
+/**
+ * @generated from protobuf service pncp.v1.Broker
+ */
+export class BrokerClient implements IBrokerClient, ServiceInfo {
+    typeName = Broker.typeName;
+    methods = Broker.methods;
+    options = Broker.options;
+    constructor(private readonly _transport: RpcTransport) {
+    }
+    /**
+     * A skill request initiates a conversation between the requesting actor and the corresponding matched
+     * actor. Any further messages within the conversation are sent via PncpMessage.
+     * Messages are forwarded to actors depending on the actor configuration, but the majority of actors
+     * will receive their messages as a callback on `PncpCallbackStream`.
+     *
+     * @generated from protobuf rpc: SkillRequest(pncp.v1.PncpRequest) returns (pncp.v1.MessageResponse);
+     */
+    skillRequest(input: PncpRequest, options?: RpcOptions): UnaryCall<PncpRequest, MessageResponse> {
+        const method = this.methods[0], opt = this._transport.mergeOptions(options);
+        return stackIntercept<PncpRequest, MessageResponse>("unary", this._transport, method, opt, input);
+    }
+    /**
+     * Follow up messages within a conversation are sent with via this endpoint.
+     *
+     * @generated from protobuf rpc: PncpMessageRequest(pncp.v1.PncpMessage) returns (pncp.v1.MessageResponse);
+     */
+    pncpMessageRequest(input: PncpMessage, options?: RpcOptions): UnaryCall<PncpMessage, MessageResponse> {
+        const method = this.methods[1], opt = this._transport.mergeOptions(options);
+        return stackIntercept<PncpMessage, MessageResponse>("unary", this._transport, method, opt, input);
+    }
+    /**
+     * The callback stream for an actor to receive all Pncp type messages. This includes skill requests
+     * and all additional Pncp messages sent in the conversation thread.
+     *
+     * @generated from protobuf rpc: PncpCallbackStream(pncp.v1.PncpCallbackRequest) returns (stream pncp.v1.PncpCallback);
+     */
+    pncpCallbackStream(input: PncpCallbackRequest, options?: RpcOptions): ServerStreamingCall<PncpCallbackRequest, PncpCallback> {
+        const method = this.methods[2], opt = this._transport.mergeOptions(options);
+        return stackIntercept<PncpCallbackRequest, PncpCallback>("serverStreaming", this._transport, method, opt, input);
+    }
+    /**
+     * Creates a new observation stream.
+     *
+     * @generated from protobuf rpc: CreateObserverStream(pncp.v1.ObservationRequest) returns (stream pncp.v1.ObservationMessageWrapper);
+     */
+    createObserverStream(input: ObservationRequest, options?: RpcOptions): ServerStreamingCall<ObservationRequest, ObservationMessageWrapper> {
+        const method = this.methods[3], opt = this._transport.mergeOptions(options);
+        return stackIntercept<ObservationRequest, ObservationMessageWrapper>("serverStreaming", this._transport, method, opt, input);
+    }
+    /**
+     * A direct cross domain request, posted from one node to another. The other node is often expected to post
+     * the results back.
+     *
+     * @generated from protobuf rpc: CrossDomainRequest(pncp.v1.CrossDomainMessage) returns (pncp.v1.CrossDomainResponse);
+     */
+    crossDomainRequest(input: CrossDomainMessage, options?: RpcOptions): UnaryCall<CrossDomainMessage, CrossDomainResponse> {
+        const method = this.methods[4], opt = this._transport.mergeOptions(options);
+        return stackIntercept<CrossDomainMessage, CrossDomainResponse>("unary", this._transport, method, opt, input);
+    }
+    /**
+     * Inverted API for an edge node to connect to another node. It creates this stream so that the node it
+     * connects to can stream messages back to the edge node. The edge node is then required to stream
+     * `MessageResponse` to each incoming message back to the connected node.
+     *
+     * @generated from protobuf rpc: CrossDomainStream(stream pncp.v1.CrossDomainResponse) returns (stream pncp.v1.CrossDomainStreamMessage);
+     */
+    crossDomainStream(options?: RpcOptions): DuplexStreamingCall<CrossDomainResponse, CrossDomainStreamMessage> {
+        const method = this.methods[5], opt = this._transport.mergeOptions(options);
+        return stackIntercept<CrossDomainResponse, CrossDomainStreamMessage>("duplex", this._transport, method, opt);
+    }
+    /**
+     * @generated from protobuf rpc: Login(pncp.v1.LoginRequest) returns (pncp.v1.LoginResponse);
+     */
+    login(input: LoginRequest, options?: RpcOptions): UnaryCall<LoginRequest, LoginResponse> {
+        const method = this.methods[6], opt = this._transport.mergeOptions(options);
+        return stackIntercept<LoginRequest, LoginResponse>("unary", this._transport, method, opt, input);
+    }
+    /**
+     * @generated from protobuf rpc: RefreshToken(pncp.v1.RefreshTokenRequest) returns (pncp.v1.LoginResponse);
+     */
+    refreshToken(input: RefreshTokenRequest, options?: RpcOptions): UnaryCall<RefreshTokenRequest, LoginResponse> {
+        const method = this.methods[7], opt = this._transport.mergeOptions(options);
+        return stackIntercept<RefreshTokenRequest, LoginResponse>("unary", this._transport, method, opt, input);
+    }
+    /**
+     * A PNCP message received from a medium. Note, that we are likely to rework mediums.
+     * Given currently limitations with mediums this route is left unauthenticated.
+     *
+     * @generated from protobuf rpc: PncpMediumMessageRequest(pncp.v1.PncpMediumMessage) returns (pncp.v1.MessageResponse);
+     */
+    pncpMediumMessageRequest(input: PncpMediumMessage, options?: RpcOptions): UnaryCall<PncpMediumMessage, MessageResponse> {
+        const method = this.methods[8], opt = this._transport.mergeOptions(options);
+        return stackIntercept<PncpMediumMessage, MessageResponse>("unary", this._transport, method, opt, input);
+    }
+}

package/src/proto/broker.grpc.ts

@@ -0,0 +1,32 @@
+// @generated by protobuf-ts 2.9.4
+// @generated from protobuf file "broker.grpc.proto" (package "pncp.v1", syntax proto3)
+// tslint:disable
+import { PncpMediumMessage } from "./mediums";
+import { RefreshTokenRequest } from "./broker_api";
+import { LoginResponse } from "./broker_api";
+import { LoginRequest } from "./broker_api";
+import { CrossDomainStreamMessage } from "./broker_api";
+import { CrossDomainResponse } from "./broker_api";
+import { CrossDomainMessage } from "./broker_api";
+import { ObservationMessageWrapper } from "./observation";
+import { ObservationRequest } from "./observation";
+import { PncpCallback } from "./pncp";
+import { PncpCallbackRequest } from "./broker_api";
+import { PncpMessage } from "./pncp";
+import { MessageResponse } from "./broker_api";
+import { PncpRequest } from "./pncp";
+import { ServiceType } from "@protobuf-ts/runtime-rpc";
+/**
+ * @generated ServiceType for protobuf service pncp.v1.Broker
+ */
+export const Broker = new ServiceType("pncp.v1.Broker", [
+    { name: "SkillRequest", options: {}, I: PncpRequest, O: MessageResponse },
+    { name: "PncpMessageRequest", options: {}, I: PncpMessage, O: MessageResponse },
+    { name: "PncpCallbackStream", serverStreaming: true, options: {}, I: PncpCallbackRequest, O: PncpCallback },
+    { name: "CreateObserverStream", serverStreaming: true, options: {}, I: ObservationRequest, O: ObservationMessageWrapper },
+    { name: "CrossDomainRequest", options: {}, I: CrossDomainMessage, O: CrossDomainResponse },
+    { name: "CrossDomainStream", serverStreaming: true, clientStreaming: true, options: {}, I: CrossDomainResponse, O: CrossDomainStreamMessage },
+    { name: "Login", options: { unauthenticated: true }, I: LoginRequest, O: LoginResponse },
+    { name: "RefreshToken", options: { unauthenticated: true }, I: RefreshTokenRequest, O: LoginResponse },
+    { name: "PncpMediumMessageRequest", options: { unauthenticated: true }, I: PncpMediumMessage, O: MessageResponse }
+]);