@rise-maritime/keelson-js 0.5.3 → 0.6.0-pre.3

package/dist/index.d.ts

@@ -2,7 +2,9 @@ import { Envelope } from './Envelope';
 import { MessageType } from './payloads/typeRegistry';
 import './payloads';
 export declare function construct_pubSub_key(base_path: string, entityId: string, subject: string, sourceId: string, targetId?: string): string;
-export declare function construct_rpc_key(base_path: string, entityId: string, procedure: string, sourceId: string): string;
+export declare function construct_rpc_key(base_path: string, entityId: string, iface: string, version: string, procedure: string, sourceId: string): string;
+export declare function construct_source_liveliness_key(base_path: string, entityId: string, sourceId: string): string;
+export declare function construct_rpc_interface_liveliness_key(base_path: string, entityId: string, iface: string, version: string, sourceId: string): string;
 export interface ParsedPubSubKey {
     base_path: string;
     entityId: string;
@@ -17,6 +19,437 @@ export declare function enclose(payload: Uint8Array, enclosed_at?: Date): Envelo
 export declare function uncover(encodedEnvelope: Uint8Array): [Date, Date | undefined, Uint8Array] | undefined;
 export declare function isSubjectWellKnown(subject: string): boolean;
 export declare function getSubjectSchema(subject: string): string | undefined;
+export declare function isInterfaceWellKnown(interfaceAndVersion: string): boolean;
+export declare function getInterfaceService(interfaceAndVersion: string): string | undefined;
+export declare function listInterfaces(): string[];
+export declare function getInterfaceDefinition(interfaceAndVersion: string): {
+    readonly name: "Configurable";
+    readonly fullName: "keelson.interfaces.configurable.Configurable";
+    readonly methods: {
+        readonly get_config: {
+            readonly name: "get_config";
+            readonly requestType: import("./interfaces/google/protobuf/empty").MessageFns<import("./interfaces/google/protobuf/empty").Empty>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/Configurable").MessageFns<import("./interfaces/Configurable").JSON>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly set_config: {
+            readonly name: "set_config";
+            readonly requestType: import("./interfaces/Configurable").MessageFns<import("./interfaces/Configurable").JSON>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/Configurable").MessageFns<import("./interfaces/Configurable").ConfigurableSuccessResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+    };
+} | {
+    readonly name: "MavlinkCommand";
+    readonly fullName: "keelson.interfaces.mavlink_command.MavlinkCommand";
+    readonly methods: {
+        readonly set_message_interval: {
+            readonly name: "set_message_interval";
+            readonly requestType: import("./interfaces/MavlinkCommand").MessageFns<import("./interfaces/MavlinkCommand").SetMessageIntervalRequest>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/MavlinkCommand").MessageFns<import("./interfaces/MavlinkCommand").SetMessageIntervalResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly send_command_long: {
+            readonly name: "send_command_long";
+            readonly requestType: import("./interfaces/MavlinkCommand").MessageFns<import("./interfaces/MavlinkCommand").CommandLongRequest>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/MavlinkCommand").MessageFns<import("./interfaces/MavlinkCommand").CommandLongResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+    };
+} | {
+    readonly name: "NetworkPingPong";
+    readonly fullName: "keelson.interfaces.network_ping_pong.NetworkPingPong";
+    readonly methods: {
+        readonly ping_network: {
+            readonly name: "ping_network";
+            readonly requestType: import("./interfaces/NetworkPingPong").MessageFns<import("./interfaces/NetworkPingPong").NetworkPing>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/NetworkPingPong").MessageFns<import("./interfaces/NetworkPingPong").NetworkPong>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+    };
+} | {
+    readonly name: "ReplayControl";
+    readonly fullName: "keelson.interfaces.replay_control.ReplayControl";
+    readonly methods: {
+        readonly list_files: {
+            readonly name: "list_files";
+            readonly requestType: import("./interfaces/ReplayControl").MessageFns<import("./interfaces/ReplayControl").ListFilesRequest>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/ReplayControl").MessageFns<import("./interfaces/ReplayControl").ListFilesResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly load_file: {
+            readonly name: "load_file";
+            readonly requestType: import("./interfaces/ReplayControl").MessageFns<import("./interfaces/ReplayControl").LoadFileRequest>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/ReplayControl").MessageFns<import("./interfaces/ReplayControl").ReplaySuccessResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly play: {
+            readonly name: "play";
+            readonly requestType: import("./interfaces/google/protobuf/empty").MessageFns<import("./interfaces/google/protobuf/empty").Empty>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/ReplayControl").MessageFns<import("./interfaces/ReplayControl").ReplaySuccessResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly pause: {
+            readonly name: "pause";
+            readonly requestType: import("./interfaces/google/protobuf/empty").MessageFns<import("./interfaces/google/protobuf/empty").Empty>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/ReplayControl").MessageFns<import("./interfaces/ReplayControl").ReplaySuccessResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly stop: {
+            readonly name: "stop";
+            readonly requestType: import("./interfaces/google/protobuf/empty").MessageFns<import("./interfaces/google/protobuf/empty").Empty>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/ReplayControl").MessageFns<import("./interfaces/ReplayControl").ReplaySuccessResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly seek: {
+            readonly name: "seek";
+            readonly requestType: import("./interfaces/ReplayControl").MessageFns<import("./interfaces/ReplayControl").SeekRequest>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/ReplayControl").MessageFns<import("./interfaces/ReplayControl").ReplaySuccessResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly set_speed: {
+            readonly name: "set_speed";
+            readonly requestType: import("./interfaces/ReplayControl").MessageFns<import("./interfaces/ReplayControl").SetSpeedRequest>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/ReplayControl").MessageFns<import("./interfaces/ReplayControl").ReplaySuccessResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly set_loop: {
+            readonly name: "set_loop";
+            readonly requestType: import("./interfaces/ReplayControl").MessageFns<import("./interfaces/ReplayControl").SetLoopRequest>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/ReplayControl").MessageFns<import("./interfaces/ReplayControl").ReplaySuccessResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+    };
+} | {
+    readonly name: "RoutePlanner";
+    readonly fullName: "keelson.interfaces.route_planner.RoutePlanner";
+    readonly methods: {
+        readonly plan_route: {
+            readonly name: "plan_route";
+            readonly requestType: import("./interfaces/RoutePlanner").MessageFns<import("./interfaces/RoutePlanner").PlanRouteRequest>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/Route").MessageFns<import("./interfaces/Route").Route>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly validate_route: {
+            readonly name: "validate_route";
+            readonly requestType: import("./interfaces/Route").MessageFns<import("./interfaces/Route").Route>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/Route").MessageFns<import("./interfaces/Route").Route>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly get_route: {
+            readonly name: "get_route";
+            readonly requestType: import("./interfaces/Route").MessageFns<import("./interfaces/Route").RouteRef>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/Route").MessageFns<import("./interfaces/Route").Route>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly select_route: {
+            readonly name: "select_route";
+            readonly requestType: import("./interfaces/Route").MessageFns<import("./interfaces/Route").RouteRef>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/Route").MessageFns<import("./interfaces/Route").Route>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+    };
+} | {
+    readonly name: "SimulationControl";
+    readonly fullName: "keelson.interfaces.simulation_control.SimulationControl";
+    readonly methods: {
+        readonly start: {
+            readonly name: "start";
+            readonly requestType: import("./interfaces/google/protobuf/empty").MessageFns<import("./interfaces/google/protobuf/empty").Empty>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/SimulationControl").MessageFns<import("./interfaces/SimulationControl").StartResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly pause: {
+            readonly name: "pause";
+            readonly requestType: import("./interfaces/google/protobuf/empty").MessageFns<import("./interfaces/google/protobuf/empty").Empty>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/SimulationControl").MessageFns<import("./interfaces/SimulationControl").PauseResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly stop: {
+            readonly name: "stop";
+            readonly requestType: import("./interfaces/google/protobuf/empty").MessageFns<import("./interfaces/google/protobuf/empty").Empty>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/SimulationControl").MessageFns<import("./interfaces/SimulationControl").StopResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+    };
+} | {
+    readonly name: "Subscriber";
+    readonly fullName: "keelson.interfaces.subscriber.Subscriber";
+    readonly methods: {
+        readonly get_subscriptions: {
+            readonly name: "get_subscriptions";
+            readonly requestType: import("./interfaces/google/protobuf/empty").MessageFns<import("./interfaces/google/protobuf/empty").Empty>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/Subscriber").MessageFns<import("./interfaces/Subscriber").Subscriptions>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly set_subscriptions: {
+            readonly name: "set_subscriptions";
+            readonly requestType: import("./interfaces/Subscriber").MessageFns<import("./interfaces/Subscriber").Subscriptions>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/Subscriber").MessageFns<import("./interfaces/Subscriber").SubscriberSuccessResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+    };
+} | {
+    readonly name: "VehicleControl";
+    readonly fullName: "keelson.interfaces.vehicle_control.VehicleControl";
+    readonly methods: {
+        readonly set_control_mapping: {
+            readonly name: "set_control_mapping";
+            readonly requestType: import("./interfaces/VehicleControl").MessageFns<import("./interfaces/VehicleControl").ControlAxisMapping>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/VehicleControl").MessageFns<import("./interfaces/VehicleControl").ControlAxisMappingAck>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly get_control_mapping: {
+            readonly name: "get_control_mapping";
+            readonly requestType: import("./interfaces/google/protobuf/empty").MessageFns<import("./interfaces/google/protobuf/empty").Empty>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/VehicleControl").MessageFns<import("./interfaces/VehicleControl").ControlAxisMapping>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+    };
+} | {
+    readonly name: "VehicleGeofence";
+    readonly fullName: "keelson.interfaces.vehicle_geofence.VehicleGeofence";
+    readonly methods: {
+        readonly upload_geofence: {
+            readonly name: "upload_geofence";
+            readonly requestType: import("./interfaces/VehicleGeofence").MessageFns<import("./interfaces/VehicleGeofence").Geofence>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/VehicleGeofence").MessageFns<import("./interfaces/VehicleGeofence").GeofenceUploadResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly enable_geofence: {
+            readonly name: "enable_geofence";
+            readonly requestType: import("./interfaces/VehicleGeofence").MessageFns<import("./interfaces/VehicleGeofence").EnableGeofenceRequest>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/VehicleGeofence").MessageFns<import("./interfaces/VehicleGeofence").EnableGeofenceResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+    };
+} | {
+    readonly name: "VehicleLifecycle";
+    readonly fullName: "keelson.interfaces.vehicle_lifecycle.VehicleLifecycle";
+    readonly methods: {
+        readonly arm: {
+            readonly name: "arm";
+            readonly requestType: import("./interfaces/VehicleLifecycle").MessageFns<import("./interfaces/VehicleLifecycle").ArmRequest>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/VehicleLifecycle").MessageFns<import("./interfaces/VehicleLifecycle").ArmResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly set_mode: {
+            readonly name: "set_mode";
+            readonly requestType: import("./interfaces/VehicleLifecycle").MessageFns<import("./interfaces/VehicleLifecycle").SetModeRequest>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/VehicleLifecycle").MessageFns<import("./interfaces/VehicleLifecycle").SetModeResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly emergency_stop: {
+            readonly name: "emergency_stop";
+            readonly requestType: import("./interfaces/VehicleLifecycle").MessageFns<import("./interfaces/VehicleLifecycle").EmergencyStopRequest>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/VehicleLifecycle").MessageFns<import("./interfaces/VehicleLifecycle").EmergencyStopResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+    };
+} | {
+    readonly name: "VehicleMission";
+    readonly fullName: "keelson.interfaces.vehicle_mission.VehicleMission";
+    readonly methods: {
+        readonly upload_mission: {
+            readonly name: "upload_mission";
+            readonly requestType: import("./interfaces/Mission").MessageFns<import("./interfaces/Mission").Mission>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/VehicleMission").MessageFns<import("./interfaces/VehicleMission").MissionUploadResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly download_mission: {
+            readonly name: "download_mission";
+            readonly requestType: import("./interfaces/google/protobuf/empty").MessageFns<import("./interfaces/google/protobuf/empty").Empty>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/Mission").MessageFns<import("./interfaces/Mission").Mission>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly clear_mission: {
+            readonly name: "clear_mission";
+            readonly requestType: import("./interfaces/VehicleMission").MessageFns<import("./interfaces/VehicleMission").ClearMissionRequest>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/VehicleMission").MessageFns<import("./interfaces/VehicleMission").ClearMissionResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly set_current_waypoint: {
+            readonly name: "set_current_waypoint";
+            readonly requestType: import("./interfaces/VehicleMission").MessageFns<import("./interfaces/VehicleMission").SetCurrentWaypointRequest>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/VehicleMission").MessageFns<import("./interfaces/VehicleMission").SetCurrentWaypointResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+    };
+} | {
+    readonly name: "VehicleNavigation";
+    readonly fullName: "keelson.interfaces.vehicle_navigation.VehicleNavigation";
+    readonly methods: {
+        readonly set_navigation_target: {
+            readonly name: "set_navigation_target";
+            readonly requestType: import("./interfaces/VehicleNavigation").MessageFns<import("./interfaces/VehicleNavigation").NavigationTarget>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/VehicleNavigation").MessageFns<import("./interfaces/VehicleNavigation").NavigationTargetResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly set_cruise_speed: {
+            readonly name: "set_cruise_speed";
+            readonly requestType: import("./interfaces/VehicleNavigation").MessageFns<import("./interfaces/VehicleNavigation").SetCruiseSpeedRequest>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/VehicleNavigation").MessageFns<import("./interfaces/VehicleNavigation").SetCruiseSpeedResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+    };
+} | {
+    readonly name: "VehicleParam";
+    readonly fullName: "keelson.interfaces.vehicle_param.VehicleParam";
+    readonly methods: {
+        readonly get_param: {
+            readonly name: "get_param";
+            readonly requestType: import("./interfaces/VehicleParam").MessageFns<import("./interfaces/VehicleParam").ParamGetRequest>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/VehicleParam").MessageFns<import("./interfaces/VehicleParam").ParamValueResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly set_param: {
+            readonly name: "set_param";
+            readonly requestType: import("./interfaces/VehicleParam").MessageFns<import("./interfaces/VehicleParam").ParamSetRequest>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/VehicleParam").MessageFns<import("./interfaces/VehicleParam").ParamValueResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly list_params: {
+            readonly name: "list_params";
+            readonly requestType: import("./interfaces/google/protobuf/empty").MessageFns<import("./interfaces/google/protobuf/empty").Empty>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/VehicleParam").MessageFns<import("./interfaces/VehicleParam").ParamListResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly set_params: {
+            readonly name: "set_params";
+            readonly requestType: import("./interfaces/VehicleParam").MessageFns<import("./interfaces/VehicleParam").ParamSetBulkRequest>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/VehicleParam").MessageFns<import("./interfaces/VehicleParam").ParamSetBulkResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly save_params: {
+            readonly name: "save_params";
+            readonly requestType: import("./interfaces/VehicleParam").MessageFns<import("./interfaces/VehicleParam").SaveParamsRequest>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/VehicleParam").MessageFns<import("./interfaces/VehicleParam").SaveParamsResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+    };
+} | {
+    readonly name: "VehicleSimulatorControl";
+    readonly fullName: "keelson.interfaces.vehicle_simulator_control.VehicleSimulatorControl";
+    readonly methods: {
+        readonly set_initial_pose: {
+            readonly name: "set_initial_pose";
+            readonly requestType: import("./interfaces/VehicleSimulatorControl").MessageFns<import("./interfaces/VehicleSimulatorControl").InitialPose>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/VehicleSimulatorControl").MessageFns<import("./interfaces/VehicleSimulatorControl").SetInitialPoseResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+    };
+} | {
+    readonly name: "WHEPProxy";
+    readonly fullName: "keelson.interfaces.whep_proxy.WHEPProxy";
+    readonly methods: {
+        readonly whep_signal: {
+            readonly name: "whep_signal";
+            readonly requestType: import("./interfaces/WHEPProxy").MessageFns<import("./interfaces/WHEPProxy").WHEPRequest>;
+            readonly requestStream: false;
+            readonly responseType: import("./interfaces/WHEPProxy").MessageFns<import("./interfaces/WHEPProxy").WHEPResponse>;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+    };
+};
+export declare function getProcedures(interfaceAndVersion: string): string[];
+export interface ProcedureCodec {
+    /** ts-proto MessageFns: encode/decode/fromJSON/toJSON/fromPartial */
+    requestType: unknown;
+    responseType: unknown;
+}
+export declare function getProcedureCodecs(interfaceAndVersion: string, procedure: string): ProcedureCodec;
+export interface QoSProfile {
+    name: string;
+    priority: "REAL_TIME" | "INTERACTIVE_HIGH" | "INTERACTIVE_LOW" | "DATA_HIGH" | "DATA" | "DATA_LOW" | "BACKGROUND";
+    congestion_control: "DROP" | "BLOCK";
+    reliability: "RELIABLE" | "BEST_EFFORT";
+    express: boolean;
+}
+/** Return the QoS profile assigned to a well-known subject (or the default). */
+export declare function qosFor(subject: string): QoSProfile;
 export declare function getProtobufClassFromTypeName(typeName: string): MessageType<import("./payloads/typeRegistry").UnknownMessage> | undefined;
 export declare function decodePayloadFromTypeName(typeName: string, payload: Uint8Array): import("./payloads/typeRegistry").UnknownMessage | undefined;
 export declare function encodePayloadFromTypeName(typeName: string, payload: any): Uint8Array | undefined;

package/dist/index.js

@@ -3,15 +3,23 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.encloseFromTypeName = exports.encodePayloadFromTypeName = exports.decodePayloadFromTypeName = exports.getProtobufClassFromTypeName = exports.getSubjectSchema = exports.isSubjectWellKnown = exports.uncover = exports.enclose = exports.get_subject_from_pubsub_key = exports.parse_rpc_key = exports.parse_pubsub_key = exports.construct_rpc_key = exports.construct_pubSub_key = void 0;
+exports.encloseFromTypeName = exports.encodePayloadFromTypeName = exports.decodePayloadFromTypeName = exports.getProtobufClassFromTypeName = exports.qosFor = exports.getProcedureCodecs = exports.getProcedures = exports.getInterfaceDefinition = exports.listInterfaces = exports.getInterfaceService = exports.isInterfaceWellKnown = exports.getSubjectSchema = exports.isSubjectWellKnown = exports.uncover = exports.enclose = exports.get_subject_from_pubsub_key = exports.parse_rpc_key = exports.parse_pubsub_key = exports.construct_rpc_interface_liveliness_key = exports.construct_source_liveliness_key = exports.construct_rpc_key = exports.construct_pubSub_key = void 0;
 const Envelope_1 = require("./Envelope");
 const subjects_json_1 = __importDefault(require("./subjects.json"));
+const interfaces_json_1 = __importDefault(require("./interfaces.json"));
+const qos_json_1 = __importDefault(require("./qos.json"));
 const typeRegistry_1 = require("./payloads/typeRegistry");
+const serviceRegistry_1 = require("./interfaces/serviceRegistry");
 require("./payloads");
 // KEY HELPER FUNCTIONS
 const KEELSON_BASE_KEY_FORMAT = "{base_path}/@v0/{entity_id}";
 const KEELSON_PUB_SUB_KEY_FORMAT = KEELSON_BASE_KEY_FORMAT + "/pubsub/{subject}/{source_id}";
-const KEELSON_REQ_REP_KEY_FORMAT = KEELSON_BASE_KEY_FORMAT + "/@rpc/{procedure}/{source_id}";
+const KEELSON_REQ_REP_KEY_FORMAT = KEELSON_BASE_KEY_FORMAT + "/@rpc/{interface}/{version}/{procedure}/{source_id}";
+const KEELSON_RPC_INTERFACE_LIVELINESS_KEY_FORMAT = KEELSON_BASE_KEY_FORMAT + "/@rpc/{interface}/{version}/*/{source_id}";
+// An interface version chunk is v{N} with N a positive integer.
+function isValidInterfaceVersion(version) {
+    return /^v[1-9][0-9]*$/.test(version);
+}
 function construct_pubSub_key(base_path, entityId, subject, sourceId, targetId) {
     /**
     * Construct a key expression for a publish and subscribe.
@@ -33,16 +41,58 @@ function construct_pubSub_key(base_path, entityId, subject, sourceId, targetId)
     return targetId ? `${key}/@target/${targetId}` : key;
 }
 exports.construct_pubSub_key = construct_pubSub_key;
-function construct_rpc_key(base_path, entityId, procedure, sourceId) {
+function construct_rpc_key(base_path, entityId, iface, version, procedure, sourceId) {
     /**
      * Construct a key expression for a request reply interaction (Queryable).
+     *
+     * @param iface - Well-known RPC interface name (see interfaces.yaml)
+     * @param version - Interface version chunk, v{N} (e.g. "v1")
      */
+    if (!isValidInterfaceVersion(version)) {
+        throw new Error(`Interface version '${version}' is not of the required form v{N}`);
+    }
+    if (!isInterfaceWellKnown(`${iface}/${version}`)) {
+        console.warn(`Interface: ${iface}/${version} is NOT well-known!`);
+    }
     return KEELSON_REQ_REP_KEY_FORMAT.replace("{base_path}", base_path)
         .replace("{entity_id}", entityId)
+        .replace("{interface}", iface)
+        .replace("{version}", version)
         .replace("{procedure}", procedure)
         .replace("{source_id}", sourceId);
 }
 exports.construct_rpc_key = construct_rpc_key;
+function construct_source_liveliness_key(base_path, entityId, sourceId) {
+    /**
+     * Construct the source-level liveliness token key: "this process is
+     * present on the bus as a producer in some category". The `*` occupies
+     * the category slot (pubsub / @rpc / ...). Note that as a verbatim
+     * chunk, @rpc is never matched by the wildcard — RPC capability is
+     * discovered via the interface-level token instead.
+     */
+    return `${base_path}/@v0/${entityId}/*/${sourceId}`;
+}
+exports.construct_source_liveliness_key = construct_source_liveliness_key;
+function construct_rpc_interface_liveliness_key(base_path, entityId, iface, version, sourceId) {
+    /**
+     * Construct the liveliness token key for one served RPC
+     * (interface, version) pair. The `*` in the procedure slot means
+     * "any procedure in this scope"; under the full-interface rule the
+     * token also claims full coverage of the interface version.
+     */
+    if (!isValidInterfaceVersion(version)) {
+        throw new Error(`Interface version '${version}' is not of the required form v{N}`);
+    }
+    if (!isInterfaceWellKnown(`${iface}/${version}`)) {
+        console.warn(`Interface: ${iface}/${version} is NOT well-known!`);
+    }
+    return KEELSON_RPC_INTERFACE_LIVELINESS_KEY_FORMAT.replace("{base_path}", base_path)
+        .replace("{entity_id}", entityId)
+        .replace("{interface}", iface)
+        .replace("{version}", version)
+        .replace("{source_id}", sourceId);
+}
+exports.construct_rpc_interface_liveliness_key = construct_rpc_interface_liveliness_key;
 function parse_pubsub_key(key) {
     /**
      * Parse a key expression for a publish subscribe interaction.
@@ -74,8 +124,10 @@ function parse_rpc_key(key) {
     return {
         base_path: parts[0],
         entityId: parts[2],
-        procedure: parts[4],
-        sourceId: parts.slice(5).join("/")
+        interface: parts[4],
+        version: parts[5],
+        procedure: parts[6],
+        sourceId: parts.slice(7).join("/")
     };
 }
 exports.parse_rpc_key = parse_rpc_key;
@@ -103,6 +155,63 @@ function getSubjectSchema(subject) {
     return subjects_json_1.default[subject];
 }
 exports.getSubjectSchema = getSubjectSchema;
+// INTERFACES HELPER FUNCTIONS
+function isInterfaceWellKnown(interfaceAndVersion) {
+    return interfaces_json_1.default[interfaceAndVersion] != null;
+}
+exports.isInterfaceWellKnown = isInterfaceWellKnown;
+function getInterfaceService(interfaceAndVersion) {
+    return interfaces_json_1.default[interfaceAndVersion];
+}
+exports.getInterfaceService = getInterfaceService;
+function listInterfaces() {
+    /** All well-known "{interface}/{version}" keys of this SDK release. */
+    return Object.keys(serviceRegistry_1.serviceDefinitions);
+}
+exports.listInterfaces = listInterfaces;
+function getInterfaceDefinition(interfaceAndVersion) {
+    /** The ts-proto generic ServiceDefinition for "{interface}/{version}". */
+    return serviceRegistry_1.serviceDefinitions[interfaceAndVersion];
+}
+exports.getInterfaceDefinition = getInterfaceDefinition;
+function getProcedures(interfaceAndVersion) {
+    /** Procedure (method) names defined by "{interface}/{version}". */
+    const definition = getInterfaceDefinition(interfaceAndVersion);
+    if (definition == null) {
+        throw new Error(`Unknown interface: ${interfaceAndVersion}`);
+    }
+    return Object.values(definition.methods).map((m) => m.name);
+}
+exports.getProcedures = getProcedures;
+function getProcedureCodecs(interfaceAndVersion, procedure) {
+    /**
+     * The request/response message codecs of one procedure — each has
+     * encode/decode/fromJSON/toJSON/fromPartial per ts-proto's message
+     * functions, enabling generic invocation without static imports.
+     */
+    const definition = getInterfaceDefinition(interfaceAndVersion);
+    if (definition == null) {
+        throw new Error(`Unknown interface: ${interfaceAndVersion}`);
+    }
+    for (const method of Object.values(definition.methods)) {
+        const m = method;
+        if (m.name === procedure) {
+            return { requestType: m.requestType, responseType: m.responseType };
+        }
+    }
+    throw new Error(`Unknown procedure ${procedure} on ${interfaceAndVersion}`);
+}
+exports.getProcedureCodecs = getProcedureCodecs;
+const QOS_PROFILES = qos_json_1.default.profiles ?? {};
+const QOS_SUBJECTS = qos_json_1.default.subjects ?? {};
+const QOS_DEFAULT = qos_json_1.default.default ?? "default";
+/** Return the QoS profile assigned to a well-known subject (or the default). */
+function qosFor(subject) {
+    const name = QOS_SUBJECTS[subject] ?? QOS_DEFAULT;
+    const fields = QOS_PROFILES[name];
+    return { name, ...fields };
+}
+exports.qosFor = qosFor;
 // PAYLOADS
 function getProtobufClassFromTypeName(typeName) {
     return typeRegistry_1.messageTypeRegistry.get(typeName);