rclnodejs 1.7.0 → 1.8.0

package/src/rcl_timer_bindings.cpp

@@ -17,12 +17,48 @@
 #include <rcl/error_handling.h>
 #include <rcl/rcl.h>
 
+#include <memory>
+#include <mutex>
+#include <unordered_map>
+
 #include "macros.h"
 #include "rcl_handle.h"
 #include "rcl_utilities.h"
 
 namespace rclnodejs {
 
+struct TimerContext {
+  Napi::ThreadSafeFunction on_reset_callback;
+};
+
+static std::unordered_map<rcl_timer_t*, std::shared_ptr<TimerContext>>
+    g_timer_contexts;
+static std::mutex g_timer_contexts_mutex;
+
+void TimerOnResetCallbackTrampoline(const void* user_data,
+                                    size_t number_of_events) {
+  const rcl_timer_t* timer = static_cast<const rcl_timer_t*>(user_data);
+  std::shared_ptr<TimerContext> context;
+
+  {
+    std::lock_guard<std::mutex> lock(g_timer_contexts_mutex);
+    auto it = g_timer_contexts.find(const_cast<rcl_timer_t*>(timer));
+    if (it != g_timer_contexts.end()) {
+      context = it->second;
+    }
+  }
+
+  if (context) {
+    auto callback = [](Napi::Env env, Napi::Function js_callback,
+                       size_t* events) {
+      js_callback.Call({Napi::Number::New(env, *events)});
+      delete events;
+    };
+    size_t* events_ptr = new size_t(number_of_events);
+    context->on_reset_callback.BlockingCall(events_ptr, callback);
+  }
+}
+
 Napi::Value CreateTimer(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
 
@@ -61,6 +97,30 @@ Napi::Value CreateTimer(const Napi::CallbackInfo& info) {
   auto js_obj =
       RclHandle::NewInstance(env, timer, clock_handle, [env](void* ptr) {
         rcl_timer_t* timer = reinterpret_cast<rcl_timer_t*>(ptr);
+
+#if ROS_VERSION > 2205
+        // Clear the callback first to prevent any new callbacks from being
+        // triggered
+        rcl_ret_t callback_ret =
+            rcl_timer_set_on_reset_callback(timer, nullptr, nullptr);
+        THROW_ERROR_IF_NOT_EQUAL_NO_RETURN(RCL_RET_OK, callback_ret,
+                                           rcl_get_error_string().str);
+#endif
+
+        std::shared_ptr<TimerContext> context;
+        {
+          std::lock_guard<std::mutex> lock(g_timer_contexts_mutex);
+          auto it = g_timer_contexts.find(timer);
+          if (it != g_timer_contexts.end()) {
+            context = it->second;
+            g_timer_contexts.erase(it);
+          }
+        }
+
+        if (context) {
+          context->on_reset_callback.Release();
+        }
+
         rcl_ret_t ret = rcl_timer_fini(timer);
         free(ptr);
         THROW_ERROR_IF_NOT_EQUAL_NO_RETURN(RCL_RET_OK, ret,
@@ -197,6 +257,26 @@ Napi::Value GetTimerPeriod(const Napi::CallbackInfo& info) {
   return Napi::BigInt::New(env, period_nsec);
 }
 
+#if ROS_VERSION > 2205  // 2205 == Humble
+Napi::Value GetTimerNextCallTime(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  RclHandle* timer_handle = RclHandle::Unwrap(info[0].As<Napi::Object>());
+  rcl_timer_t* timer = reinterpret_cast<rcl_timer_t*>(timer_handle->ptr());
+  int64_t next_call_time = 0;
+
+  rcl_ret_t ret = rcl_timer_get_next_call_time(timer, &next_call_time);
+
+  if (ret == RCL_RET_OK) {
+    return Napi::BigInt::New(env, next_call_time);
+  } else if (ret == RCL_RET_TIMER_CANCELED) {
+    return env.Null();
+  } else {
+    THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK, ret, rcl_get_error_string().str);
+    return env.Undefined();  // Safeguard return, should not reach here
+  }
+}
+#endif
+
 #if ROS_VERSION > 2205  // 2205 == Humble
 Napi::Value CallTimerWithInfo(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
@@ -215,6 +295,60 @@ Napi::Value CallTimerWithInfo(const Napi::CallbackInfo& info) {
                  Napi::BigInt::New(env, call_info.actual_call_time));
   return timer_info;
 }
+
+Napi::Value SetTimerOnResetCallback(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  RclHandle* timer_handle = RclHandle::Unwrap(info[0].As<Napi::Object>());
+  rcl_timer_t* timer = reinterpret_cast<rcl_timer_t*>(timer_handle->ptr());
+
+  if (!info[1].IsFunction()) {
+    Napi::TypeError::New(env, "Callback must be a function")
+        .ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  Napi::Function callback = info[1].As<Napi::Function>();
+
+  std::lock_guard<std::mutex> lock(g_timer_contexts_mutex);
+  std::shared_ptr<TimerContext> context;
+  auto it = g_timer_contexts.find(timer);
+  if (it == g_timer_contexts.end()) {
+    context = std::make_shared<TimerContext>();
+    g_timer_contexts[timer] = context;
+  } else {
+    context = it->second;
+    context->on_reset_callback.Release();
+  }
+
+  context->on_reset_callback = Napi::ThreadSafeFunction::New(
+      env, callback, "TimerOnResetCallback", 0, 1);
+
+  THROW_ERROR_IF_NOT_EQUAL(RCL_RET_OK,
+                           rcl_timer_set_on_reset_callback(
+                               timer, TimerOnResetCallbackTrampoline, timer),
+                           rcl_get_error_string().str);
+
+  return env.Undefined();
+}
+
+Napi::Value ClearTimerOnResetCallback(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  RclHandle* timer_handle = RclHandle::Unwrap(info[0].As<Napi::Object>());
+  rcl_timer_t* timer = reinterpret_cast<rcl_timer_t*>(timer_handle->ptr());
+
+  std::lock_guard<std::mutex> lock(g_timer_contexts_mutex);
+  auto it = g_timer_contexts.find(timer);
+  if (it != g_timer_contexts.end()) {
+    it->second->on_reset_callback.Release();
+    g_timer_contexts.erase(it);
+  }
+
+  THROW_ERROR_IF_NOT_EQUAL(
+      RCL_RET_OK, rcl_timer_set_on_reset_callback(timer, nullptr, nullptr),
+      rcl_get_error_string().str);
+
+  return env.Undefined();
+}
 #endif
 
 Napi::Object InitTimerBindings(Napi::Env env, Napi::Object exports) {
@@ -231,6 +365,12 @@ Napi::Object InitTimerBindings(Napi::Env env, Napi::Object exports) {
   exports.Set("changeTimerPeriod", Napi::Function::New(env, ChangeTimerPeriod));
   exports.Set("getTimerPeriod", Napi::Function::New(env, GetTimerPeriod));
 #if ROS_VERSION > 2205  // 2205 == Humble
+  exports.Set("getTimerNextCallTime",
+              Napi::Function::New(env, GetTimerNextCallTime));
+  exports.Set("setTimerOnResetCallback",
+              Napi::Function::New(env, SetTimerOnResetCallback));
+  exports.Set("clearTimerOnResetCallback",
+              Napi::Function::New(env, ClearTimerOnResetCallback));
   exports.Set("callTimerWithInfo", Napi::Function::New(env, CallTimerWithInfo));
 #endif
   return exports;

package/src/rcl_utilities.cpp

@@ -21,6 +21,8 @@
 
 #include <cstdio>
 #include <memory>
+#include <rcpputils/scope_exit.hpp>
+// NOLINTNEXTLINE
 #include <string>
 
 namespace {
@@ -55,6 +57,7 @@ std::unique_ptr<rmw_qos_profile_t> GetQosProfileFromObject(
   auto depth = object.Get("depth");
   auto reliability = object.Get("reliability");
   auto durability = object.Get("durability");
+  auto liveliness = object.Get("liveliness");
   auto avoid_ros_namespace_conventions =
       object.Get("avoidRosNameSpaceConventions");
 
@@ -65,6 +68,8 @@ std::unique_ptr<rmw_qos_profile_t> GetQosProfileFromObject(
       reliability.As<Napi::Number>().Uint32Value());
   qos_profile->durability = static_cast<rmw_qos_durability_policy_t>(
       durability.As<Napi::Number>().Uint32Value());
+  qos_profile->liveliness = static_cast<rmw_qos_liveliness_policy_t>(
+      liveliness.As<Napi::Number>().Uint32Value());
   qos_profile->avoid_ros_namespace_conventions =
       avoid_ros_namespace_conventions.As<Napi::Boolean>();
 
@@ -119,6 +124,48 @@ Napi::Value ConvertToJSTopicEndpoint(
   return endpoint;
 }
 
+#if ROS_VERSION > 2505
+Napi::Value ConvertToJSServiceEndpointInfo(
+    Napi::Env env, const rmw_service_endpoint_info_t* service_endpoint_info) {
+  Napi::Object endpoint = Napi::Object::New(env);
+  endpoint.Set("node_name",
+               Napi::String::New(env, service_endpoint_info->node_name));
+  endpoint.Set("node_namespace",
+               Napi::String::New(env, service_endpoint_info->node_namespace));
+  endpoint.Set("service_type",
+               Napi::String::New(env, service_endpoint_info->service_type));
+  endpoint.Set(
+      "service_type_hash",
+      ConvertToHashObject(env, &service_endpoint_info->service_type_hash));
+  endpoint.Set(
+      "endpoint_type",
+      Napi::Number::New(
+          env, static_cast<int>(service_endpoint_info->endpoint_type)));
+  endpoint.Set("endpoint_count",
+               Napi::Number::New(env, service_endpoint_info->endpoint_count));
+
+  Napi::Array endpoint_gids =
+      Napi::Array::New(env, service_endpoint_info->endpoint_count);
+  Napi::Array qos_profiles =
+      Napi::Array::New(env, service_endpoint_info->endpoint_count);
+
+  for (size_t i = 0; i < service_endpoint_info->endpoint_count; i++) {
+    Napi::Array gid = Napi::Array::New(env, RMW_GID_STORAGE_SIZE);
+    for (size_t j = 0; j < RMW_GID_STORAGE_SIZE; j++) {
+      gid.Set(j, Napi::Number::New(env,
+                                   service_endpoint_info->endpoint_gids[i][j]));
+    }
+    endpoint_gids.Set(i, gid);
+    qos_profiles.Set(i, rclnodejs::ConvertToQoS(
+                            env, &service_endpoint_info->qos_profiles[i]));
+  }
+  endpoint.Set("endpoint_gids", endpoint_gids);
+  endpoint.Set("qos_profiles", qos_profiles);
+
+  return endpoint;
+}
+#endif  // ROS_VERSION > 2505
+
 uv_lib_t g_lib;
 Napi::Env g_env = nullptr;
 
@@ -261,6 +308,19 @@ Napi::Array ConvertToJSTopicEndpointInfoList(
   return list;
 }
 
+#if ROS_VERSION > 2505
+Napi::Array ConvertToJSServiceEndpointInfoList(
+    Napi::Env env, const rmw_service_endpoint_info_array_t* info_array) {
+  Napi::Array list = Napi::Array::New(env, info_array->size);
+  for (size_t i = 0; i < info_array->size; ++i) {
+    rmw_service_endpoint_info_t service_endpoint_info =
+        info_array->info_array[i];
+    list.Set(i, ConvertToJSServiceEndpointInfo(env, &service_endpoint_info));
+  }
+  return list;
+}
+#endif  // ROS_VERSION > 2505
+
 char** AbstractArgsFromNapiArray(const Napi::Array& jsArgv) {
   size_t argc = jsArgv.Length();
   char** argv = nullptr;
@@ -286,9 +346,50 @@ void FreeArgs(char** argv, size_t argc) {
   }
 }
 
-bool HasUnparsedROSArgs(const rcl_arguments_t& rcl_args) {
+void ThrowIfUnparsedROSArgs(Napi::Env env, const Napi::Array& jsArgv,
+                            const rcl_arguments_t& rcl_args) {
   int unparsed_ros_args_count = rcl_arguments_get_count_unparsed_ros(&rcl_args);
-  return unparsed_ros_args_count != 0;
+
+  if (unparsed_ros_args_count < 0) {
+    Napi::Error::New(env, "Failed to count unparsed arguments")
+        .ThrowAsJavaScriptException();
+    return;
+  }
+  if (0 == unparsed_ros_args_count) {
+    return;
+  }
+
+  rcl_allocator_t allocator = rcl_get_default_allocator();
+  int* unparsed_indices_c = nullptr;
+  rcl_ret_t ret =
+      rcl_arguments_get_unparsed_ros(&rcl_args, allocator, &unparsed_indices_c);
+  if (RCL_RET_OK != ret) {
+    Napi::Error::New(env, "Failed to get unparsed arguments")
+        .ThrowAsJavaScriptException();
+    return;
+  }
+
+  RCPPUTILS_SCOPE_EXIT(
+      { allocator.deallocate(unparsed_indices_c, allocator.state); });
+
+  std::string unparsed_args_str = "[";
+  for (int i = 0; i < unparsed_ros_args_count; ++i) {
+    int index = unparsed_indices_c[i];
+    if (index < 0 || static_cast<size_t>(index) >= jsArgv.Length()) {
+      Napi::Error::New(env, "Got invalid unparsed ROS arg index")
+          .ThrowAsJavaScriptException();
+      return;
+    }
+    std::string arg = jsArgv.Get(index).As<Napi::String>().Utf8Value();
+    unparsed_args_str += "'" + arg + "'";
+    if (i < unparsed_ros_args_count - 1) {
+      unparsed_args_str += ", ";
+    }
+  }
+  unparsed_args_str += "]";
+
+  Napi::Error::New(env, "Unknown ROS arguments: " + unparsed_args_str)
+      .ThrowAsJavaScriptException();
 }
 
 }  // namespace rclnodejs

package/src/rcl_utilities.h

@@ -51,6 +51,11 @@ void ExtractNamesAndTypes(rcl_names_and_types_t names_and_types,
 Napi::Array ConvertToJSTopicEndpointInfoList(
     Napi::Env env, const rmw_topic_endpoint_info_array_t* info_array);
 
+#if ROS_VERSION > 2505
+Napi::Array ConvertToJSServiceEndpointInfoList(
+    Napi::Env env, const rmw_service_endpoint_info_array_t* info_array);
+#endif  // ROS_VERSION > 2505
+
 Napi::Value ConvertToQoS(Napi::Env env, const rmw_qos_profile_t* qos_profile);
 
 // `AbstractArgsFromNapiArray` and `FreeArgs` must be called in pairs.
@@ -58,7 +63,8 @@ char** AbstractArgsFromNapiArray(const Napi::Array& jsArgv);
 // `AbstractArgsFromNapiArray` and `FreeArgs` must be called in pairs.
 void FreeArgs(char** argv, size_t argc);
 
-bool HasUnparsedROSArgs(const rcl_arguments_t& rcl_args);
+void ThrowIfUnparsedROSArgs(Napi::Env env, const Napi::Array& jsArgv,
+                            const rcl_arguments_t& rcl_args);
 
 }  // namespace rclnodejs
 

package/types/action_client.d.ts

@@ -115,6 +115,14 @@ declare module 'rclnodejs' {
     statusSubQosProfile?: QoS | QoS.ProfileRef;
   }
 
+  /**
+   * Options for sending a goal
+   */
+  interface SendGoalOptions {
+    /** Override validateGoals setting for this call */
+    validate?: boolean;
+  }
+
   /**
    * ROS Action client.
    */
@@ -131,9 +139,23 @@ declare module 'rclnodejs' {
       node: Node,
       typeClass: T,
       actionName: string,
-      options?: Options<ActionQoS>
+      options?: Options<ActionQoS> & {
+        validateGoals?: boolean;
+        validationOptions?: MessageValidationOptions;
+      }
     );
 
+    /**
+     * Whether goals will be validated before sending.
+     */
+    willValidateGoal: boolean;
+
+    /**
+     * Set validation options for this action client.
+     * @param options - Validation options
+     */
+    setValidation(options: MessageValidationOptions): void;
+
     /**
      * Send a goal and wait for the goal ACK asynchronously.
      *
@@ -143,12 +165,15 @@ declare module 'rclnodejs' {
      * @param goal - The goal request.
      * @param feedbackCallback - Callback function for feedback associated with the goal.
      * @param goalUuid - Universally unique identifier for the goal. If None, then a random UUID is generated.
+     * @param options - Send options (e.g., { validate: true })
      * @returns A Promise to a goal handle that resolves when the goal request has been accepted or rejected.
+     * @throws MessageValidationError if validation is enabled and goal is invalid
      */
     sendGoal(
       goal: ActionGoal<T>,
       feedbackCallback?: (feedbackMessage: ActionFeedback<T>) => void,
-      goalUuid?: unique_identifier_msgs.msg.UUID
+      goalUuid?: unique_identifier_msgs.msg.UUID,
+      options?: SendGoalOptions
     ): Promise<ClientGoalHandle<T>>;
 
     /**

package/types/base.d.ts

@@ -14,6 +14,7 @@
 /// <reference path="./lifecycle.d.ts" />
 /// <reference path="./lifecycle_publisher.d.ts" />
 /// <reference path="./logging.d.ts" />
+/// <reference path="./message_introspector.d.ts" />
 /// <reference path="./node.d.ts" />
 /// <reference path="./node_options.d.ts" />
 /// <reference path="./parameter.d.ts" />
@@ -25,6 +26,8 @@
 /// <reference path="./service.d.ts" />
 /// <reference path="./service_introspection.d.ts" />
 /// <reference path="./subscription.d.ts" />
+/// <reference path="./observable_subscription.d.ts" />
 /// <reference path="./time_source.d.ts" />
 /// <reference path="./time.d.ts" />
 /// <reference path="./timer.d.ts" />
+/// <reference path="./validator.d.ts" />

package/types/client.d.ts

@@ -1,17 +1,39 @@
 declare module 'rclnodejs' {
+  /**
+   * Options for sending a request
+   */
+  interface SendRequestOptions {
+    /** Override validateRequests setting for this call */
+    validate?: boolean;
+  }
+
   /**
    * A ROS service client.
    */
   interface Client<T extends TypeClass<ServiceTypeClassName>> extends Entity {
+    /**
+     * Whether requests will be validated before sending.
+     */
+    willValidateRequest: boolean;
+
+    /**
+     * Set validation options for this client.
+     * @param options - Validation options
+     */
+    setValidation(options: MessageValidationOptions): void;
+
     /**
      * Make a service request and wait for to be notified asynchronously through a callback.
      *
      * @param request - Request to be submitted.
      * @param callback - Callback for receiving the server response.
+     * @param options - Send options (e.g., { validate: true })
+     * @throws MessageValidationError if validation is enabled and request is invalid
      */
     sendRequest(
       request: ServiceRequestMessage<T>,
-      callback: Client.ResponseCallback<T>
+      callback: Client.ResponseCallback<T>,
+      options?: SendRequestOptions
     ): void;
 
     /**
@@ -22,6 +44,7 @@ declare module 'rclnodejs' {
      * @returns Promise that resolves with the service response.
      * @throws TimeoutError if the request times out (when options.timeout is exceeded).
      * @throws AbortError if the request is manually aborted (via options.signal).
+     * @throws MessageValidationError if validation is enabled and request is invalid.
      * @throws Error if the request fails for other reasons.
      */
     sendRequestAsync(
@@ -109,6 +132,11 @@ declare module 'rclnodejs' {
        * will abort the request.
        */
       signal?: AbortSignal;
+
+      /**
+       * Override validateRequests setting for this call
+       */
+      validate?: boolean;
     }
   }
 }

package/types/clock.d.ts

@@ -1,4 +1,35 @@
 declare module 'rclnodejs' {
+  /**
+   * Jump information provided to clock jump callbacks.
+   */
+  interface ClockJumpInfo {
+    /**
+     * Type of clock change that occurred.
+     */
+    clock_change: ClockChange;
+
+    /**
+     * Time delta in nanoseconds.
+     */
+    delta: bigint;
+  }
+
+  /**
+   * Callback object for clock jump events.
+   */
+  interface ClockCallbackObject {
+    /**
+     * Optional callback invoked before a time jump.
+     */
+    _pre_callback?: () => void;
+
+    /**
+     * Optional callback invoked after a time jump.
+     * @param jumpInfo - Information about the time jump.
+     */
+    _post_callback?: (jumpInfo: ClockJumpInfo) => void;
+  }
+
   /**
    * A ROS Clock.
    */
@@ -17,12 +48,67 @@ declare module 'rclnodejs' {
      */
     readonly clockType: ClockType;
 
+    /**
+     * Add a clock callback.
+     * @param callbackObject - The object containing callback methods.
+     * @param onClockChange - Whether to call the callback on clock change.
+     * @param minForward - Minimum forward jump in nanoseconds to trigger the callback.
+     * @param minBackward - Minimum backward jump in nanoseconds to trigger the callback.
+     */
+    addClockCallback(
+      callbackObject: ClockCallbackObject,
+      onClockChange: boolean,
+      minForward: bigint,
+      minBackward: bigint
+    ): void;
+
+    /**
+     * Remove a clock callback.
+     * @param callbackObject - The callback object that was previously registered with addClockCallback().
+     */
+    removeClockCallback(callbackObject: ClockCallbackObject): void;
+
     /**
      * Return the current time.
      *
      * @returns The current time.
      */
     now(): Time;
+
+    /**
+     * Sleep until a specific time is reached on this Clock.
+     *
+     * When using a ROSClock, this may sleep forever if the TimeSource is misconfigured
+     * and the context is never shut down. ROS time being activated or deactivated causes
+     * this function to cease sleeping and return false.
+     *
+     * @param until - Time at which this function should stop sleeping.
+     * @param context - Context which when shut down will cause this sleep to wake early.
+     *   If context is null or undefined, then the default context is used.
+     * @returns Promise that resolves to true if 'until' was reached,
+     *   or false if it woke for another reason (time jump, context shutdown).
+     * @throws {TypeError} if until is specified for a different type of clock than this one.
+     * @throws {Error} if context has not been initialized or is shutdown.
+     */
+    sleepUntil(until: Time, context?: Context | null): Promise<boolean>;
+
+    /**
+     * Sleep for a specified duration.
+     *
+     * Equivalent to: clock.sleepUntil(clock.now() + duration, context)
+     *
+     * When using a ROSClock, this may sleep forever if the TimeSource is misconfigured
+     * and the context is never shut down. ROS time being activated or deactivated causes
+     * this function to cease sleeping and return false.
+     *
+     * @param duration - Duration of time to sleep for.
+     * @param context - Context which when shut down will cause this sleep to wake early.
+     *   If context is null or undefined, then the default context is used.
+     * @returns Promise that resolves to true if the full duration was slept,
+     *   or false if it woke for another reason.
+     * @throws {Error} if context has not been initialized or is shutdown.
+     */
+    sleepFor(duration: Duration, context?: Context | null): Promise<boolean>;
   }
 
   /**

package/types/clock_change.d.ts

@@ -0,0 +1,27 @@
+declare module 'rclnodejs' {
+  /**
+   * Clock change type identifiers
+   * Represents the type of clock change that occurred during a time jump.
+   */
+  enum ClockChange {
+    /**
+     * The source before and after the jump is ROS_TIME.
+     */
+    ROS_TIME_NO_CHANGE = 1,
+
+    /**
+     * The source switched to ROS_TIME from SYSTEM_TIME.
+     */
+    ROS_TIME_ACTIVATED = 2,
+
+    /**
+     * The source switched to SYSTEM_TIME from ROS_TIME.
+     */
+    ROS_TIME_DEACTIVATED = 3,
+
+    /**
+     * The source before and after the jump is SYSTEM_TIME.
+     */
+    SYSTEM_TIME_NO_CHANGE = 4,
+  }
+}

package/types/clock_event.d.ts

@@ -0,0 +1,51 @@
+declare module 'rclnodejs' {
+  /**
+   * Class representing a ClockEvent in ROS
+   */
+  class ClockEvent {
+    /**
+     * Create a ClockEvent.
+     */
+    constructor();
+
+    /**
+     * Wait until a time specified by a steady clock.
+     * @param clock - The clock to use for time synchronization.
+     * @param until - The time to wait until.
+     * @returns A promise that resolves when the time is reached.
+     */
+    waitUntilSteady(clock: Clock, until: bigint): Promise<void>;
+
+    /**
+     * Wait until a time specified by a system clock.
+     * @param clock - The clock to use for time synchronization.
+     * @param until - The time to wait until.
+     * @returns A promise that resolves when the time is reached.
+     */
+    waitUntilSystem(clock: Clock, until: bigint): Promise<void>;
+
+    /**
+     * Wait until a time specified by a ROS clock.
+     * @param clock - The clock to use for time synchronization.
+     * @param until - The time to wait until.
+     * @returns A promise that resolves when the time is reached.
+     */
+    waitUntilRos(clock: Clock, until: bigint): Promise<void>;
+
+    /**
+     * Indicate if the ClockEvent is set.
+     * @returns True if the ClockEvent is set.
+     */
+    isSet(): boolean;
+
+    /**
+     * Set the event.
+     */
+    set(): void;
+
+    /**
+     * Clear the event.
+     */
+    clear(): void;
+  }
+}