@rise-maritime/keelson-js 0.5.3 → 0.6.0-alpha.202.dev.1

package/dist/interfaces/serviceRegistry.d.ts

@@ -0,0 +1,520 @@
+export declare const serviceDefinitions: {
+    readonly "configurable/v1": {
+        readonly name: "Configurable";
+        readonly fullName: "keelson.interfaces.configurable.Configurable";
+        readonly methods: {
+            readonly get_config: {
+                readonly name: "get_config";
+                readonly requestType: import("./google/protobuf/empty").MessageFns<import("./google/protobuf/empty").Empty>;
+                readonly requestStream: false;
+                readonly responseType: import("./Configurable").MessageFns<import("./Configurable").JSON>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
+            readonly set_config: {
+                readonly name: "set_config";
+                readonly requestType: import("./Configurable").MessageFns<import("./Configurable").JSON>;
+                readonly requestStream: false;
+                readonly responseType: import("./Configurable").MessageFns<import("./Configurable").ConfigurableSuccessResponse>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
+        };
+    };
+    readonly "mavlink_command/v1": {
+        readonly name: "MavlinkCommand";
+        readonly fullName: "keelson.interfaces.mavlink_command.MavlinkCommand";
+        readonly methods: {
+            readonly set_message_interval: {
+                readonly name: "set_message_interval";
+                readonly requestType: import("./MavlinkCommand").MessageFns<import("./MavlinkCommand").SetMessageIntervalRequest>;
+                readonly requestStream: false;
+                readonly responseType: import("./MavlinkCommand").MessageFns<import("./MavlinkCommand").SetMessageIntervalResponse>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
+            readonly send_command_long: {
+                readonly name: "send_command_long";
+                readonly requestType: import("./MavlinkCommand").MessageFns<import("./MavlinkCommand").CommandLongRequest>;
+                readonly requestStream: false;
+                readonly responseType: import("./MavlinkCommand").MessageFns<import("./MavlinkCommand").CommandLongResponse>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
+        };
+    };
+    readonly "network_ping_pong/v1": {
+        readonly name: "NetworkPingPong";
+        readonly fullName: "keelson.interfaces.network_ping_pong.NetworkPingPong";
+        readonly methods: {
+            readonly ping_network: {
+                readonly name: "ping_network";
+                readonly requestType: import("./NetworkPingPong").MessageFns<import("./NetworkPingPong").NetworkPing>;
+                readonly requestStream: false;
+                readonly responseType: import("./NetworkPingPong").MessageFns<import("./NetworkPingPong").NetworkPong>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
+        };
+    };
+    readonly "replay_control/v1": {
+        readonly name: "ReplayControl";
+        readonly fullName: "keelson.interfaces.replay_control.ReplayControl";
+        readonly methods: {
+            readonly list_files: {
+                readonly name: "list_files";
+                readonly requestType: import("./ReplayControl").MessageFns<import("./ReplayControl").ListFilesRequest>;
+                readonly requestStream: false;
+                readonly responseType: import("./ReplayControl").MessageFns<import("./ReplayControl").ListFilesResponse>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
+            readonly load_file: {
+                readonly name: "load_file";
+                readonly requestType: import("./ReplayControl").MessageFns<import("./ReplayControl").LoadFileRequest>;
+                readonly requestStream: false;
+                readonly responseType: import("./ReplayControl").MessageFns<import("./ReplayControl").ReplaySuccessResponse>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
+            readonly play: {
+                readonly name: "play";
+                readonly requestType: import("./google/protobuf/empty").MessageFns<import("./google/protobuf/empty").Empty>;
+                readonly requestStream: false;
+                readonly responseType: import("./ReplayControl").MessageFns<import("./ReplayControl").ReplaySuccessResponse>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
+            readonly pause: {
+                readonly name: "pause";
+                readonly requestType: import("./google/protobuf/empty").MessageFns<import("./google/protobuf/empty").Empty>;
+                readonly requestStream: false;
+                readonly responseType: import("./ReplayControl").MessageFns<import("./ReplayControl").ReplaySuccessResponse>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
+            readonly stop: {
+                readonly name: "stop";
+                readonly requestType: import("./google/protobuf/empty").MessageFns<import("./google/protobuf/empty").Empty>;
+                readonly requestStream: false;
+                readonly responseType: import("./ReplayControl").MessageFns<import("./ReplayControl").ReplaySuccessResponse>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
+            readonly seek: {
+                readonly name: "seek";
+                readonly requestType: import("./ReplayControl").MessageFns<import("./ReplayControl").SeekRequest>;
+                readonly requestStream: false;
+                readonly responseType: import("./ReplayControl").MessageFns<import("./ReplayControl").ReplaySuccessResponse>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
+            readonly set_speed: {
+                readonly name: "set_speed";
+                readonly requestType: import("./ReplayControl").MessageFns<import("./ReplayControl").SetSpeedRequest>;
+                readonly requestStream: false;
+                readonly responseType: import("./ReplayControl").MessageFns<import("./ReplayControl").ReplaySuccessResponse>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
+            readonly set_loop: {
+                readonly name: "set_loop";
+                readonly requestType: import("./ReplayControl").MessageFns<import("./ReplayControl").SetLoopRequest>;
+                readonly requestStream: false;
+                readonly responseType: import("./ReplayControl").MessageFns<import("./ReplayControl").ReplaySuccessResponse>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
+        };
+    };
+    readonly "route_planner/v1": {
+        readonly name: "RoutePlanner";
+        readonly fullName: "keelson.interfaces.route_planner.RoutePlanner";
+        readonly methods: {
+            readonly plan_route: {
+                readonly name: "plan_route";
+                readonly requestType: import("./RoutePlanner").MessageFns<import("./RoutePlanner").PlanRouteRequest>;
+                readonly requestStream: false;
+                readonly responseType: import("./Route").MessageFns<import("./Route").Route>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
+            readonly validate_route: {
+                readonly name: "validate_route";
+                readonly requestType: import("./Route").MessageFns<import("./Route").Route>;
+                readonly requestStream: false;
+                readonly responseType: import("./Route").MessageFns<import("./Route").Route>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
+            readonly get_route: {
+                readonly name: "get_route";
+                readonly requestType: import("./Route").MessageFns<import("./Route").RouteRef>;
+                readonly requestStream: false;
+                readonly responseType: import("./Route").MessageFns<import("./Route").Route>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
+            readonly select_route: {
+                readonly name: "select_route";
+                readonly requestType: import("./Route").MessageFns<import("./Route").RouteRef>;
+                readonly requestStream: false;
+                readonly responseType: import("./Route").MessageFns<import("./Route").Route>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
+        };
+    };
+    readonly "scenario_checkpoint/v1": {
+        readonly name: "ScenarioCheckpoint";
+        readonly fullName: "keelson.interfaces.scenario_checkpoint.ScenarioCheckpoint";
+        readonly methods: {
+            readonly save: {
+                readonly name: "save";
+                readonly requestType: import("./ScenarioCheckpoint").MessageFns<import("./ScenarioCheckpoint").SaveRequest>;
+                readonly requestStream: false;
+                readonly responseType: import("./ScenarioCheckpoint").MessageFns<import("./ScenarioCheckpoint").SaveResponse>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
+            readonly restore: {
+                readonly name: "restore";
+                readonly requestType: import("./ScenarioCheckpoint").MessageFns<import("./ScenarioCheckpoint").RestoreRequest>;
+                readonly requestStream: false;
+                readonly responseType: import("./ScenarioCheckpoint").MessageFns<import("./ScenarioCheckpoint").RestoreResponse>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
+            readonly list_checkpoints: {
+                readonly name: "list_checkpoints";
+                readonly requestType: import("./ScenarioCheckpoint").MessageFns<import("./ScenarioCheckpoint").ListCheckpointsRequest>;
+                readonly requestStream: false;
+                readonly responseType: import("./ScenarioCheckpoint").MessageFns<import("./ScenarioCheckpoint").ListCheckpointsResponse>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
+        };
+    };
+    readonly "scenario_control/v1": {
+        readonly name: "ScenarioControl";
+        readonly fullName: "keelson.interfaces.scenario_control.ScenarioControl";
+        readonly methods: {
+            readonly load: {
+                readonly name: "load";
+                readonly requestType: import("./ScenarioControl").MessageFns<import("./ScenarioControl").LoadRequest>;
+                readonly requestStream: false;
+                readonly responseType: import("./ScenarioControl").MessageFns<import("./ScenarioControl").LoadResponse>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
+            readonly start: {
+                readonly name: "start";
+                readonly requestType: import("./google/protobuf/empty").MessageFns<import("./google/protobuf/empty").Empty>;
+                readonly requestStream: false;
+                readonly responseType: import("./ScenarioControl").MessageFns<import("./ScenarioControl").StartResponse>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
+            readonly pause: {
+                readonly name: "pause";
+                readonly requestType: import("./google/protobuf/empty").MessageFns<import("./google/protobuf/empty").Empty>;
+                readonly requestStream: false;
+                readonly responseType: import("./ScenarioControl").MessageFns<import("./ScenarioControl").PauseResponse>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
+            readonly stop: {
+                readonly name: "stop";
+                readonly requestType: import("./google/protobuf/empty").MessageFns<import("./google/protobuf/empty").Empty>;
+                readonly requestStream: false;
+                readonly responseType: import("./ScenarioControl").MessageFns<import("./ScenarioControl").StopResponse>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
+            readonly reset: {
+                readonly name: "reset";
+                readonly requestType: import("./google/protobuf/empty").MessageFns<import("./google/protobuf/empty").Empty>;
+                readonly requestStream: false;
+                readonly responseType: import("./ScenarioControl").MessageFns<import("./ScenarioControl").ResetResponse>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
+            readonly step: {
+                readonly name: "step";
+                readonly requestType: import("./ScenarioControl").MessageFns<import("./ScenarioControl").StepRequest>;
+                readonly requestStream: false;
+                readonly responseType: import("./ScenarioControl").MessageFns<import("./ScenarioControl").StepResponse>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
+            readonly set_rate: {
+                readonly name: "set_rate";
+                readonly requestType: import("./ScenarioControl").MessageFns<import("./ScenarioControl").SetRateRequest>;
+                readonly requestStream: false;
+                readonly responseType: import("./ScenarioControl").MessageFns<import("./ScenarioControl").SetRateResponse>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
+        };
+    };
+    readonly "simulation_control/v1": {
+        readonly name: "SimulationControl";
+        readonly fullName: "keelson.interfaces.simulation_control.SimulationControl";
+        readonly methods: {
+            readonly start: {
+                readonly name: "start";
+                readonly requestType: import("./google/protobuf/empty").MessageFns<import("./google/protobuf/empty").Empty>;
+                readonly requestStream: false;
+                readonly responseType: import("./SimulationControl").MessageFns<import("./SimulationControl").StartResponse>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
+            readonly pause: {
+                readonly name: "pause";
+                readonly requestType: import("./google/protobuf/empty").MessageFns<import("./google/protobuf/empty").Empty>;
+                readonly requestStream: false;
+                readonly responseType: import("./SimulationControl").MessageFns<import("./SimulationControl").PauseResponse>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
+            readonly stop: {
+                readonly name: "stop";
+                readonly requestType: import("./google/protobuf/empty").MessageFns<import("./google/protobuf/empty").Empty>;
+                readonly requestStream: false;
+                readonly responseType: import("./SimulationControl").MessageFns<import("./SimulationControl").StopResponse>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
+        };
+    };
+    readonly "subscriber/v1": {
+        readonly name: "Subscriber";
+        readonly fullName: "keelson.interfaces.subscriber.Subscriber";
+        readonly methods: {
+            readonly get_subscriptions: {
+                readonly name: "get_subscriptions";
+                readonly requestType: import("./google/protobuf/empty").MessageFns<import("./google/protobuf/empty").Empty>;
+                readonly requestStream: false;
+                readonly responseType: import("./Subscriber").MessageFns<import("./Subscriber").Subscriptions>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
+            readonly set_subscriptions: {
+                readonly name: "set_subscriptions";
+                readonly requestType: import("./Subscriber").MessageFns<import("./Subscriber").Subscriptions>;
+                readonly requestStream: false;
+                readonly responseType: import("./Subscriber").MessageFns<import("./Subscriber").SubscriberSuccessResponse>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
+        };
+    };
+    readonly "vehicle_control/v1": {
+        readonly name: "VehicleControl";
+        readonly fullName: "keelson.interfaces.vehicle_control.VehicleControl";
+        readonly methods: {
+            readonly set_control_mapping: {
+                readonly name: "set_control_mapping";
+                readonly requestType: import("./VehicleControl").MessageFns<import("./VehicleControl").ControlAxisMapping>;
+                readonly requestStream: false;
+                readonly responseType: import("./VehicleControl").MessageFns<import("./VehicleControl").ControlAxisMappingAck>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
+            readonly get_control_mapping: {
+                readonly name: "get_control_mapping";
+                readonly requestType: import("./google/protobuf/empty").MessageFns<import("./google/protobuf/empty").Empty>;
+                readonly requestStream: false;
+                readonly responseType: import("./VehicleControl").MessageFns<import("./VehicleControl").ControlAxisMapping>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
+        };
+    };
+    readonly "vehicle_geofence/v1": {
+        readonly name: "VehicleGeofence";
+        readonly fullName: "keelson.interfaces.vehicle_geofence.VehicleGeofence";
+        readonly methods: {
+            readonly upload_geofence: {
+                readonly name: "upload_geofence";
+                readonly requestType: import("./VehicleGeofence").MessageFns<import("./VehicleGeofence").Geofence>;
+                readonly requestStream: false;
+                readonly responseType: import("./VehicleGeofence").MessageFns<import("./VehicleGeofence").GeofenceUploadResponse>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
+            readonly enable_geofence: {
+                readonly name: "enable_geofence";
+                readonly requestType: import("./VehicleGeofence").MessageFns<import("./VehicleGeofence").EnableGeofenceRequest>;
+                readonly requestStream: false;
+                readonly responseType: import("./VehicleGeofence").MessageFns<import("./VehicleGeofence").EnableGeofenceResponse>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
+        };
+    };
+    readonly "vehicle_lifecycle/v1": {
+        readonly name: "VehicleLifecycle";
+        readonly fullName: "keelson.interfaces.vehicle_lifecycle.VehicleLifecycle";
+        readonly methods: {
+            readonly arm: {
+                readonly name: "arm";
+                readonly requestType: import("./VehicleLifecycle").MessageFns<import("./VehicleLifecycle").ArmRequest>;
+                readonly requestStream: false;
+                readonly responseType: import("./VehicleLifecycle").MessageFns<import("./VehicleLifecycle").ArmResponse>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
+            readonly set_mode: {
+                readonly name: "set_mode";
+                readonly requestType: import("./VehicleLifecycle").MessageFns<import("./VehicleLifecycle").SetModeRequest>;
+                readonly requestStream: false;
+                readonly responseType: import("./VehicleLifecycle").MessageFns<import("./VehicleLifecycle").SetModeResponse>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
+            readonly emergency_stop: {
+                readonly name: "emergency_stop";
+                readonly requestType: import("./VehicleLifecycle").MessageFns<import("./VehicleLifecycle").EmergencyStopRequest>;
+                readonly requestStream: false;
+                readonly responseType: import("./VehicleLifecycle").MessageFns<import("./VehicleLifecycle").EmergencyStopResponse>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
+        };
+    };
+    readonly "vehicle_mission/v1": {
+        readonly name: "VehicleMission";
+        readonly fullName: "keelson.interfaces.vehicle_mission.VehicleMission";
+        readonly methods: {
+            readonly upload_mission: {
+                readonly name: "upload_mission";
+                readonly requestType: import("./Mission").MessageFns<import("./Mission").Mission>;
+                readonly requestStream: false;
+                readonly responseType: import("./VehicleMission").MessageFns<import("./VehicleMission").MissionUploadResponse>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
+            readonly download_mission: {
+                readonly name: "download_mission";
+                readonly requestType: import("./google/protobuf/empty").MessageFns<import("./google/protobuf/empty").Empty>;
+                readonly requestStream: false;
+                readonly responseType: import("./Mission").MessageFns<import("./Mission").Mission>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
+            readonly clear_mission: {
+                readonly name: "clear_mission";
+                readonly requestType: import("./VehicleMission").MessageFns<import("./VehicleMission").ClearMissionRequest>;
+                readonly requestStream: false;
+                readonly responseType: import("./VehicleMission").MessageFns<import("./VehicleMission").ClearMissionResponse>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
+            readonly set_current_waypoint: {
+                readonly name: "set_current_waypoint";
+                readonly requestType: import("./VehicleMission").MessageFns<import("./VehicleMission").SetCurrentWaypointRequest>;
+                readonly requestStream: false;
+                readonly responseType: import("./VehicleMission").MessageFns<import("./VehicleMission").SetCurrentWaypointResponse>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
+        };
+    };
+    readonly "vehicle_navigation/v1": {
+        readonly name: "VehicleNavigation";
+        readonly fullName: "keelson.interfaces.vehicle_navigation.VehicleNavigation";
+        readonly methods: {
+            readonly set_navigation_target: {
+                readonly name: "set_navigation_target";
+                readonly requestType: import("./VehicleNavigation").MessageFns<import("./VehicleNavigation").NavigationTarget>;
+                readonly requestStream: false;
+                readonly responseType: import("./VehicleNavigation").MessageFns<import("./VehicleNavigation").NavigationTargetResponse>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
+            readonly set_cruise_speed: {
+                readonly name: "set_cruise_speed";
+                readonly requestType: import("./VehicleNavigation").MessageFns<import("./VehicleNavigation").SetCruiseSpeedRequest>;
+                readonly requestStream: false;
+                readonly responseType: import("./VehicleNavigation").MessageFns<import("./VehicleNavigation").SetCruiseSpeedResponse>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
+        };
+    };
+    readonly "vehicle_param/v1": {
+        readonly name: "VehicleParam";
+        readonly fullName: "keelson.interfaces.vehicle_param.VehicleParam";
+        readonly methods: {
+            readonly get_param: {
+                readonly name: "get_param";
+                readonly requestType: import("./VehicleParam").MessageFns<import("./VehicleParam").ParamGetRequest>;
+                readonly requestStream: false;
+                readonly responseType: import("./VehicleParam").MessageFns<import("./VehicleParam").ParamValueResponse>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
+            readonly set_param: {
+                readonly name: "set_param";
+                readonly requestType: import("./VehicleParam").MessageFns<import("./VehicleParam").ParamSetRequest>;
+                readonly requestStream: false;
+                readonly responseType: import("./VehicleParam").MessageFns<import("./VehicleParam").ParamValueResponse>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
+            readonly list_params: {
+                readonly name: "list_params";
+                readonly requestType: import("./google/protobuf/empty").MessageFns<import("./google/protobuf/empty").Empty>;
+                readonly requestStream: false;
+                readonly responseType: import("./VehicleParam").MessageFns<import("./VehicleParam").ParamListResponse>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
+            readonly set_params: {
+                readonly name: "set_params";
+                readonly requestType: import("./VehicleParam").MessageFns<import("./VehicleParam").ParamSetBulkRequest>;
+                readonly requestStream: false;
+                readonly responseType: import("./VehicleParam").MessageFns<import("./VehicleParam").ParamSetBulkResponse>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
+            readonly save_params: {
+                readonly name: "save_params";
+                readonly requestType: import("./VehicleParam").MessageFns<import("./VehicleParam").SaveParamsRequest>;
+                readonly requestStream: false;
+                readonly responseType: import("./VehicleParam").MessageFns<import("./VehicleParam").SaveParamsResponse>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
+        };
+    };
+    readonly "vehicle_simulator_control/v1": {
+        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("./VehicleSimulatorControl").MessageFns<import("./VehicleSimulatorControl").InitialPose>;
+                readonly requestStream: false;
+                readonly responseType: import("./VehicleSimulatorControl").MessageFns<import("./VehicleSimulatorControl").SetInitialPoseResponse>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
+        };
+    };
+    readonly "whep_proxy/v1": {
+        readonly name: "WHEPProxy";
+        readonly fullName: "keelson.interfaces.whep_proxy.WHEPProxy";
+        readonly methods: {
+            readonly whep_signal: {
+                readonly name: "whep_signal";
+                readonly requestType: import("./WHEPProxy").MessageFns<import("./WHEPProxy").WHEPRequest>;
+                readonly requestStream: false;
+                readonly responseType: import("./WHEPProxy").MessageFns<import("./WHEPProxy").WHEPResponse>;
+                readonly responseStream: false;
+                readonly options: {};
+            };
+        };
+    };
+};

package/dist/interfaces/serviceRegistry.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serviceDefinitions = void 0;
+// Generated by generate_javascript.sh - DO NOT EDIT.
+const Configurable_1 = require("./Configurable");
+const MavlinkCommand_1 = require("./MavlinkCommand");
+const NetworkPingPong_1 = require("./NetworkPingPong");
+const ReplayControl_1 = require("./ReplayControl");
+const RoutePlanner_1 = require("./RoutePlanner");
+const ScenarioCheckpoint_1 = require("./ScenarioCheckpoint");
+const ScenarioControl_1 = require("./ScenarioControl");
+const SimulationControl_1 = require("./SimulationControl");
+const Subscriber_1 = require("./Subscriber");
+const VehicleControl_1 = require("./VehicleControl");
+const VehicleGeofence_1 = require("./VehicleGeofence");
+const VehicleLifecycle_1 = require("./VehicleLifecycle");
+const VehicleMission_1 = require("./VehicleMission");
+const VehicleNavigation_1 = require("./VehicleNavigation");
+const VehicleParam_1 = require("./VehicleParam");
+const VehicleSimulatorControl_1 = require("./VehicleSimulatorControl");
+const WHEPProxy_1 = require("./WHEPProxy");
+exports.serviceDefinitions = {
+    "configurable/v1": Configurable_1.ConfigurableDefinition,
+    "mavlink_command/v1": MavlinkCommand_1.MavlinkCommandDefinition,
+    "network_ping_pong/v1": NetworkPingPong_1.NetworkPingPongDefinition,
+    "replay_control/v1": ReplayControl_1.ReplayControlDefinition,
+    "route_planner/v1": RoutePlanner_1.RoutePlannerDefinition,
+    "scenario_checkpoint/v1": ScenarioCheckpoint_1.ScenarioCheckpointDefinition,
+    "scenario_control/v1": ScenarioControl_1.ScenarioControlDefinition,
+    "simulation_control/v1": SimulationControl_1.SimulationControlDefinition,
+    "subscriber/v1": Subscriber_1.SubscriberDefinition,
+    "vehicle_control/v1": VehicleControl_1.VehicleControlDefinition,
+    "vehicle_geofence/v1": VehicleGeofence_1.VehicleGeofenceDefinition,
+    "vehicle_lifecycle/v1": VehicleLifecycle_1.VehicleLifecycleDefinition,
+    "vehicle_mission/v1": VehicleMission_1.VehicleMissionDefinition,
+    "vehicle_navigation/v1": VehicleNavigation_1.VehicleNavigationDefinition,
+    "vehicle_param/v1": VehicleParam_1.VehicleParamDefinition,
+    "vehicle_simulator_control/v1": VehicleSimulatorControl_1.VehicleSimulatorControlDefinition,
+    "whep_proxy/v1": WHEPProxy_1.WHEPProxyDefinition,
+};

package/dist/interfaces.json

@@ -0,0 +1,19 @@
+{
+    "configurable/v1": "keelson.interfaces.configurable.Configurable",
+    "mavlink_command/v1": "keelson.interfaces.mavlink_command.MavlinkCommand",
+    "network_ping_pong/v1": "keelson.interfaces.network_ping_pong.NetworkPingPong",
+    "replay_control/v1": "keelson.interfaces.replay_control.ReplayControl",
+    "route_planner/v1": "keelson.interfaces.route_planner.RoutePlanner",
+    "scenario_checkpoint/v1": "keelson.interfaces.scenario_checkpoint.ScenarioCheckpoint",
+    "scenario_control/v1": "keelson.interfaces.scenario_control.ScenarioControl",
+    "simulation_control/v1": "keelson.interfaces.simulation_control.SimulationControl",
+    "subscriber/v1": "keelson.interfaces.subscriber.Subscriber",
+    "vehicle_control/v1": "keelson.interfaces.vehicle_control.VehicleControl",
+    "vehicle_geofence/v1": "keelson.interfaces.vehicle_geofence.VehicleGeofence",
+    "vehicle_lifecycle/v1": "keelson.interfaces.vehicle_lifecycle.VehicleLifecycle",
+    "vehicle_mission/v1": "keelson.interfaces.vehicle_mission.VehicleMission",
+    "vehicle_navigation/v1": "keelson.interfaces.vehicle_navigation.VehicleNavigation",
+    "vehicle_param/v1": "keelson.interfaces.vehicle_param.VehicleParam",
+    "vehicle_simulator_control/v1": "keelson.interfaces.vehicle_simulator_control.VehicleSimulatorControl",
+    "whep_proxy/v1": "keelson.interfaces.whep_proxy.WHEPProxy"
+}

package/dist/payloads/Alarm.d.ts

@@ -1,5 +1,6 @@
 import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
 import { Audio } from "./Audio";
+import { SeverityLevel } from "./Severity";
 import { CompressedImage } from "./foxglove/CompressedImage";
 import { CompressedVideo } from "./foxglove/CompressedVideo";
 import { RawImage } from "./foxglove/RawImage";
@@ -36,8 +37,12 @@ export interface Alarm {
     durationSeconds: number;
     /** The acknowledgment scheme for the alarm. */
     ackScheme: Alarm_AckScheme;
-    /** The severity level of the alarm. */
-    severity: Alarm_Severity;
+    /**
+     * The severity level of the alarm. Shared vocabulary from
+     * Severity.proto; wire values are unchanged from the previous nested
+     * enum (LOW=1, MEDIUM=2, HIGH=3, CRITICAL=4).
+     */
+    severity: SeverityLevel;
     /** Indicates if the alarm has been acknowledged. */
     acknowledged: boolean;
 }
@@ -70,16 +75,6 @@ export declare enum Alarm_AckScheme {
 }
 export declare function alarm_AckSchemeFromJSON(object: any): Alarm_AckScheme;
 export declare function alarm_AckSchemeToJSON(object: Alarm_AckScheme): string;
-export declare enum Alarm_Severity {
-    SEVERITY_UNSPECIFIED = 0,
-    SEVERITY_LOW = 1,
-    SEVERITY_MEDIUM = 2,
-    SEVERITY_HIGH = 3,
-    SEVERITY_CRITICAL = 4,
-    UNRECOGNIZED = -1
-}
-export declare function alarm_SeverityFromJSON(object: any): Alarm_Severity;
-export declare function alarm_SeverityToJSON(object: Alarm_Severity): string;
 export interface AlarmAcknowledgment {
     $type: "keelson.AlarmAcknowledgment";
     timestampAcknowledged: Date | undefined;