nros_generated.h

Go to the documentation of this file.

 
#include <stdarg.h>
#include <stdbool.h>
#include <stdint.h>
#include <stddef.h>
 
#include "rclc/visibility_control.h"
#include "rclc/detail/nros_config_generated.h"
/* issue 2081 — `rmw_request_id_t`, hand-written under the guard the RMW ABI
 * and rclcpp share; excluded from export below. */
#include "rclc/detail/request_id.h"
/* phase-515 C4b — `unique_identifier_msgs__msg__UUID`, the goal id of an rclc
 * goal handle, declared under the guard the generated message shares;
 * excluded from export below. */
#include "rclc/detail/uuid.h"
 
/* Forward declarations for callback typedefs that reference these
 * structs before they appear in source-order output. Without these,
 * gcc treats `struct rcl_timer_t *` inside a callback parameter list
 * as a parameter-local incomplete type that doesn't match the later
 * file-scope struct definition. */
#ifdef __cplusplus
extern "C" {
#endif
struct rclc_executor_t;
struct rcl_node_t;
struct rcl_publisher_t;
struct rcl_subscription_t;
struct rcl_service_t;
struct rcl_client_t;
struct rcl_timer_t;
struct rcl_guard_condition_t;
struct rcl_action_server_t;
struct rcl_action_client_t;
struct rcl_lifecycle_state_machine_t;
struct rclc_support_t;
struct rcl_clock_t;
struct rclc_goal_handle_t;
struct rclc_goal_uuid_t;
#ifdef __cplusplus
}
#endif
 
 
#ifndef NROS_GENERATED_H
#define NROS_GENERATED_H
 
/* Warning: this file is autogenerated. Don't modify this manually. */

#define NROS_MAX_LOCATOR_LEN 128

#define NROS_MAX_NAME_LEN 64

#define NROS_MAX_NAMESPACE_LEN 128

#define MAX_RMW_NAME_LEN 32

#define NROS_MAX_TOPIC_LEN 256

#define NROS_MAX_SERVICE_NAME_LEN 256

#define NROS_MAX_ACTION_NAME_LEN 256

#define NROS_MAX_TYPE_NAME_LEN 256

#define NROS_MAX_TYPE_HASH_LEN 128

#define NROS_MAX_CONCURRENT_GOALS 4

#define NROS_SERIALIZATION_FORMAT_ID 1

#define RCUTILS_ERROR_STATE_MESSAGE_MAX_LENGTH 160

#define RCUTILS_ERROR_STATE_FILE_MAX_LENGTH 69

#define RCUTILS_ERROR_STATE_LINE_NUMBER_STR_MAX_LENGTH 20

#define RCUTILS_ERROR_FORMATTING_CHARACTERS 6

#define RCUTILS_ERROR_MESSAGE_MAX_LENGTH ((((RCUTILS_ERROR_STATE_MESSAGE_MAX_LENGTH + RCUTILS_ERROR_STATE_FILE_MAX_LENGTH) + RCUTILS_ERROR_STATE_LINE_NUMBER_STR_MAX_LENGTH) + RCUTILS_ERROR_FORMATTING_CHARACTERS) + 1)

#define RCLC_ACTION_RESULT_PAYLOAD_OFFSET 8

#define RCLC_ACTION_FEEDBACK_PAYLOAD_OFFSET 20

#define MAX_SLOTS 16

#define RCLC_LIFECYCLE_STATE_UNCONFIGURED 1

#define RCLC_LIFECYCLE_STATE_INACTIVE 2

#define RCLC_LIFECYCLE_STATE_ACTIVE 3

#define RCLC_LIFECYCLE_STATE_FINALIZED 4

#define RCLC_LIFECYCLE_STATE_ERROR_PROCESSING 5

#define RCLC_LIFECYCLE_TRANSITION_CONFIGURE 1

#define RCLC_LIFECYCLE_TRANSITION_CLEANUP 2

#define RCLC_LIFECYCLE_TRANSITION_ACTIVATE 3

#define RCLC_LIFECYCLE_TRANSITION_DEACTIVATE 4

#define RCLC_LIFECYCLE_TRANSITION_SHUTDOWN_UNCONFIGURED 5

#define RCLC_LIFECYCLE_TRANSITION_SHUTDOWN_INACTIVE 6

#define RCLC_LIFECYCLE_TRANSITION_SHUTDOWN_ACTIVE 7

#define RCLC_LIFECYCLE_TRANSITION_ERROR_RECOVERY 60

#define RCLC_LIFECYCLE_RET_OK 0

#define RCLC_LIFECYCLE_RET_FAILURE 1

#define RCLC_LIFECYCLE_RET_ERROR 2

#define NROS_DOMAIN_ID_INHERIT UINT32_MAX

#define NROS_PUBLISHER_GID_SIZE 24

#define RCLC_SERVICE_TYPED_OK 0

#define RCLC_SERVICE_TYPED_ERR_REQUEST_DESERIALIZE -1

#define RCLC_SERVICE_TYPED_ERR_RESPONSE_SERIALIZE -2

#define RCLC_SERVICE_TYPED_ERR_REQUEST_SERIALIZE -3

#define RCLC_SERVICE_TYPED_ERR_RESPONSE_DESERIALIZE -4

#define RCLC_SERVICE_TYPED_ERR_NO_CALLBACK -5

#define NROS_DOMAIN_ID_EXPLICIT_ZERO 255

typedef enum rcl_clock_type_t {
  RCL_CLOCK_UNINITIALIZED = 0,
  RCL_ROS_TIME = 1,
  RCL_SYSTEM_TIME = 2,
  RCL_STEADY_TIME = 3,
} rcl_clock_type_t;

typedef enum rclc_clock_state_t {
  RCLC_CLOCK_STATE_UNINITIALIZED = 0,
  RCLC_CLOCK_STATE_READY = 1,
  RCLC_CLOCK_STATE_SHUTDOWN = 2,
} rclc_clock_state_t;

typedef enum rclc_action_client_state_t {
  RCLC_ACTION_CLIENT_STATE_UNINITIALIZED = 0,
  RCLC_ACTION_CLIENT_STATE_INITIALIZED = 1,
  RCLC_ACTION_CLIENT_STATE_SHUTDOWN = 2,
} rclc_action_client_state_t;

typedef enum rclc_goal_status_t {
  RCLC_GOAL_STATUS_UNKNOWN = 0,
  RCLC_GOAL_STATUS_ACCEPTED = 1,
  RCLC_GOAL_STATUS_EXECUTING = 2,
  RCLC_GOAL_STATUS_CANCELING = 3,
  RCLC_GOAL_STATUS_SUCCEEDED = 4,
  RCLC_GOAL_STATUS_CANCELED = 5,
  RCLC_GOAL_STATUS_ABORTED = 6,
} rclc_goal_status_t;

typedef enum rclc_cancel_return_code_t {
  RCLC_CANCEL_RC_OK = 0,
  RCLC_CANCEL_RC_REJECTED = 1,
  RCLC_CANCEL_RC_UNKNOWN_GOAL = 2,
  RCLC_CANCEL_RC_GOAL_TERMINATED = 3,
} rclc_cancel_return_code_t;

typedef enum rclc_node_state_t {
  RCLC_NODE_STATE_UNINITIALIZED = 0,
  RCLC_NODE_STATE_INITIALIZED = 1,
  RCLC_NODE_STATE_SHUTDOWN = 2,
} rclc_node_state_t;

typedef enum rclc_support_state_t {
  RCLC_SUPPORT_STATE_UNINITIALIZED = 0,
  RCLC_SUPPORT_STATE_INITIALIZED = 1,
  RCLC_SUPPORT_STATE_SHUTDOWN = 2,
} rclc_support_state_t;

typedef enum rclc_executor_state_t {
  RCLC_EXECUTOR_STATE_UNINITIALIZED = 0,
  RCLC_EXECUTOR_STATE_INITIALIZED = 1,
  RCLC_EXECUTOR_STATE_SPINNING = 2,
  RCLC_EXECUTOR_STATE_SHUTDOWN = 3,
} rclc_executor_state_t;

typedef enum rclc_executor_semantics_t {
  RCLCPP_EXECUTOR = 0,
  LET = 1,
} rclc_executor_semantics_t;

typedef enum rclc_action_server_state_t {
  RCLC_ACTION_SERVER_STATE_UNINITIALIZED = 0,
  RCLC_ACTION_SERVER_STATE_INITIALIZED = 1,
  RCLC_ACTION_SERVER_STATE_SHUTDOWN = 2,
} rclc_action_server_state_t;

typedef enum rclc_goal_response_t {
  RCLC_GOAL_REJECT = 0,
  RCLC_GOAL_ACCEPT_AND_EXECUTE = 1,
  RCLC_GOAL_ACCEPT_AND_DEFER = 2,
} rclc_goal_response_t;

typedef enum rclc_cancel_response_t {
  RCLC_CANCEL_REJECT = 0,
  RCLC_CANCEL_ACCEPT = 1,
} rclc_cancel_response_t;

typedef enum rclc_qos_reliability_t {
  RCLC_QOS_RELIABILITY_BEST_EFFORT = 0,
  RCLC_QOS_RELIABILITY_RELIABLE = 1,
  RCLC_QOS_RELIABILITY_SYSTEM_DEFAULT = 2,
  RCLC_QOS_RELIABILITY_UNKNOWN = 3,
  RCLC_QOS_RELIABILITY_BEST_AVAILABLE = 4,
} rclc_qos_reliability_t;

typedef enum rclc_qos_durability_t {
  RCLC_QOS_DURABILITY_VOLATILE = 0,
  RCLC_QOS_DURABILITY_TRANSIENT_LOCAL = 1,
  RCLC_QOS_DURABILITY_SYSTEM_DEFAULT = 2,
  RCLC_QOS_DURABILITY_UNKNOWN = 3,
  RCLC_QOS_DURABILITY_BEST_AVAILABLE = 4,
} rclc_qos_durability_t;

typedef enum rclc_qos_history_t {
  RCLC_QOS_HISTORY_KEEP_LAST = 0,
  RCLC_QOS_HISTORY_KEEP_ALL = 1,
  RCLC_QOS_HISTORY_SYSTEM_DEFAULT = 2,
  RCLC_QOS_HISTORY_UNKNOWN = 3,
} rclc_qos_history_t;

typedef enum rclc_qos_liveliness_t {
  RCLC_QOS_LIVELINESS_NONE = 0,
  RCLC_QOS_LIVELINESS_AUTOMATIC = 1,
  RCLC_QOS_LIVELINESS_MANUAL_BY_TOPIC = 2,
  RCLC_QOS_LIVELINESS_MANUAL_BY_NODE = 3,
  RCLC_QOS_LIVELINESS_UNKNOWN = 4,
  RCLC_QOS_LIVELINESS_BEST_AVAILABLE = 5,
} rclc_qos_liveliness_t;

typedef enum rclc_subscription_state_t {
  RCLC_SUBSCRIPTION_STATE_UNINITIALIZED = 0,
  RCLC_SUBSCRIPTION_STATE_INITIALIZED = 1,
  RCLC_SUBSCRIPTION_STATE_SHUTDOWN = 2,
} rclc_subscription_state_t;

typedef enum rclc_publisher_state_t {
  RCLC_PUBLISHER_STATE_UNINITIALIZED = 0,
  RCLC_PUBLISHER_STATE_INITIALIZED = 1,
  RCLC_PUBLISHER_STATE_SHUTDOWN = 2,
} rclc_publisher_state_t;

typedef enum rclc_executor_handle_invocation_t {
  ON_NEW_DATA = 0,
  ALWAYS = 1,
} rclc_executor_handle_invocation_t;

typedef enum rclc_timer_state_t {
  RCLC_TIMER_STATE_UNINITIALIZED = 0,
  RCLC_TIMER_STATE_RUNNING = 1,
  RCLC_TIMER_STATE_CANCELED = 2,
  RCLC_TIMER_STATE_SHUTDOWN = 3,
} rclc_timer_state_t;

typedef enum rclc_service_state_t {
  RCLC_SERVICE_STATE_UNINITIALIZED = 0,
  RCLC_SERVICE_STATE_INITIALIZED = 1,
  RCLC_SERVICE_STATE_SHUTDOWN = 2,
} rclc_service_state_t;

typedef enum rclc_client_state_t {
  RCLC_CLIENT_STATE_UNINITIALIZED = 0,
  RCLC_CLIENT_STATE_INITIALIZED = 1,
  RCLC_CLIENT_STATE_REGISTERED = 2,
  RCLC_CLIENT_STATE_SHUTDOWN = 3,
} rclc_client_state_t;

enum rclc_sched_class_t
#if defined(__cplusplus) || __STDC_VERSION__ >= 202311L
  : uint8_t
#endif // defined(__cplusplus) || __STDC_VERSION__ >= 202311L
 {
  RCLC_SCHED_CLASS_FIFO = 0,
  RCLC_SCHED_CLASS_EDF = 1,
  RCLC_SCHED_CLASS_SPORADIC = 2,
  RCLC_SCHED_CLASS_BEST_EFFORT = 3,
  RCLC_SCHED_CLASS_TIME_TRIGGERED = 4,
};
#ifndef __cplusplus
#if __STDC_VERSION__ >= 202311L
typedef enum rclc_sched_class_t rclc_sched_class_t;
#else
typedef uint8_t rclc_sched_class_t;
#endif // __STDC_VERSION__ >= 202311L
#endif // __cplusplus

enum rclc_sched_priority_t
#if defined(__cplusplus) || __STDC_VERSION__ >= 202311L
  : uint8_t
#endif // defined(__cplusplus) || __STDC_VERSION__ >= 202311L
 {
  RCLC_SCHED_PRIORITY_CRITICAL = 0,
  RCLC_SCHED_PRIORITY_NORMAL = 1,
  RCLC_SCHED_PRIORITY_BEST_EFFORT = 2,
};
#ifndef __cplusplus
#if __STDC_VERSION__ >= 202311L
typedef enum rclc_sched_priority_t rclc_sched_priority_t;
#else
typedef uint8_t rclc_sched_priority_t;
#endif // __STDC_VERSION__ >= 202311L
#endif // __cplusplus

enum rclc_deadline_policy_t
#if defined(__cplusplus) || __STDC_VERSION__ >= 202311L
  : uint8_t
#endif // defined(__cplusplus) || __STDC_VERSION__ >= 202311L
 {
  RCLC_DEADLINE_POLICY_RELEASED = 0,
  RCLC_DEADLINE_POLICY_ACTIVATED = 1,
  RCLC_DEADLINE_POLICY_INHERITED = 2,
};
#ifndef __cplusplus
#if __STDC_VERSION__ >= 202311L
typedef enum rclc_deadline_policy_t rclc_deadline_policy_t;
#else
typedef uint8_t rclc_deadline_policy_t;
#endif // __STDC_VERSION__ >= 202311L
#endif // __cplusplus

typedef enum rclc_guard_condition_state_t {
  RCLC_GUARD_CONDITION_STATE_UNINITIALIZED = 0,
  RCLC_GUARD_CONDITION_STATE_INITIALIZED = 1,
  RCLC_GUARD_CONDITION_STATE_SHUTDOWN = 2,
} rclc_guard_condition_state_t;

typedef struct rmw_publisher_allocation_t rmw_publisher_allocation_t;

typedef struct rmw_subscription_allocation_t rmw_subscription_allocation_t;

typedef struct rcl_allocator_t {
  void *(*allocate)(size_t size, void *state);
  void (*deallocate)(void *pointer, void *state);
  void *(*reallocate)(void *pointer, size_t size, void *state);
  void *(*zero_allocate)(size_t number_of_elements, size_t size_of_element, void *state);
  void *state;
} rcl_allocator_t;

typedef struct rcl_clock_t {
  enum rcl_clock_type_t type;
  enum rclc_clock_state_t state;
  uint64_t _steady_epoch_ns;
} rcl_clock_t;

typedef int rcl_ret_t;

typedef struct rclc_time_t {
  int32_t sec;
  uint32_t nanosec;
} rclc_time_t;

typedef struct rcl_duration_t {
  int32_t sec;
  uint32_t nanosec;
} rcl_duration_t;

typedef struct rcl_error_state_t {
  char message[RCUTILS_ERROR_STATE_MESSAGE_MAX_LENGTH];
  char file[RCUTILS_ERROR_STATE_FILE_MAX_LENGTH];
  uint64_t line_number;
} rcl_error_state_t;

typedef struct rcl_error_string_t {
  char str[RCUTILS_ERROR_MESSAGE_MAX_LENGTH];
} rcl_error_string_t;

typedef struct nros_transport_ops_t {
  uint32_t abi_version;
  uint32_t _reserved;
  void *user_data;
  rcl_ret_t (*open)(void *user_data, const void *params);
  void (*close)(void *user_data);
  rcl_ret_t (*write)(void *user_data, const uint8_t *buf, size_t len);
  int32_t (*read)(void *user_data, uint8_t *buf, size_t len, uint32_t timeout_ms);
} nros_transport_ops_t;

typedef struct rclc_node_ref_t {
  uint8_t node_id;
  bool executor_bound;
  uint32_t generation;
} rclc_node_ref_t;

typedef struct rclc_polling_action_client_t {
  enum rclc_action_client_state_t state;
  struct rclc_node_ref_t node;
  uint64_t _opaque[ACTION_CLIENT_OPAQUE_U64S];
} rclc_polling_action_client_t;

typedef struct rclc_action_endpoint_hashes_t {
  const char *send_goal;
  const char *cancel_goal;
  const char *get_result;
  const char *feedback;
  const char *status;
} rclc_action_endpoint_hashes_t;

typedef struct rclc_goal_uuid_t {
  uint8_t uuid[16];
} rclc_goal_uuid_t;

typedef void (*rclc_goal_response_callback_t)(const struct rclc_goal_uuid_t *goal_uuid,
                                              bool accepted,
                                              void *context);

typedef void (*rclc_feedback_callback_t)(const struct rclc_goal_uuid_t *goal_uuid,
                                         const uint8_t *feedback,
                                         size_t feedback_len,
                                         void *context);

typedef void (*rclc_result_callback_t)(const struct rclc_goal_uuid_t *goal_uuid,
                                       enum rclc_goal_status_t status,
                                       const uint8_t *result,
                                       size_t result_len,
                                       void *context);

typedef void (*rclc_cancel_response_callback_t)(const struct rclc_goal_uuid_t *goal_uuid,
                                                enum rclc_cancel_return_code_t return_code,
                                                size_t goals_canceling,
                                                void *context);

typedef uint8_t rclc_sched_context_id_t;

typedef struct rcl_action_client_options_t {
  rclc_sched_context_id_t sched_context;
  uint8_t _reserved[3];
} rcl_action_client_options_t;

typedef struct ActionClientInternal {
  int32_t arena_entry_index;
  void *executor_ptr;
} ActionClientInternal;

typedef struct rcl_action_client_t {
  enum rclc_action_client_state_t state;
  uint8_t action_name[NROS_MAX_ACTION_NAME_LEN];
  size_t action_name_len;
  uint8_t type_name[NROS_MAX_TYPE_NAME_LEN];
  size_t type_name_len;
  uint8_t type_hash[NROS_MAX_TYPE_HASH_LEN];
  size_t type_hash_len;
  struct rclc_action_endpoint_hashes_t endpoint_hashes;
  rclc_goal_response_callback_t goal_response_callback;
  rclc_feedback_callback_t feedback_callback;
  rclc_result_callback_t result_callback;
  rclc_cancel_response_callback_t cancel_response_callback;
  void *context;
  struct rclc_node_ref_t node;
  struct rcl_action_client_options_t options;
  struct ActionClientInternal _internal;
} rcl_action_client_t;

typedef struct rcl_context_t {
  const struct rclc_support_t *_support;
} rcl_context_t;

typedef struct rclc_support_t {
  struct rcl_context_t context;
  enum rclc_support_state_t state;
  uint8_t domain_id;
  uint8_t locator[NROS_MAX_LOCATOR_LEN];
  size_t locator_len;
  uint64_t _opaque[SESSION_OPAQUE_U64S];
} rclc_support_t;

typedef struct rclc_executor_trigger_handle_t {
  void *entity;
  bool data_available;
} rclc_executor_trigger_handle_t;

typedef bool (*rclc_executor_trigger_t)(const struct rclc_executor_trigger_handle_t *handles,
                                        size_t size,
                                        void *obj);

typedef struct rclc_executor_t {
  enum rclc_executor_state_t state;
  uint64_t timeout_ns;
  enum rclc_executor_semantics_t semantics;
  const struct rclc_support_t *support;
  rclc_executor_trigger_t trigger;
  void *trigger_context;
  size_t handle_count;
  size_t max_handles;
  size_t subscription_count;
  size_t timer_count;
  size_t service_count;
  uint64_t invocation_time_ns;
  bool in_dispatch;
  void *_handle_entities[NROS_EXECUTOR_MAX_HANDLES];
  void *_host;
  uint64_t _opaque[EXECUTOR_OPAQUE_U64S];
} rclc_executor_t;

typedef struct rclc_qos_override_t {
  const char *topic;
  uint8_t role;
  uint8_t policy;
  uint32_t value;
} rclc_qos_override_t;

typedef struct rcl_node_t {
  enum rclc_node_state_t state;
  uint8_t name[NROS_MAX_NAME_LEN];
  size_t name_len;
  uint8_t namespace_[NROS_MAX_NAMESPACE_LEN];
  size_t namespace_len;
  const struct rclc_support_t *support;
  uint8_t rmw_name[MAX_RMW_NAME_LEN];
  size_t rmw_name_len;
  uint32_t domain_id_override;
  uint8_t sched_context_id;
  uint8_t _reserved[3];
  uint8_t node_id;
  const struct rclc_executor_t *executor;
  const struct rclc_qos_override_t *qos_overrides;
  size_t qos_overrides_len;
} rcl_node_t;

typedef int32_t (*rclc_message_serialize_fn_t)(const void *msg,
                                               uint8_t *buffer,
                                               size_t capacity,
                                               size_t *out_len);

typedef int32_t (*rclc_message_deserialize_fn_t)(const uint8_t *buffer, size_t len, void *msg);

typedef struct rclc_action_type_t {
  const char *type_name;
  const char *type_hash;
  size_t goal_serialized_size_max;
  size_t result_serialized_size_max;
  size_t feedback_serialized_size_max;
  rclc_message_serialize_fn_t goal_serialize;
  rclc_message_deserialize_fn_t goal_deserialize;
  rclc_message_serialize_fn_t result_serialize;
  rclc_message_deserialize_fn_t result_deserialize;
  rclc_message_serialize_fn_t feedback_serialize;
  rclc_message_deserialize_fn_t feedback_deserialize;
  struct rclc_action_endpoint_hashes_t endpoint_hashes;
  size_t send_goal_request_size;
  size_t send_goal_request_goal_offset;
  size_t get_result_response_size;
  size_t get_result_response_result_offset;
  size_t feedback_message_size;
  size_t feedback_message_feedback_offset;
} rclc_action_type_t;

typedef struct rclc_wake_state_t {
  uint64_t _opaque[2];
} rclc_wake_state_t;

typedef struct rclc_polling_action_server_t {
  enum rclc_action_server_state_t state;
  struct rclc_node_ref_t node;
  uint64_t _opaque[ACTION_SERVER_OPAQUE_U64S];
} rclc_polling_action_server_t;

typedef struct rclc_goal_handle_t {
  struct rclc_goal_uuid_t uuid;
} rclc_goal_handle_t;

typedef enum rclc_goal_response_t (*rclc_goal_callback_t)(struct rcl_action_server_t *server,
                                                          const struct rclc_goal_handle_t *goal,
                                                          const uint8_t *goal_request,
                                                          size_t goal_len,
                                                          void *context);

typedef enum rclc_cancel_response_t (*rclc_cancel_callback_t)(struct rcl_action_server_t *server,
                                                              const struct rclc_goal_handle_t *goal,
                                                              void *context);

typedef void (*rclc_accepted_callback_t)(struct rcl_action_server_t *server,
                                         const struct rclc_goal_handle_t *goal,
                                         void *context);

typedef struct rclc_qos_t {
  enum rclc_qos_reliability_t reliability;
  enum rclc_qos_durability_t durability;
  enum rclc_qos_history_t history;
  enum rclc_qos_liveliness_t liveliness_kind;
  int depth;
  uint32_t deadline_ms;
  uint32_t lifespan_ms;
  uint32_t liveliness_lease_ms;
  uint8_t avoid_ros_namespace_conventions;
  uint8_t tx_express;
} rclc_qos_t;

typedef struct rcl_action_server_options_t {
  rclc_sched_context_id_t sched_context;
  uint8_t _reserved[3];
} rcl_action_server_options_t;

typedef struct ActionServerInternal {
  ActionServerRawHandle handle;
  void *executor_ptr;
} ActionServerInternal;

typedef int8_t rcl_action_goal_state_t;

typedef struct rclc_action_goal_handle_t {
  struct rclc_action_goal_handle_t *next;
  struct rcl_action_server_t *action_server;
  rcl_action_goal_state_t status;
  unique_identifier_msgs__msg__UUID goal_id;
  void *ros_goal_request;
  bool available_goal_response;
  bool goal_accepted;
  bool available_feedback;
  bool available_result_response;
  bool available_cancel_response;
  bool goal_cancelled;
  bool _in_use;
} rclc_action_goal_handle_t;

typedef rcl_ret_t (*rclc_action_server_handle_goal_callback_t)(struct rclc_action_goal_handle_t *goal_handle,
                                                               void *context);

typedef bool (*rclc_action_server_handle_cancel_callback_t)(struct rclc_action_goal_handle_t *goal_handle,
                                                            void *context);

typedef struct rclc_action_server_rclc_state_t {
  rclc_action_server_handle_goal_callback_t goal_callback;
  rclc_action_server_handle_cancel_callback_t cancel_callback;
  void *context;
  uint8_t *goal_requests;
  size_t goal_request_size;
  size_t handles_number;
  struct rclc_action_goal_handle_t goal_handles[NROS_MAX_CONCURRENT_GOALS];
} rclc_action_server_rclc_state_t;

typedef struct rcl_action_server_t {
  enum rclc_action_server_state_t state;
  uint8_t action_name[NROS_MAX_ACTION_NAME_LEN];
  size_t action_name_len;
  uint8_t type_name[NROS_MAX_TYPE_NAME_LEN];
  size_t type_name_len;
  uint8_t type_hash[NROS_MAX_TYPE_HASH_LEN];
  size_t type_hash_len;
  struct rclc_action_endpoint_hashes_t endpoint_hashes;
  rclc_goal_callback_t goal_callback;
  rclc_cancel_callback_t cancel_callback;
  rclc_accepted_callback_t accepted_callback;
  void *context;
  struct rclc_node_ref_t node;
  struct rclc_qos_t qos;
  struct rcl_action_server_options_t options;
  struct ActionServerInternal _internal;
  const struct rclc_action_type_t *type_support;
  struct rclc_action_server_rclc_state_t _rclc;
} rcl_action_server_t;

typedef struct rcl_action_server_t rclc_action_server_t;

typedef struct rclc_message_type_t {
  const char *type_name;
  const char *type_hash;
  size_t serialized_size_max;
  rclc_message_serialize_fn_t serialize;
  rclc_message_deserialize_fn_t deserialize;
} rclc_message_type_t;

typedef struct rcl_subscription_options_t {
  rclc_sched_context_id_t sched_context;
  uint8_t message_info;
  uint8_t _reserved[2];
} rcl_subscription_options_t;

typedef struct rcl_subscription_t {
  enum rclc_subscription_state_t state;
  uint8_t topic_name[NROS_MAX_TOPIC_LEN];
  size_t topic_name_len;
  uint8_t type_name[NROS_MAX_TYPE_NAME_LEN];
  size_t type_name_len;
  uint8_t type_hash[NROS_MAX_TYPE_HASH_LEN];
  size_t type_hash_len;
  struct rclc_node_ref_t node;
  const struct rclc_message_type_t *type_support;
  struct rclc_qos_t qos;
  size_t handle_id;
  struct rcl_subscription_options_t options;
  void *_executor;
} rcl_subscription_t;

typedef struct rclc_liveliness_changed_status_t {
  uint16_t alive_count;
  uint16_t not_alive_count;
  int16_t alive_count_change;
  int16_t not_alive_count_change;
} rclc_liveliness_changed_status_t;

typedef void (*rclc_event_liveliness_changed_cb_t)(struct rcl_subscription_t *sub,
                                                   struct rclc_liveliness_changed_status_t status,
                                                   void *user_context);

typedef struct rclc_count_status_t {
  uint32_t total_count;
  uint32_t total_count_change;
} rclc_count_status_t;

typedef void (*rclc_event_subscriber_count_cb_t)(struct rcl_subscription_t *sub,
                                                 struct rclc_count_status_t status,
                                                 void *user_context);

typedef struct rcl_publisher_options_t {
  uint8_t _reserved[4];
} rcl_publisher_options_t;

typedef struct rcl_publisher_t {
  enum rclc_publisher_state_t state;
  uint8_t topic_name[NROS_MAX_TOPIC_LEN];
  struct rcl_publisher_options_t options;
  size_t topic_name_len;
  uint8_t type_name[NROS_MAX_TYPE_NAME_LEN];
  size_t type_name_len;
  uint8_t type_hash[NROS_MAX_TYPE_HASH_LEN];
  size_t type_hash_len;
  struct rclc_node_ref_t node;
  const struct rclc_message_type_t *type_support;
  uint64_t _opaque[PUBLISHER_OPAQUE_U64S];
} rcl_publisher_t;

typedef void (*rclc_event_publisher_count_cb_t)(struct rcl_publisher_t *pub_,
                                                struct rclc_count_status_t status,
                                                void *user_context);

typedef struct rclc_matched_status_t {
  uint32_t total_count;
  uint32_t total_count_change;
  uint32_t current_count;
  int32_t current_count_change;
} rclc_matched_status_t;

typedef void (*rclc_event_publisher_matched_cb_t)(struct rcl_publisher_t *pub_,
                                                  struct rclc_matched_status_t status,
                                                  void *user_context);

typedef struct rclc_incompatible_type_status_t {
  uint32_t total_count;
  uint32_t total_count_change;
} rclc_incompatible_type_status_t;

typedef void (*rclc_event_publisher_incompatible_type_cb_t)(struct rcl_publisher_t *pub_,
                                                            struct rclc_incompatible_type_status_t status,
                                                            void *user_context);

typedef void (*rclc_event_subscription_matched_cb_t)(struct rcl_subscription_t *sub,
                                                     struct rclc_matched_status_t status,
                                                     void *user_context);

typedef void (*rclc_event_subscription_incompatible_type_cb_t)(struct rcl_subscription_t *sub,
                                                               struct rclc_incompatible_type_status_t status,
                                                               void *user_context);

typedef bool (*rclc_node_visit_fn)(void *ctx,
                                   const char *node_name,
                                   const char *node_namespace,
                                   const char *enclave);

typedef bool (*rclc_names_and_types_visit_fn)(void *ctx,
                                              const char *name,
                                              const char *const *types,
                                              size_t types_count);

typedef struct rclc_endpoint_info_t {
  const char *node_name;
  const char *node_namespace;
  const char *topic_type;
  bool is_publisher;
  uint8_t endpoint_gid[24];
} rclc_endpoint_info_t;

typedef bool (*rclc_endpoint_info_visit_fn)(void *ctx, const struct rclc_endpoint_info_t *info);

typedef struct rcl_node_options_t {
  uint8_t namespace_[NROS_MAX_NAMESPACE_LEN];
  size_t namespace_len;
  uint8_t rmw_name[MAX_RMW_NAME_LEN];
  size_t rmw_name_len;
  uint8_t locator[NROS_MAX_LOCATOR_LEN];
  size_t locator_len;
  uint32_t domain_id_override;
  uint8_t sched_context_id;
  uint8_t _reserved[3];
} rcl_node_options_t;

typedef void (*rclc_subscription_validated_callback_t)(const uint8_t *data,
                                                       size_t len,
                                                       int64_t gap,
                                                       bool duplicate,
                                                       int8_t crc_valid,
                                                       void *context);

typedef void (*rclc_subscription_callback_with_context_t)(const void *msg, void *context);

typedef void (*rclc_subscription_callback_t)(const void *msgin);

typedef void (*rclc_subscription_raw_callback_t)(const uint8_t *data, size_t len, void *context);

typedef void (*rclc_subscription_info_callback_t)(const uint8_t *data,
                                                  size_t len,
                                                  const uint8_t *attachment,
                                                  size_t attachment_len,
                                                  void *context);

typedef void (*rcl_timer_callback_t)(struct rcl_timer_t *timer, int64_t last_call_time);

typedef struct rcl_timer_call_info_t {
  int64_t expected_call_time;
  int64_t actual_call_time;
} rcl_timer_call_info_t;

typedef void (*rclc_timer_callback_with_info_t)(struct rcl_timer_t *timer,
                                                const struct rcl_timer_call_info_t *info);

typedef struct rcl_timer_t {
  enum rclc_timer_state_t state;
  uint64_t period_ns;
  rcl_timer_callback_t callback;
  const struct rcl_clock_t *clock;
  size_t handle_id;
  void *_executor;
  rclc_timer_callback_with_info_t info_callback;
} rcl_timer_t;

typedef struct rclc_service_type_t {
  const char *type_name;
  const char *type_hash;
  rclc_message_serialize_fn_t request_serialize;
  rclc_message_deserialize_fn_t request_deserialize;
  rclc_message_serialize_fn_t response_serialize;
  rclc_message_deserialize_fn_t response_deserialize;
} rclc_service_type_t;

typedef struct rcl_service_options_t {
  rclc_sched_context_id_t sched_context;
  uint8_t _reserved[3];
} rcl_service_options_t;

typedef struct ServiceServerInternal {
  int32_t arena_entry_index;
  void *executor_ptr;
} ServiceServerInternal;

typedef struct rcl_service_t {
  enum rclc_service_state_t state;
  uint8_t service_name[NROS_MAX_SERVICE_NAME_LEN];
  size_t service_name_len;
  uint8_t type_name[NROS_MAX_TYPE_NAME_LEN];
  size_t type_name_len;
  uint8_t type_hash[NROS_MAX_TYPE_HASH_LEN];
  size_t type_hash_len;
  struct rclc_node_ref_t node;
  const struct rclc_service_type_t *type_support;
  struct rclc_qos_t qos;
  struct rcl_service_options_t options;
  struct ServiceServerInternal _internal;
} rcl_service_t;

typedef bool (*rclc_service_raw_callback_t)(const uint8_t *request_data,
                                            size_t request_len,
                                            uint8_t *response_data,
                                            size_t response_capacity,
                                            size_t *response_len,
                                            void *context);

typedef bool (*rclc_service_raw_callback_with_request_id_t)(const uint8_t *request_data,
                                                            size_t request_len,
                                                            rmw_request_id_t *request_id,
                                                            uint8_t *response_data,
                                                            size_t response_capacity,
                                                            size_t *response_len,
                                                            void *context);

typedef void (*rclc_service_callback_t)(const void *request, void *response);

typedef void (*rclc_service_callback_with_request_id_t)(const void *request,
                                                        rmw_request_id_t *request_id,
                                                        void *response);

typedef void (*rclc_service_callback_with_context_t)(const void *request,
                                                     void *response,
                                                     void *context);

typedef struct rcl_client_options_t {
  rclc_sched_context_id_t sched_context;
  uint8_t _reserved[3];
} rcl_client_options_t;

typedef struct ServiceClientInternal {
  int32_t arena_entry_index;
  void *executor_ptr;
  uint32_t timeout_ms;
} ServiceClientInternal;

typedef struct rcl_client_t {
  enum rclc_client_state_t state;
  uint8_t service_name[NROS_MAX_SERVICE_NAME_LEN];
  size_t service_name_len;
  uint8_t type_name[NROS_MAX_TYPE_NAME_LEN];
  size_t type_name_len;
  uint8_t type_hash[NROS_MAX_TYPE_HASH_LEN];
  size_t type_hash_len;
  struct rclc_node_ref_t node;
  const struct rclc_service_type_t *type_support;
  struct rclc_qos_t qos;
  struct rcl_client_options_t options;
  struct ServiceClientInternal _internal;
} rcl_client_t;

typedef void (*rclc_client_callback_t)(const void *response);

typedef void (*rclc_client_callback_with_request_id_t)(const void *response,
                                                       rmw_request_id_t *request_id);

typedef struct rclc_sched_context_t {
  rclc_sched_class_t class_;
  rclc_sched_priority_t priority;
  rclc_deadline_policy_t deadline_policy;
  uint32_t period_us;
  uint32_t budget_us;
  uint32_t deadline_us;
  uint8_t os_pri;
  uint32_t tt_window_offset_us;
  uint32_t tt_window_duration_us;
} rclc_sched_context_t;

typedef void (*rclc_shutdown_callback_t)(void *context);

typedef uint32_t rclc_shutdown_callback_handle_t;

typedef void (*rclc_guard_condition_callback_t)(void *context);

typedef struct rcl_guard_condition_t {
  enum rclc_guard_condition_state_t state;
  bool triggered;
  rclc_guard_condition_callback_t callback;
  void *context;
  size_t handle_id;
  bool _guard_valid;
  uint64_t _guard_opaque[GUARD_HANDLE_OPAQUE_U64S];
} rcl_guard_condition_t;

typedef struct rcl_lifecycle_state_machine_t {
  bool initialized;
  uint8_t _pad[7];
  uint64_t storage[NROS_LIFECYCLE_CTX_OPAQUE_U64S];
} rcl_lifecycle_state_machine_t;

typedef uint8_t (*rclc_lifecycle_callback_t)(void *context);

typedef struct rclc_polling_service_t {
  enum rclc_service_state_t state;
  struct rclc_node_ref_t node;
  uint64_t _opaque[SERVICE_SERVER_OPAQUE_U64S];
} rclc_polling_service_t;

typedef struct rclc_polling_client_t {
  enum rclc_client_state_t state;
  struct rclc_node_ref_t node;
  uint64_t _opaque[SERVICE_CLIENT_OPAQUE_U64S];
} rclc_polling_client_t;

typedef void (*rclc_response_callback_t)(const uint8_t *response, size_t response_len, void *context);

typedef struct rclc_polling_subscription_t {
  enum rclc_subscription_state_t state;
  struct rclc_node_ref_t node;
  const struct rclc_message_type_t *type_support;
  uint64_t _opaque[SUBSCRIPTION_OPAQUE_U64S];
} rclc_polling_subscription_t;

typedef struct rclc_integrity_status_t {
  int64_t gap;
  bool duplicate;
  int8_t crc_valid;
} rclc_integrity_status_t;

#define RCL_RET_OK 0

#define RCL_RET_ERROR -1

#define RCL_RET_TIMEOUT -2

#define RCL_RET_INVALID_ARGUMENT -3

#define RCLC_RET_NOT_FOUND -4

#define RCLC_RET_ALREADY_EXISTS -5

#define RCLC_RET_FULL -6

#define RCL_RET_NOT_INIT -7

#define RCLC_RET_BAD_SEQUENCE -8

#define RCLC_RET_STALE_NODE -17

#define RCL_RET_ACTION_GOAL_ACCEPTED -18

#define RCL_RET_ACTION_GOAL_REJECTED -19

#define RCLC_RET_ACTION_WAIT_RESULT_REQUEST -20

#define RCLC_RET_SERVICE_FAILED -9

#define RCLC_RET_PUBLISH_FAILED -10

#define RCLC_RET_SUBSCRIPTION_FAILED -11

#define RCLC_RET_NOT_ALLOWED -12

#define RCLC_RET_REJECTED -13

#define RCLC_RET_TRY_AGAIN -14

#define RCLC_RET_REENTRANT -15

#define RCL_RET_UNSUPPORTED -16

#define GOAL_STATE_UNKNOWN 0

#define GOAL_STATE_ACCEPTED 1

#define GOAL_STATE_EXECUTING 2

#define GOAL_STATE_CANCELING 3

#define GOAL_STATE_SUCCEEDED 4

#define GOAL_STATE_CANCELED 5

#define GOAL_STATE_ABORTED 6

#define RCLC_SHUTDOWN_CALLBACK_HANDLE_INVALID 4294967295
 
#ifdef __cplusplus
extern "C" {
#endif // __cplusplus

extern const struct rclc_qos_t RCLC_QOS_DEFAULT;

extern const struct rclc_qos_t RCLC_QOS_SENSOR_DATA;

extern const struct rclc_qos_t RCLC_QOS_SERVICES;

extern const uint32_t NROS_TRANSPORT_OPS_ABI_VERSION_V1;
 
extern size_t nros_platform_heap_used_bytes(void);
 
extern size_t nros_platform_heap_total_bytes(void);

NROS_PUBLIC size_t rclc_heap_used_bytes(void);

NROS_PUBLIC size_t rclc_heap_peak_bytes(void);

NROS_PUBLIC size_t rclc_heap_platform_used_bytes(void);

NROS_PUBLIC size_t rclc_heap_total_bytes(void);
 
extern uint32_t nros_platform_critical_section_acquire(void);
 
extern void nros_platform_critical_section_release(uint32_t token);

NROS_PUBLIC struct rcl_allocator_t rcl_get_default_allocator(void);

NROS_PUBLIC int32_t rclc_cdr_write_encaps_header(uint8_t **ptr, const uint8_t *end);

NROS_PUBLIC
int64_t rclc_cdr_begin_dheader(uint8_t **ptr,
                               const uint8_t *end,
                               const uint8_t *origin);

NROS_PUBLIC
int32_t rclc_cdr_end_dheader(int64_t mark,
                             uint8_t **ptr,
                             const uint8_t *end,
                             const uint8_t *origin);

NROS_PUBLIC
int64_t rclc_cdr_begin_dheader_read(const uint8_t **ptr,
                                    const uint8_t *end,
                                    const uint8_t *origin);

NROS_PUBLIC
int32_t rclc_cdr_end_dheader_read(int64_t scope,
                                  const uint8_t **ptr,
                                  const uint8_t *end,
                                  const uint8_t *origin);

NROS_PUBLIC
int32_t rclc_cdr_write_bool(uint8_t **ptr,
                            const uint8_t *end,
                            const uint8_t *origin,
                            bool value);

NROS_PUBLIC
int32_t rclc_cdr_write_u8(uint8_t **ptr,
                          const uint8_t *end,
                          const uint8_t *origin,
                          uint8_t value);

NROS_PUBLIC
int32_t rclc_cdr_write_i8(uint8_t **ptr,
                          const uint8_t *end,
                          const uint8_t *origin,
                          int8_t value);

NROS_PUBLIC
int32_t rclc_cdr_write_u16(uint8_t **ptr,
                           const uint8_t *end,
                           const uint8_t *origin,
                           uint16_t value);

NROS_PUBLIC
int32_t rclc_cdr_write_i16(uint8_t **ptr,
                           const uint8_t *end,
                           const uint8_t *origin,
                           int16_t value);

NROS_PUBLIC
int32_t rclc_cdr_write_u32(uint8_t **ptr,
                           const uint8_t *end,
                           const uint8_t *origin,
                           uint32_t value);

NROS_PUBLIC
int32_t rclc_cdr_write_i32(uint8_t **ptr,
                           const uint8_t *end,
                           const uint8_t *origin,
                           int32_t value);

NROS_PUBLIC
int32_t rclc_cdr_write_u64(uint8_t **ptr,
                           const uint8_t *end,
                           const uint8_t *origin,
                           uint64_t value);

NROS_PUBLIC
int32_t rclc_cdr_write_i64(uint8_t **ptr,
                           const uint8_t *end,
                           const uint8_t *origin,
                           int64_t value);

NROS_PUBLIC
int32_t rclc_cdr_write_f32(uint8_t **ptr,
                           const uint8_t *end,
                           const uint8_t *origin,
                           float value);

NROS_PUBLIC
int32_t rclc_cdr_write_f64(uint8_t **ptr,
                           const uint8_t *end,
                           const uint8_t *origin,
                           double value);

NROS_PUBLIC
int32_t rclc_cdr_write_string(uint8_t **ptr,
                              const uint8_t *end,
                              const uint8_t *origin,
                              const char *value);

NROS_PUBLIC
int32_t rclc_cdr_write_string_n(uint8_t **ptr,
                                const uint8_t *end,
                                const uint8_t *origin,
                                const char *data,
                                size_t data_len);

NROS_PUBLIC
int32_t rclc_cdr_read_bool(const uint8_t **ptr,
                           const uint8_t *end,
                           const uint8_t *origin,
                           bool *value);

NROS_PUBLIC
int32_t rclc_cdr_read_u8(const uint8_t **ptr,
                         const uint8_t *end,
                         const uint8_t *origin,
                         uint8_t *value);

NROS_PUBLIC
int32_t rclc_cdr_read_i8(const uint8_t **ptr,
                         const uint8_t *end,
                         const uint8_t *origin,
                         int8_t *value);

NROS_PUBLIC
int32_t rclc_cdr_read_u16(const uint8_t **ptr,
                          const uint8_t *end,
                          const uint8_t *origin,
                          uint16_t *value);

NROS_PUBLIC
int32_t rclc_cdr_read_i16(const uint8_t **ptr,
                          const uint8_t *end,
                          const uint8_t *origin,
                          int16_t *value);

NROS_PUBLIC
int32_t rclc_cdr_read_u32(const uint8_t **ptr,
                          const uint8_t *end,
                          const uint8_t *origin,
                          uint32_t *value);

NROS_PUBLIC
int32_t rclc_cdr_read_i32(const uint8_t **ptr,
                          const uint8_t *end,
                          const uint8_t *origin,
                          int32_t *value);

NROS_PUBLIC
int32_t rclc_cdr_read_u64(const uint8_t **ptr,
                          const uint8_t *end,
                          const uint8_t *origin,
                          uint64_t *value);

NROS_PUBLIC
int32_t rclc_cdr_read_i64(const uint8_t **ptr,
                          const uint8_t *end,
                          const uint8_t *origin,
                          int64_t *value);

NROS_PUBLIC
int32_t rclc_cdr_read_f32(const uint8_t **ptr,
                          const uint8_t *end,
                          const uint8_t *origin,
                          float *value);

NROS_PUBLIC
int32_t rclc_cdr_read_f64(const uint8_t **ptr,
                          const uint8_t *end,
                          const uint8_t *origin,
                          double *value);

NROS_PUBLIC
int32_t rclc_cdr_read_string(const uint8_t **ptr,
                             const uint8_t *end,
                             const uint8_t *origin,
                             char *value,
                             size_t max_len);

NROS_PUBLIC
int32_t rclc_cdr_align(const uint8_t **ptr,
                       const uint8_t *end,
                       const uint8_t *origin,
                       size_t alignment);

NROS_PUBLIC struct rcl_clock_t rclc_clock_get_zero_initialized(void);

NROS_PUBLIC
rcl_ret_t rcl_clock_init(enum rcl_clock_type_t clock_type,
                         struct rcl_clock_t *clock,
                         struct rcl_allocator_t *allocator);

NROS_PUBLIC
rcl_ret_t rclc_clock_get_now_time(const struct rcl_clock_t *clock,
                                  struct rclc_time_t *time_out);

NROS_PUBLIC rcl_ret_t rcl_clock_get_now(const struct rcl_clock_t *clock, int64_t *nanoseconds);

NROS_PUBLIC bool rclc_clock_is_valid(const struct rcl_clock_t *clock);

NROS_PUBLIC enum rcl_clock_type_t rclc_clock_get_type(const struct rcl_clock_t *clock);

NROS_PUBLIC rcl_ret_t rcl_clock_fini(struct rcl_clock_t *clock);

NROS_PUBLIC rcl_ret_t rcl_enable_ros_time_override(const struct rcl_clock_t *clock);

NROS_PUBLIC rcl_ret_t rcl_disable_ros_time_override(const struct rcl_clock_t *clock);

NROS_PUBLIC
rcl_ret_t rcl_is_enabled_ros_time_override(const struct rcl_clock_t *clock,
                                           bool *is_enabled);

NROS_PUBLIC
rcl_ret_t rcl_set_ros_time_override(const struct rcl_clock_t *clock,
                                    int64_t nanoseconds);

NROS_PUBLIC
rcl_ret_t rclc_get_ros_time_override(const struct rcl_clock_t *clock,
                                     int64_t *nanoseconds);

NROS_PUBLIC bool rcl_clock_time_started(const struct rcl_clock_t *clock);

NROS_PUBLIC struct rclc_time_t rclc_time_from_nanoseconds(int64_t nanoseconds);

NROS_PUBLIC struct rcl_duration_t rclc_duration_from_nanoseconds(int64_t nanoseconds);

NROS_PUBLIC int64_t rclc_time_to_nanoseconds(const struct rclc_time_t *time);

NROS_PUBLIC
struct rclc_time_t rclc_time_add(struct rclc_time_t time,
                                 struct rcl_duration_t duration);

NROS_PUBLIC
struct rclc_time_t rclc_time_sub(struct rclc_time_t time,
                                 struct rcl_duration_t duration);

NROS_PUBLIC int rclc_time_compare(struct rclc_time_t a, struct rclc_time_t b);

NROS_PUBLIC
void rcl_set_error_state(const char *error_string,
                         const char *file,
                         size_t line_number);

NROS_PUBLIC bool rcl_error_is_set(void);

NROS_PUBLIC const struct rcl_error_state_t *rcl_get_error_state(void);

NROS_PUBLIC struct rcl_error_string_t rcl_get_error_string(void);

NROS_PUBLIC void rcl_reset_error(void);

extern uint64_t nros_platform_clock_ns(void);

extern void nros_platform_sleep_us(size_t us);

extern uint64_t nros_platform_time_now_ns(void);

NROS_PUBLIC const char *rclc_qos_policy_kind_to_cstr(uint32_t policy);

NROS_PUBLIC void rclc_set_trace_sink(void (*sink)(uint32_t, uint32_t));

NROS_PUBLIC int32_t rclc_set_default_trace_sink(void (*sink)(uint32_t, uint32_t));

NROS_PUBLIC void rclc_monitors_arm(void);

NROS_PUBLIC void rclc_trace_set_take(uint8_t handle, bool on, int32_t stamp_offset);

NROS_PUBLIC void rclc_trace_set_timer_every(uint8_t handle, uint16_t every);

NROS_PUBLIC rcl_ret_t rclc_set_custom_transport(const struct nros_transport_ops_t *ops);

NROS_PUBLIC rcl_ret_t rclc_clear_custom_transport(void);

NROS_PUBLIC rcl_ret_t rclc_has_custom_transport(void);

NROS_PUBLIC
struct rclc_polling_action_client_t rclc_get_zero_initialized_polling_action_client(void);

NROS_PUBLIC struct rcl_action_client_t rcl_action_get_zero_initialized_client(void);

NROS_PUBLIC
rcl_ret_t rcl_action_client_init(struct rcl_action_client_t *client,
                                 const struct rcl_node_t *node,
                                 const struct rclc_action_type_t *type_info,
                                 const char *action_name,
                                 const struct rcl_action_client_options_t *options);

NROS_PUBLIC
const struct rcl_action_client_options_t *rcl_action_client_get_options(const struct rcl_action_client_t *client);

NROS_PUBLIC struct rcl_action_client_options_t rcl_action_client_get_default_options(void);

NROS_PUBLIC
rcl_ret_t rclc_action_client_set_feedback_callback(struct rcl_action_client_t *client,
                                                   rclc_feedback_callback_t callback,
                                                   void *context);

NROS_PUBLIC
rcl_ret_t rclc_action_client_set_result_callback(struct rcl_action_client_t *client,
                                                 rclc_result_callback_t callback,
                                                 void *context);

NROS_PUBLIC
rcl_ret_t rclc_action_client_set_cancel_response_callback(struct rcl_action_client_t *client,
                                                          rclc_cancel_response_callback_t callback,
                                                          void *context);

NROS_PUBLIC
rcl_ret_t rclc_action_client_wait_for_action_server(struct rcl_action_client_t *client,
                                                    struct rclc_executor_t *executor,
                                                    uint32_t timeout_ms);

NROS_PUBLIC const char *rcl_action_client_get_action_name(const struct rcl_action_client_t *client);

NROS_PUBLIC
bool rclc_action_client_action_server_is_ready(const struct rcl_action_client_t *client,
                                               struct rclc_executor_t *executor);

NROS_PUBLIC
rcl_ret_t rclc_action_send_goal(struct rcl_action_client_t *client,
                                struct rclc_executor_t *executor,
                                const uint8_t *goal,
                                size_t goal_len,
                                struct rclc_goal_uuid_t *goal_uuid);

NROS_PUBLIC
rcl_ret_t rclc_action_cancel_goal(struct rcl_action_client_t *client,
                                  const struct rclc_goal_uuid_t *goal_uuid);

NROS_PUBLIC
rcl_ret_t rclc_action_get_result(struct rcl_action_client_t *client,
                                 struct rclc_executor_t *executor,
                                 const struct rclc_goal_uuid_t *goal_uuid,
                                 enum rclc_goal_status_t *status,
                                 uint8_t *result,
                                 size_t result_capacity,
                                 size_t *result_len);

NROS_PUBLIC rcl_ret_t rclc_action_try_recv_feedback(struct rcl_action_client_t *client);

NROS_PUBLIC
rcl_ret_t rclc_action_send_goal_async(struct rcl_action_client_t *client,
                                      const uint8_t *goal,
                                      size_t goal_len,
                                      struct rclc_goal_uuid_t *goal_uuid);

NROS_PUBLIC
rcl_ret_t rclc_action_get_result_async(struct rcl_action_client_t *client,
                                       const struct rclc_goal_uuid_t *goal_uuid);

NROS_PUBLIC
rcl_ret_t rclc_action_client_set_goal_response_callback(struct rcl_action_client_t *client,
                                                        rclc_goal_response_callback_t callback,
                                                        void *context);

NROS_PUBLIC rcl_ret_t rclc_action_client_poll(struct rcl_action_client_t *client);

NROS_PUBLIC
rcl_ret_t rcl_action_client_fini(struct rcl_action_client_t *client,
                                 struct rcl_node_t *node);

NROS_PUBLIC
rcl_ret_t rclc_polling_action_client_init(struct rclc_polling_action_client_t *client,
                                          const struct rcl_node_t *node,
                                          const struct rclc_action_type_t *type_info,
                                          const char *action_name);

NROS_PUBLIC rcl_ret_t rclc_polling_action_client_fini(struct rclc_polling_action_client_t *client);

NROS_PUBLIC
rcl_ret_t rclc_polling_action_client_send_goal_raw(struct rclc_polling_action_client_t *client,
                                                   const uint8_t *goal_cdr,
                                                   size_t goal_len,
                                                   uint8_t (*goal_id_out)[16]);

NROS_PUBLIC
int32_t rclc_polling_action_client_try_recv_goal_response_raw(struct rclc_polling_action_client_t *client,
                                                              uint8_t *buf,
                                                              size_t buf_len);

NROS_PUBLIC
int32_t rclc_polling_action_client_try_recv_goal_response_raw_for(struct rclc_polling_action_client_t *client,
                                                                  uint8_t *buf,
                                                                  size_t buf_len,
                                                                  uint8_t (*goal_id_out)[16]);

NROS_PUBLIC
rcl_ret_t rclc_polling_action_client_send_get_result_request_raw(struct rclc_polling_action_client_t *client,
                                                                 const uint8_t (*goal_id)[16]);

NROS_PUBLIC
int32_t rclc_polling_action_client_try_recv_result_raw(struct rclc_polling_action_client_t *client,
                                                       uint8_t *buf,
                                                       size_t buf_len);

NROS_PUBLIC
int32_t rclc_polling_action_client_try_recv_result_raw_for(struct rclc_polling_action_client_t *client,
                                                           uint8_t *buf,
                                                           size_t buf_len,
                                                           uint8_t (*goal_id_out)[16]);

NROS_PUBLIC
rcl_ret_t rclc_polling_action_client_send_cancel_request_raw(struct rclc_polling_action_client_t *client,
                                                             const uint8_t (*goal_id)[16]);

NROS_PUBLIC
int32_t rclc_polling_action_client_try_recv_cancel_response_raw(struct rclc_polling_action_client_t *client,
                                                                uint8_t *buf,
                                                                size_t buf_len);

NROS_PUBLIC
int32_t rclc_polling_action_client_try_recv_cancel_response_raw_for(struct rclc_polling_action_client_t *client,
                                                                    uint8_t *buf,
                                                                    size_t buf_len,
                                                                    uint8_t (*goal_id_out)[16]);

NROS_PUBLIC
rcl_ret_t rclc_polling_action_client_set_goal_response_wake_callback(struct rclc_polling_action_client_t *client,
                                                                     struct rclc_wake_state_t *state,
                                                                     void (*cb)(void*),
                                                                     void *ctx);

NROS_PUBLIC
rcl_ret_t rclc_polling_action_client_set_cancel_response_wake_callback(struct rclc_polling_action_client_t *client,
                                                                       struct rclc_wake_state_t *state,
                                                                       void (*cb)(void*),
                                                                       void *ctx);

NROS_PUBLIC
rcl_ret_t rclc_polling_action_client_set_result_wake_callback(struct rclc_polling_action_client_t *client,
                                                              struct rclc_wake_state_t *state,
                                                              void (*cb)(void*),
                                                              void *ctx);

NROS_PUBLIC
rcl_ret_t rclc_polling_action_client_set_feedback_wake_callback(struct rclc_polling_action_client_t *client,
                                                                struct rclc_wake_state_t *state,
                                                                void (*cb)(void*),
                                                                void *ctx);

NROS_PUBLIC
int32_t rclc_polling_action_client_try_recv_feedback_raw(struct rclc_polling_action_client_t *client,
                                                         uint8_t *buf,
                                                         size_t buf_len,
                                                         uint8_t (*goal_id_out)[16]);

NROS_PUBLIC rcl_ret_t rclc_goal_uuid_generate(struct rclc_goal_uuid_t *uuid);

NROS_PUBLIC
bool rclc_goal_uuid_equal(const struct rclc_goal_uuid_t *a,
                          const struct rclc_goal_uuid_t *b);

NROS_PUBLIC const char *rclc_goal_status_to_string(enum rclc_goal_status_t status);

NROS_PUBLIC
struct rclc_polling_action_server_t rclc_get_zero_initialized_polling_action_server(void);

NROS_PUBLIC struct rcl_action_server_t rcl_action_get_zero_initialized_server(void);

NROS_PUBLIC
rcl_ret_t rclc_action_server_init_with_callbacks(struct rcl_action_server_t *server,
                                                 const struct rcl_node_t *node,
                                                 const char *action_name,
                                                 const struct rclc_action_type_t *type_info,
                                                 rclc_goal_callback_t goal_callback,
                                                 rclc_cancel_callback_t cancel_callback,
                                                 rclc_accepted_callback_t accepted_callback,
                                                 void *context);

NROS_PUBLIC
rcl_ret_t rclc_action_server_init_with_qos(struct rcl_action_server_t *server,
                                           const struct rcl_node_t *node,
                                           const char *action_name,
                                           const struct rclc_action_type_t *type_info,
                                           rclc_goal_callback_t goal_callback,
                                           rclc_cancel_callback_t cancel_callback,
                                           rclc_accepted_callback_t accepted_callback,
                                           void *context,
                                           const struct rclc_qos_t *qos);

NROS_PUBLIC
const struct rcl_action_server_options_t *rcl_action_server_get_options(const struct rcl_action_server_t *server);

NROS_PUBLIC struct rcl_action_server_options_t rcl_action_server_get_default_options(void);

NROS_PUBLIC
rcl_ret_t rclc_action_server_init_with_options(struct rcl_action_server_t *server,
                                               const struct rcl_node_t *node,
                                               const char *action_name,
                                               const struct rclc_action_type_t *type_info,
                                               rclc_goal_callback_t goal_callback,
                                               rclc_cancel_callback_t cancel_callback,
                                               rclc_accepted_callback_t accepted_callback,
                                               void *context,
                                               const struct rclc_qos_t *qos,
                                               const struct rcl_action_server_options_t *options);

NROS_PUBLIC
rcl_ret_t rclc_action_publish_feedback_raw(struct rcl_action_server_t *server,
                                           const struct rclc_goal_handle_t *goal,
                                           const uint8_t *feedback,
                                           size_t feedback_len);

NROS_PUBLIC
rcl_ret_t rclc_action_succeed(struct rcl_action_server_t *server,
                              const struct rclc_goal_handle_t *goal,
                              const uint8_t *result,
                              size_t result_len);

NROS_PUBLIC
rcl_ret_t rclc_action_abort(struct rcl_action_server_t *server,
                            const struct rclc_goal_handle_t *goal,
                            const uint8_t *result,
                            size_t result_len);

NROS_PUBLIC
rcl_ret_t rclc_action_canceled(struct rcl_action_server_t *server,
                               const struct rclc_goal_handle_t *goal,
                               const uint8_t *result,
                               size_t result_len);

NROS_PUBLIC
rcl_ret_t rclc_action_execute(struct rcl_action_server_t *server,
                              const struct rclc_goal_handle_t *goal);

NROS_PUBLIC
rcl_ret_t rclc_action_server_get_active_goal_count(struct rcl_action_server_t *server,
                                                   size_t *out);

NROS_PUBLIC const char *rcl_action_server_get_action_name(const struct rcl_action_server_t *server);

NROS_PUBLIC
bool rclc_action_server_goal_exists(struct rcl_action_server_t *server,
                                    const struct rclc_goal_handle_t *goal);

NROS_PUBLIC
rcl_ret_t rclc_action_expire_goals(struct rcl_action_server_t *server,
                                   size_t *num_expired);

NROS_PUBLIC
rcl_ret_t rclc_action_get_goal_status(const struct rcl_action_server_t *server,
                                      const struct rclc_goal_handle_t *goal,
                                      enum rclc_goal_status_t *status);

NROS_PUBLIC
rcl_ret_t rcl_action_server_fini(struct rcl_action_server_t *server,
                                 struct rcl_node_t *node);

NROS_PUBLIC
rcl_ret_t rclc_action_server_init_default(rclc_action_server_t *action_server,
                                          struct rcl_node_t *node,
                                          struct rclc_support_t *support,
                                          const struct rclc_action_type_t *type_support,
                                          const char *action_name);

NROS_PUBLIC
rcl_ret_t rclc_executor_add_action_server(struct rclc_executor_t *executor,
                                          rclc_action_server_t *action_server,
                                          size_t handles_number,
                                          void *ros_goal_request,
                                          size_t ros_goal_request_size,
                                          rclc_action_server_handle_goal_callback_t goal_callback,
                                          rclc_action_server_handle_cancel_callback_t cancel_callback,
                                          void *context);

NROS_PUBLIC
rcl_ret_t rclc_action_send_result(struct rclc_action_goal_handle_t *goal_handle,
                                  rcl_action_goal_state_t status,
                                  void *ros_response);

NROS_PUBLIC
rcl_ret_t rclc_action_publish_feedback(struct rclc_action_goal_handle_t *goal_handle,
                                       void *ros_feedback);

NROS_PUBLIC
rcl_ret_t rclc_action_server_fini(rclc_action_server_t *action_server,
                                  struct rcl_node_t *node);

NROS_PUBLIC
rcl_ret_t rclc_polling_action_server_init(struct rclc_polling_action_server_t *server,
                                          const struct rcl_node_t *node,
                                          const struct rclc_action_type_t *type_info,
                                          const char *action_name);

NROS_PUBLIC rcl_ret_t rclc_polling_action_server_fini(struct rclc_polling_action_server_t *server);

NROS_PUBLIC
rcl_ret_t rclc_polling_action_server_get_active_goal_count(struct rclc_polling_action_server_t *server,
                                                           size_t *out);

NROS_PUBLIC
bool rclc_polling_action_server_goal_exists(struct rclc_polling_action_server_t *server,
                                            const struct rclc_goal_handle_t *goal);

NROS_PUBLIC
rcl_ret_t rclc_polling_action_server_expire_goals(struct rclc_polling_action_server_t *server,
                                                  size_t *num_expired);

NROS_PUBLIC
int32_t rclc_polling_action_server_try_recv_goal_request_raw(struct rclc_polling_action_server_t *server,
                                                             uint8_t *buf,
                                                             size_t buf_len,
                                                             uint8_t (*goal_id_out)[16],
                                                             int64_t *sequence_number_out);

NROS_PUBLIC
rcl_ret_t rclc_polling_action_server_accept_goal_raw(struct rclc_polling_action_server_t *server,
                                                     const uint8_t (*goal_id)[16],
                                                     int64_t sequence_number);

NROS_PUBLIC
rcl_ret_t rclc_polling_action_server_reject_goal_raw(struct rclc_polling_action_server_t *server,
                                                     int64_t sequence_number);

NROS_PUBLIC
rcl_ret_t rclc_polling_action_server_publish_feedback_raw(struct rclc_polling_action_server_t *server,
                                                          const uint8_t (*goal_id)[16],
                                                          const uint8_t *feedback_cdr,
                                                          size_t feedback_len);

NROS_PUBLIC
rcl_ret_t rclc_polling_action_server_complete_goal_raw(struct rclc_polling_action_server_t *server,
                                                       const uint8_t (*goal_id)[16],
                                                       enum rclc_goal_status_t status,
                                                       const uint8_t *result_cdr,
                                                       size_t result_len);

NROS_PUBLIC
int32_t rclc_polling_action_server_try_recv_cancel_request_raw(struct rclc_polling_action_server_t *server,
                                                               uint8_t (*goal_id_out)[16],
                                                               int64_t *sequence_number_out,
                                                               enum rclc_goal_status_t *current_status_out);

NROS_PUBLIC
rcl_ret_t rclc_polling_action_server_send_cancel_reply_raw(struct rclc_polling_action_server_t *server,
                                                           int64_t sequence_number,
                                                           enum rclc_cancel_return_code_t return_code,
                                                           const uint8_t (*accepted)[16],
                                                           size_t accepted_count);

NROS_PUBLIC
int32_t rclc_polling_action_server_try_handle_get_result_raw(struct rclc_polling_action_server_t *server,
                                                             const uint8_t *default_result_cdr,
                                                             size_t default_result_len);

NROS_PUBLIC
rcl_ret_t rclc_polling_action_server_set_goal_wake_callback(struct rclc_polling_action_server_t *server,
                                                            struct rclc_wake_state_t *state,
                                                            void (*cb)(void*),
                                                            void *ctx);

NROS_PUBLIC
rcl_ret_t rclc_polling_action_server_set_cancel_wake_callback(struct rclc_polling_action_server_t *server,
                                                              struct rclc_wake_state_t *state,
                                                              void (*cb)(void*),
                                                              void *ctx);

NROS_PUBLIC
rcl_ret_t rclc_polling_action_server_set_get_result_wake_callback(struct rclc_polling_action_server_t *server,
                                                                  struct rclc_wake_state_t *state,
                                                                  void (*cb)(void*),
                                                                  void *ctx);

NROS_PUBLIC
rcl_ret_t rclc_subscription_set_liveliness_changed_callback(struct rcl_subscription_t *sub,
                                                            rclc_event_liveliness_changed_cb_t cb,
                                                            void *user_context);

NROS_PUBLIC
rcl_ret_t rclc_subscription_set_requested_deadline_missed_callback(struct rcl_subscription_t *sub,
                                                                   uint32_t deadline_ms,
                                                                   rclc_event_subscriber_count_cb_t cb,
                                                                   void *user_context);

NROS_PUBLIC
rcl_ret_t rclc_subscription_set_message_lost_callback(struct rcl_subscription_t *sub,
                                                      rclc_event_subscriber_count_cb_t cb,
                                                      void *user_context);

NROS_PUBLIC
rcl_ret_t rclc_publisher_set_liveliness_lost_callback(struct rcl_publisher_t *pub_,
                                                      rclc_event_publisher_count_cb_t cb,
                                                      void *user_context);

NROS_PUBLIC
rcl_ret_t rclc_publisher_set_offered_deadline_missed_callback(struct rcl_publisher_t *pub_,
                                                              uint32_t deadline_ms,
                                                              rclc_event_publisher_count_cb_t cb,
                                                              void *user_context);

NROS_PUBLIC
rcl_ret_t rclc_publisher_set_matched_callback(struct rcl_publisher_t *pub_,
                                              rclc_event_publisher_matched_cb_t cb,
                                              void *user_context);

NROS_PUBLIC
rcl_ret_t rclc_publisher_set_incompatible_type_callback(struct rcl_publisher_t *pub_,
                                                        rclc_event_publisher_incompatible_type_cb_t cb,
                                                        void *user_context);

NROS_PUBLIC
rcl_ret_t rclc_subscription_set_matched_callback(struct rcl_subscription_t *sub,
                                                 rclc_event_subscription_matched_cb_t cb,
                                                 void *user_context);

NROS_PUBLIC
rcl_ret_t rclc_subscription_set_incompatible_type_callback(struct rcl_subscription_t *sub,
                                                           rclc_event_subscription_incompatible_type_cb_t cb,
                                                           void *user_context);

NROS_PUBLIC struct rclc_executor_t rclc_executor_get_zero_initialized_executor(void);

NROS_PUBLIC
rcl_ret_t rclc_executor_init(struct rclc_executor_t *executor,
                             struct rcl_context_t *context,
                             size_t number_of_handles,
                             const struct rcl_allocator_t *allocator);

NROS_PUBLIC
rcl_ret_t rclc_executor_set_timeout(struct rclc_executor_t *executor,
                                    uint64_t timeout_ns);

NROS_PUBLIC rcl_ret_t rclc_executor_ping(struct rclc_executor_t *executor, int32_t timeout_ms);

NROS_PUBLIC
rcl_ret_t rclc_executor_get_node_names(struct rclc_executor_t *executor,
                                       rclc_node_visit_fn visit,
                                       void *ctx);

NROS_PUBLIC
rcl_ret_t rclc_executor_get_topic_names_and_types(struct rclc_executor_t *executor,
                                                  rclc_names_and_types_visit_fn visit,
                                                  void *ctx);

NROS_PUBLIC
rcl_ret_t rclc_executor_get_service_names_and_types(struct rclc_executor_t *executor,
                                                    rclc_names_and_types_visit_fn visit,
                                                    void *ctx);

NROS_PUBLIC
rcl_ret_t rclc_executor_count_publishers(struct rclc_executor_t *executor,
                                         const char *topic_name,
                                         size_t *out_count);

NROS_PUBLIC
rcl_ret_t rclc_executor_count_subscribers(struct rclc_executor_t *executor,
                                          const char *topic_name,
                                          size_t *out_count);

NROS_PUBLIC
rcl_ret_t rclc_executor_count_clients(struct rclc_executor_t *executor,
                                      const char *service_name,
                                      size_t *out_count);

NROS_PUBLIC
rcl_ret_t rclc_executor_count_services(struct rclc_executor_t *executor,
                                       const char *service_name,
                                       size_t *out_count);

NROS_PUBLIC
rcl_ret_t rclc_executor_wait_for_publishers(struct rclc_executor_t *executor,
                                            const char *topic_name,
                                            size_t count,
                                            uint32_t timeout_ms);

NROS_PUBLIC
rcl_ret_t rclc_executor_wait_for_subscribers(struct rclc_executor_t *executor,
                                             const char *topic_name,
                                             size_t count,
                                             uint32_t timeout_ms);

NROS_PUBLIC
rcl_ret_t rclc_executor_get_publisher_names_and_types_by_node(struct rclc_executor_t *executor,
                                                              const char *node_name,
                                                              const char *node_namespace,
                                                              rclc_names_and_types_visit_fn visit,
                                                              void *ctx);

NROS_PUBLIC
rcl_ret_t rclc_executor_get_subscriber_names_and_types_by_node(struct rclc_executor_t *executor,
                                                               const char *node_name,
                                                               const char *node_namespace,
                                                               rclc_names_and_types_visit_fn visit,
                                                               void *ctx);

NROS_PUBLIC
rcl_ret_t rclc_executor_get_service_names_and_types_by_node(struct rclc_executor_t *executor,
                                                            const char *node_name,
                                                            const char *node_namespace,
                                                            rclc_names_and_types_visit_fn visit,
                                                            void *ctx);

NROS_PUBLIC
rcl_ret_t rclc_executor_get_client_names_and_types_by_node(struct rclc_executor_t *executor,
                                                           const char *node_name,
                                                           const char *node_namespace,
                                                           rclc_names_and_types_visit_fn visit,
                                                           void *ctx);

NROS_PUBLIC
rcl_ret_t rclc_executor_get_publishers_info_by_topic(struct rclc_executor_t *executor,
                                                     const char *topic_name,
                                                     rclc_endpoint_info_visit_fn visit,
                                                     void *ctx);

NROS_PUBLIC
rcl_ret_t rclc_executor_get_subscriptions_info_by_topic(struct rclc_executor_t *executor,
                                                        const char *topic_name,
                                                        rclc_endpoint_info_visit_fn visit,
                                                        void *ctx);

NROS_PUBLIC
rcl_ret_t rclc_executor_set_semantics(struct rclc_executor_t *executor,
                                      enum rclc_executor_semantics_t semantics);

NROS_PUBLIC
rcl_ret_t rclc_executor_node_init(struct rclc_executor_t *executor,
                                  struct rcl_node_t *node,
                                  const char *name,
                                  const struct rcl_node_options_t *options);

NROS_PUBLIC
rcl_ret_t rclc_executor_set_trigger(struct rclc_executor_t *executor,
                                    rclc_executor_trigger_t trigger,
                                    void *context);

NROS_PUBLIC
bool rclc_executor_trigger_any(const struct rclc_executor_trigger_handle_t *handles,
                               size_t size,
                               void *obj);

NROS_PUBLIC
bool rclc_executor_trigger_all(const struct rclc_executor_trigger_handle_t *handles,
                               size_t size,
                               void *obj);

NROS_PUBLIC
bool rclc_executor_trigger_always(const struct rclc_executor_trigger_handle_t *handles,
                                  size_t size,
                                  void *obj);

NROS_PUBLIC
bool rclc_executor_trigger_one(const struct rclc_executor_trigger_handle_t *handles,
                               size_t size,
                               void *obj);

NROS_PUBLIC
bool rclc_executor_trigger_index(const struct rclc_executor_trigger_handle_t *handles,
                                 size_t size,
                                 void *obj);

NROS_PUBLIC
rcl_ret_t rclc_executor_add_subscription_raw_validated(struct rclc_executor_t *executor,
                                                       struct rcl_subscription_t *subscription,
                                                       rclc_subscription_validated_callback_t callback,
                                                       void *context,
                                                       enum rclc_executor_handle_invocation_t invocation);

NROS_PUBLIC
rcl_ret_t rclc_executor_add_subscription_with_context(struct rclc_executor_t *executor,
                                                      struct rcl_subscription_t *subscription,
                                                      void *msg,
                                                      rclc_subscription_callback_with_context_t callback,
                                                      void *context,
                                                      enum rclc_executor_handle_invocation_t invocation);

NROS_PUBLIC
rcl_ret_t rclc_executor_add_subscription(struct rclc_executor_t *executor,
                                         struct rcl_subscription_t *subscription,
                                         void *msg,
                                         rclc_subscription_callback_t callback,
                                         enum rclc_executor_handle_invocation_t invocation);

NROS_PUBLIC
rcl_ret_t rclc_executor_add_subscription_raw(struct rclc_executor_t *executor,
                                             struct rcl_subscription_t *subscription,
                                             rclc_subscription_raw_callback_t callback,
                                             void *context,
                                             enum rclc_executor_handle_invocation_t invocation);

NROS_PUBLIC
rcl_ret_t rclc_executor_add_subscription_raw_with_info(struct rclc_executor_t *executor,
                                                       const struct rcl_node_t *node,
                                                       const char *topic_name,
                                                       const char *type_name,
                                                       const char *type_hash,
                                                       const struct rclc_qos_t *qos,
                                                       rclc_subscription_info_callback_t callback,
                                                       void *context);

NROS_PUBLIC
rcl_ret_t rclc_executor_add_subscription_with_info(struct rclc_executor_t *executor,
                                                   struct rcl_subscription_t *subscription,
                                                   rclc_subscription_info_callback_t callback,
                                                   void *context,
                                                   enum rclc_executor_handle_invocation_t invocation);

NROS_PUBLIC
rcl_ret_t rclc_executor_add_timer(struct rclc_executor_t *executor,
                                  struct rcl_timer_t *timer);

NROS_PUBLIC
rcl_ret_t rclc_executor_add_subscription_in_group(struct rclc_executor_t *executor,
                                                  struct rcl_subscription_t *subscription,
                                                  rclc_subscription_raw_callback_t callback,
                                                  void *context,
                                                  enum rclc_executor_handle_invocation_t invocation,
                                                  const char *callback_group);

NROS_PUBLIC
rcl_ret_t rclc_executor_add_timer_in_group(struct rclc_executor_t *executor,
                                           struct rcl_timer_t *timer,
                                           const char *callback_group);

NROS_PUBLIC
rcl_ret_t rclc_executor_add_service_raw(struct rclc_executor_t *executor,
                                        struct rcl_service_t *service,
                                        rclc_service_raw_callback_t callback,
                                        void *context);

NROS_PUBLIC
rcl_ret_t rclc_executor_add_service_raw_with_request_id(struct rclc_executor_t *executor,
                                                        struct rcl_service_t *service,
                                                        rclc_service_raw_callback_with_request_id_t callback,
                                                        void *context);

NROS_PUBLIC
rcl_ret_t rclc_executor_add_service(struct rclc_executor_t *executor,
                                    struct rcl_service_t *service,
                                    void *request_msg,
                                    void *response_msg,
                                    rclc_service_callback_t callback);

NROS_PUBLIC
rcl_ret_t rclc_executor_add_service_with_request_id(struct rclc_executor_t *executor,
                                                    struct rcl_service_t *service,
                                                    void *request_msg,
                                                    void *response_msg,
                                                    rclc_service_callback_with_request_id_t callback);

NROS_PUBLIC
rcl_ret_t rclc_executor_add_service_with_context(struct rclc_executor_t *executor,
                                                 struct rcl_service_t *service,
                                                 void *request_msg,
                                                 void *response_msg,
                                                 rclc_service_callback_with_context_t callback,
                                                 void *context);

NROS_PUBLIC
rcl_ret_t rclc_executor_add_client(struct rclc_executor_t *executor,
                                   struct rcl_client_t *client,
                                   void *response_msg,
                                   rclc_client_callback_t callback);

NROS_PUBLIC
rcl_ret_t rclc_executor_add_client_with_request_id(struct rclc_executor_t *executor,
                                                   struct rcl_client_t *client,
                                                   void *response_msg,
                                                   rclc_client_callback_with_request_id_t callback);

NROS_PUBLIC
rcl_ret_t rclc_executor_attach_client(struct rclc_executor_t *executor,
                                      struct rcl_client_t *client);

NROS_PUBLIC
rcl_ret_t rclc_executor_attach_action_server(struct rclc_executor_t *executor,
                                             struct rcl_action_server_t *server);

NROS_PUBLIC
rcl_ret_t rclc_executor_attach_action_client(struct rclc_executor_t *executor,
                                             struct rcl_action_client_t *client);

NROS_PUBLIC
rcl_ret_t rclc_executor_remove_action_server(struct rclc_executor_t *executor,
                                             struct rcl_action_server_t *server);

NROS_PUBLIC
rcl_ret_t rclc_executor_remove_action_client(struct rclc_executor_t *executor,
                                             struct rcl_action_client_t *client);

NROS_PUBLIC
rcl_ret_t rclc_executor_remove_subscription(struct rclc_executor_t *executor,
                                            const struct rcl_subscription_t *subscription);

NROS_PUBLIC
rcl_ret_t rclc_executor_remove_timer(struct rclc_executor_t *executor,
                                     const struct rcl_timer_t *timer);

NROS_PUBLIC
rcl_ret_t rclc_executor_remove_service(struct rclc_executor_t *executor,
                                       const struct rcl_service_t *service);

NROS_PUBLIC
rcl_ret_t rclc_executor_remove_client(struct rclc_executor_t *executor,
                                      const struct rcl_client_t *client);

NROS_PUBLIC
rcl_ret_t rclc_executor_spin_some(struct rclc_executor_t *executor,
                                  uint64_t timeout_ns);

NROS_PUBLIC rcl_ret_t rclc_executor_spin(struct rclc_executor_t *executor);

NROS_PUBLIC
rcl_ret_t rclc_executor_spin_period(struct rclc_executor_t *executor,
                                    uint64_t period_ns);

NROS_PUBLIC
rcl_ret_t rclc_executor_spin_one_period(struct rclc_executor_t *executor,
                                        uint64_t period_ns);

NROS_PUBLIC rcl_ret_t rclc_executor_cancel(struct rclc_executor_t *executor);

NROS_PUBLIC bool rclc_executor_is_spinning(const struct rclc_executor_t *executor);

NROS_PUBLIC rcl_ret_t rclc_executor_fini(struct rclc_executor_t *executor);

NROS_PUBLIC int rclc_executor_get_handle_count(const struct rclc_executor_t *executor);

NROS_PUBLIC size_t rclc_executor_get_arena_used(const struct rclc_executor_t *executor);

NROS_PUBLIC size_t rclc_executor_get_arena_capacity(const struct rclc_executor_t *executor);

NROS_PUBLIC
rcl_ret_t rclc_executor_get_level(const struct rclc_executor_t *executor,
                                  uint8_t *level);

NROS_PUBLIC rcl_ret_t rclc_executor_set_level(struct rclc_executor_t *executor, uint8_t level);

NROS_PUBLIC uint8_t rclc_levels_max(void);

NROS_PUBLIC rcl_ret_t rclc_levels_set_count(uint8_t n);

NROS_PUBLIC uint8_t rclc_levels_count(void);

NROS_PUBLIC bool rclc_level_last_spin_us(uint8_t level, uint32_t *us);

NROS_PUBLIC bool rclc_levels_alive(void);

NROS_PUBLIC bool rclc_levels_take_alive(void);

NROS_PUBLIC bool rclc_executor_is_valid(const struct rclc_executor_t *executor);

NROS_PUBLIC int rclc_executor_get_remaining_handles(const struct rclc_executor_t *executor);

NROS_PUBLIC rclc_sched_context_id_t rclc_executor_default_sched_context_id(void);

NROS_PUBLIC
rcl_ret_t rclc_executor_add_time_triggered_dispatcher(struct rclc_executor_t *executor,
                                                      uint32_t major_frame_us);

NROS_PUBLIC
rcl_ret_t rclc_executor_create_sched_context(struct rclc_executor_t *executor,
                                             const struct rclc_sched_context_t *cfg,
                                             rclc_sched_context_id_t *out_sc_id);

NROS_PUBLIC
rcl_ret_t rclc_executor_bind_handle_to_sched_context(struct rclc_executor_t *executor,
                                                     size_t handle,
                                                     rclc_sched_context_id_t sc_id);

NROS_PUBLIC
rcl_ret_t rclc_executor_add_pre_shutdown_callback(struct rclc_executor_t *executor,
                                                  rclc_shutdown_callback_t callback,
                                                  void *context,
                                                  rclc_shutdown_callback_handle_t *out_handle);

NROS_PUBLIC
rcl_ret_t rclc_executor_add_on_shutdown_callback(struct rclc_executor_t *executor,
                                                 rclc_shutdown_callback_t callback,
                                                 void *context,
                                                 rclc_shutdown_callback_handle_t *out_handle);

NROS_PUBLIC
rcl_ret_t rclc_executor_remove_pre_shutdown_callback(struct rclc_executor_t *executor,
                                                     rclc_shutdown_callback_handle_t handle);

NROS_PUBLIC
rcl_ret_t rclc_executor_remove_on_shutdown_callback(struct rclc_executor_t *executor,
                                                    rclc_shutdown_callback_handle_t handle);

NROS_PUBLIC struct rcl_guard_condition_t rcl_get_zero_initialized_guard_condition(void);

NROS_PUBLIC
rcl_ret_t rclc_node_create_guard_condition(struct rcl_node_t *node,
                                           struct rcl_guard_condition_t *out,
                                           rclc_guard_condition_callback_t callback,
                                           void *context);

NROS_PUBLIC
rcl_ret_t rclc_node_get_graph_guard_condition(struct rcl_node_t *node,
                                              struct rcl_guard_condition_t *out,
                                              rclc_guard_condition_callback_t callback,
                                              void *context);

NROS_PUBLIC rcl_ret_t rclc_guard_condition_trigger(struct rcl_guard_condition_t *guard);

NROS_PUBLIC rcl_ret_t rcl_trigger_guard_condition(struct rcl_guard_condition_t *guard);

NROS_PUBLIC bool rclc_guard_condition_is_triggered(const struct rcl_guard_condition_t *guard);

NROS_PUBLIC rcl_ret_t rclc_guard_condition_clear(struct rcl_guard_condition_t *guard);

NROS_PUBLIC bool rclc_guard_condition_is_valid(const struct rcl_guard_condition_t *guard);

NROS_PUBLIC rcl_ret_t rcl_guard_condition_fini(struct rcl_guard_condition_t *guard);

NROS_PUBLIC struct rcl_lifecycle_state_machine_t rclc_lifecycle_get_zero_initialized(void);

NROS_PUBLIC rcl_ret_t rclc_lifecycle_init(struct rcl_lifecycle_state_machine_t *sm);

NROS_PUBLIC rcl_ret_t rclc_lifecycle_fini(struct rcl_lifecycle_state_machine_t *sm);

NROS_PUBLIC
rcl_ret_t rclc_lifecycle_state_machine_change_state(struct rcl_lifecycle_state_machine_t *sm,
                                                    uint8_t transition_id);

NROS_PUBLIC
uint8_t rclc_lifecycle_get_current_state(const struct rcl_lifecycle_state_machine_t *sm);

NROS_PUBLIC
rcl_ret_t rclc_lifecycle_state_machine_register_on_configure(struct rcl_lifecycle_state_machine_t *sm,
                                                             rclc_lifecycle_callback_t cb,
                                                             void *context);

NROS_PUBLIC
rcl_ret_t rclc_lifecycle_state_machine_register_on_activate(struct rcl_lifecycle_state_machine_t *sm,
                                                            rclc_lifecycle_callback_t cb,
                                                            void *context);

NROS_PUBLIC
rcl_ret_t rclc_lifecycle_state_machine_register_on_deactivate(struct rcl_lifecycle_state_machine_t *sm,
                                                              rclc_lifecycle_callback_t cb,
                                                              void *context);

NROS_PUBLIC
rcl_ret_t rclc_lifecycle_state_machine_register_on_cleanup(struct rcl_lifecycle_state_machine_t *sm,
                                                           rclc_lifecycle_callback_t cb,
                                                           void *context);

NROS_PUBLIC
rcl_ret_t rclc_lifecycle_register_on_shutdown(struct rcl_lifecycle_state_machine_t *sm,
                                              rclc_lifecycle_callback_t cb,
                                              void *context);

NROS_PUBLIC
rcl_ret_t rclc_lifecycle_register_on_error(struct rcl_lifecycle_state_machine_t *sm,
                                           rclc_lifecycle_callback_t cb,
                                           void *context);

NROS_PUBLIC const char *rclc_lifecycle_transition_label(uint8_t transition_id);

NROS_PUBLIC const char *rclc_lifecycle_state_label(uint8_t state_id);

NROS_PUBLIC uint8_t rclc_lifecycle_transition_start_state(uint8_t transition_id);

NROS_PUBLIC uint8_t rclc_lifecycle_transition_goal_state(uint8_t transition_id);

NROS_PUBLIC rcl_ret_t rclc_lifecycle_transition_graph(const uint8_t **out_ids, size_t *out_count);

NROS_PUBLIC rcl_ret_t rclc_executor_register_lifecycle_services(struct rclc_executor_t *executor);

NROS_PUBLIC uint8_t rclc_executor_lifecycle_get_current_state(struct rclc_executor_t *executor);

NROS_PUBLIC
rcl_ret_t rclc_executor_lifecycle_change_state(struct rclc_executor_t *executor,
                                               uint8_t transition_id);

NROS_PUBLIC
rcl_ret_t rclc_executor_lifecycle_register_on_configure(struct rclc_executor_t *executor,
                                                        rclc_lifecycle_callback_t cb,
                                                        void *context);

NROS_PUBLIC
rcl_ret_t rclc_executor_lifecycle_register_on_activate(struct rclc_executor_t *executor,
                                                       rclc_lifecycle_callback_t cb,
                                                       void *context);

NROS_PUBLIC
rcl_ret_t rclc_executor_lifecycle_register_on_deactivate(struct rclc_executor_t *executor,
                                                         rclc_lifecycle_callback_t cb,
                                                         void *context);

NROS_PUBLIC
rcl_ret_t rclc_executor_lifecycle_register_on_cleanup(struct rclc_executor_t *executor,
                                                      rclc_lifecycle_callback_t cb,
                                                      void *context);

NROS_PUBLIC
rcl_ret_t rclc_executor_lifecycle_register_on_shutdown(struct rclc_executor_t *executor,
                                                       rclc_lifecycle_callback_t cb,
                                                       void *context);

NROS_PUBLIC
rcl_ret_t rclc_executor_lifecycle_register_on_error(struct rclc_executor_t *executor,
                                                    rclc_lifecycle_callback_t cb,
                                                    void *context);

NROS_PUBLIC
rcl_ret_t rclc_node_set_qos_overrides(struct rcl_node_t *node,
                                      const struct rclc_qos_override_t *overrides,
                                      size_t len);

NROS_PUBLIC struct rcl_node_options_t rcl_node_get_default_options(void);

NROS_PUBLIC struct rcl_node_t rcl_get_zero_initialized_node(void);

NROS_PUBLIC
rcl_ret_t rclc_node_init_default(struct rcl_node_t *node,
                                 const char *name,
                                 const char *namespace_,
                                 const struct rclc_support_t *support);

NROS_PUBLIC
rcl_ret_t rclc_node_init_ex(struct rcl_node_t *node,
                            const struct rclc_support_t *support,
                            const char *name,
                            const struct rcl_node_options_t *options);

NROS_PUBLIC rcl_ret_t rcl_node_fini(struct rcl_node_t *node);

NROS_PUBLIC const char *rcl_node_get_name(const struct rcl_node_t *node);

NROS_PUBLIC const char *rcl_node_get_namespace(const struct rcl_node_t *node);

NROS_PUBLIC
rcl_ret_t rclc_get_fully_qualified_name(const char *node_name,
                                        const char *node_namespace,
                                        char *buf,
                                        size_t buf_len,
                                        size_t *out_len);

NROS_PUBLIC
rcl_ret_t rclc_node_get_fully_qualified_name(const struct rcl_node_t *node,
                                             char *buf,
                                             size_t buf_len,
                                             size_t *out_len);

NROS_PUBLIC const char *rclc_node_get_serialization_format(const struct rcl_node_t *node);

NROS_PUBLIC const char *rclc_node_get_rmw_implementation_identifier(const struct rcl_node_t *node);

NROS_PUBLIC const void *rclc_node_get_logger(const struct rcl_node_t *node);

NROS_PUBLIC bool rcl_node_is_valid(const struct rcl_node_t *node);

NROS_PUBLIC rcl_ret_t rcl_node_get_domain_id(const struct rcl_node_t *node, size_t *domain_id);

NROS_PUBLIC
rcl_ret_t rclc_node_resolve_name(const struct rcl_node_t *node,
                                 const char *input_name,
                                 bool only_expand,
                                 char *output_name,
                                 size_t output_size);

NROS_PUBLIC
const struct rcl_publisher_options_t *rcl_publisher_get_options(const struct rcl_publisher_t *publisher);

NROS_PUBLIC struct rcl_publisher_options_t rcl_publisher_get_default_options(void);

NROS_PUBLIC struct rcl_publisher_t rcl_get_zero_initialized_publisher(void);

NROS_PUBLIC
rcl_ret_t rclc_publisher_init_default(struct rcl_publisher_t *publisher,
                                      const struct rcl_node_t *node,
                                      const struct rclc_message_type_t *type_info,
                                      const char *topic_name);

NROS_PUBLIC
rcl_ret_t rclc_publisher_init_with_qos(struct rcl_publisher_t *publisher,
                                       const struct rcl_node_t *node,
                                       const struct rclc_message_type_t *type_info,
                                       const char *topic_name,
                                       const struct rclc_qos_t *qos);

NROS_PUBLIC
rcl_ret_t rclc_publisher_init_with_options(struct rcl_publisher_t *publisher,
                                           const struct rcl_node_t *node,
                                           const struct rclc_message_type_t *type_info,
                                           const char *topic_name,
                                           const struct rclc_qos_t *qos,
                                           const struct rcl_publisher_options_t *options);

NROS_PUBLIC
rcl_ret_t rclc_publish_serialized(const struct rcl_publisher_t *publisher,
                                  const uint8_t *data,
                                  size_t len);

NROS_PUBLIC
rcl_ret_t rcl_publish(const struct rcl_publisher_t *publisher,
                      const void *ros_message,
                      struct rmw_publisher_allocation_t *allocation);

NROS_PUBLIC
rcl_ret_t rclc_publisher_publish_streamed(const struct rcl_publisher_t *publisher,
                                          void (*size_cb)(size_t *out_total_len, void *user_ctx),
                                          void (*chunk_cb)(uint8_t *out_buf,
                                                           size_t cap,
                                                           size_t *out_written,
                                                           void *user_ctx),
                                          void *user_ctx);

NROS_PUBLIC rcl_ret_t rcl_publisher_assert_liveliness(const struct rcl_publisher_t *publisher);

NROS_PUBLIC
rcl_ret_t rclc_publisher_get_gid(const struct rcl_publisher_t *publisher,
                                 uint8_t *out_gid,
                                 size_t gid_capacity);

NROS_PUBLIC
rcl_ret_t rclc_publisher_loan(const struct rcl_publisher_t *publisher,
                              size_t requested_len,
                              uint8_t **out_buf,
                              size_t *out_cap,
                              void **out_token);

NROS_PUBLIC
rcl_ret_t rclc_publisher_commit(const struct rcl_publisher_t *publisher,
                                void *token,
                                size_t actual_len);

NROS_PUBLIC rcl_ret_t rclc_publisher_discard(const struct rcl_publisher_t *publisher, void *token);

NROS_PUBLIC
rcl_ret_t rclc_publisher_get_actual_qos(const struct rcl_publisher_t *publisher,
                                        struct rclc_qos_t *out_qos);

NROS_PUBLIC
rcl_ret_t rcl_publisher_fini(struct rcl_publisher_t *publisher,
                             struct rcl_node_t *node);

NROS_PUBLIC const char *rcl_publisher_get_topic_name(const struct rcl_publisher_t *publisher);

NROS_PUBLIC
rcl_ret_t rclc_publisher_get_subscription_count(const struct rcl_publisher_t *publisher,
                                                struct rclc_executor_t *executor,
                                                size_t *out_count);

NROS_PUBLIC bool rcl_publisher_is_valid(const struct rcl_publisher_t *publisher);

NROS_PUBLIC struct rclc_polling_service_t rclc_get_zero_initialized_polling_service(void);

NROS_PUBLIC struct rcl_service_t rcl_get_zero_initialized_service(void);

NROS_PUBLIC
rcl_ret_t rclc_service_init_with_qos(struct rcl_service_t *service,
                                     const struct rcl_node_t *node,
                                     const struct rclc_service_type_t *type_info,
                                     const char *service_name,
                                     const struct rclc_qos_t *qos);

NROS_PUBLIC
rcl_ret_t rclc_service_init_default(struct rcl_service_t *service,
                                    const struct rcl_node_t *node,
                                    const struct rclc_service_type_t *type_info,
                                    const char *service_name);

NROS_PUBLIC
const struct rcl_service_options_t *rcl_service_get_options(const struct rcl_service_t *service);

NROS_PUBLIC struct rcl_service_options_t rcl_service_get_default_options(void);

NROS_PUBLIC
rcl_ret_t rclc_service_init_with_options(struct rcl_service_t *service,
                                         const struct rcl_node_t *node,
                                         const struct rclc_service_type_t *type_info,
                                         const char *service_name,
                                         const struct rclc_qos_t *qos,
                                         const struct rcl_service_options_t *options);

NROS_PUBLIC rcl_ret_t rcl_service_fini(struct rcl_service_t *service, struct rcl_node_t *node);

NROS_PUBLIC
rcl_ret_t rclc_polling_service_init(struct rclc_polling_service_t *service,
                                    const struct rcl_node_t *node,
                                    const struct rclc_service_type_t *type_info,
                                    const char *service_name);

NROS_PUBLIC rcl_ret_t rclc_polling_service_fini(struct rclc_polling_service_t *service);

NROS_PUBLIC struct rclc_wake_state_t rclc_wake_state_get_zero_initialized(void);

NROS_PUBLIC
rcl_ret_t rclc_polling_service_set_wake_callback(struct rclc_polling_service_t *service,
                                                 struct rclc_wake_state_t *state,
                                                 void (*cb)(void*),
                                                 void *ctx);

NROS_PUBLIC
rcl_ret_t rclc_polling_client_set_wake_callback(struct rclc_polling_client_t *client,
                                                struct rclc_wake_state_t *state,
                                                void (*cb)(void*),
                                                void *ctx);

NROS_PUBLIC
int32_t rclc_polling_service_take_request_raw(struct rclc_polling_service_t *service,
                                              uint8_t *buf,
                                              size_t buf_len,
                                              int64_t *sequence_number);

NROS_PUBLIC
rcl_ret_t rclc_polling_service_send_response_raw(struct rclc_polling_service_t *service,
                                                 int64_t sequence_number,
                                                 const uint8_t *data,
                                                 size_t len);

NROS_PUBLIC void rclc_service_typed_report_error(int32_t error, const char *type_name);

NROS_PUBLIC const char *rcl_service_get_service_name(const struct rcl_service_t *service);

NROS_PUBLIC bool rcl_service_is_valid(const struct rcl_service_t *service);

NROS_PUBLIC struct rclc_polling_client_t rclc_get_zero_initialized_polling_client(void);

NROS_PUBLIC struct rcl_client_t rcl_get_zero_initialized_client(void);

NROS_PUBLIC
rcl_ret_t rclc_client_init_default(struct rcl_client_t *client,
                                   const struct rcl_node_t *node,
                                   const struct rclc_service_type_t *type_info,
                                   const char *service_name);

NROS_PUBLIC
rcl_ret_t rclc_client_init_with_qos(struct rcl_client_t *client,
                                    const struct rcl_node_t *node,
                                    const struct rclc_service_type_t *type_info,
                                    const char *service_name,
                                    const struct rclc_qos_t *qos);

NROS_PUBLIC
const struct rcl_client_options_t *rcl_client_get_options(const struct rcl_client_t *client);

NROS_PUBLIC struct rcl_client_options_t rcl_client_get_default_options(void);

NROS_PUBLIC
rcl_ret_t rclc_client_init_with_options(struct rcl_client_t *client,
                                        const struct rcl_node_t *node,
                                        const struct rclc_service_type_t *type_info,
                                        const char *service_name,
                                        const struct rclc_qos_t *qos,
                                        const struct rcl_client_options_t *options);

NROS_PUBLIC rcl_ret_t rcl_client_fini(struct rcl_client_t *client, struct rcl_node_t *node);

NROS_PUBLIC
rcl_ret_t rclc_polling_client_init(struct rclc_polling_client_t *client,
                                   const struct rcl_node_t *node,
                                   const struct rclc_service_type_t *type_info,
                                   const char *service_name);

NROS_PUBLIC rcl_ret_t rclc_polling_client_fini(struct rclc_polling_client_t *client);

NROS_PUBLIC
rcl_ret_t rclc_polling_client_send_request_raw(struct rclc_polling_client_t *client,
                                               const uint8_t *data,
                                               size_t len);

NROS_PUBLIC
rcl_ret_t rclc_polling_client_send_request_raw_seq(struct rclc_polling_client_t *client,
                                                   const uint8_t *data,
                                                   size_t len,
                                                   int64_t *sequence_number);

NROS_PUBLIC
int32_t rclc_polling_client_take_response_raw(struct rclc_polling_client_t *client,
                                              uint8_t *buf,
                                              size_t buf_len);

NROS_PUBLIC
int32_t rclc_polling_client_take_response_raw_seq(struct rclc_polling_client_t *client,
                                                  uint8_t *buf,
                                                  size_t buf_len,
                                                  int64_t *sequence_number);

NROS_PUBLIC
rcl_ret_t rclc_client_set_response_callback(struct rcl_client_t *client,
                                            rclc_response_callback_t callback,
                                            void *context);

NROS_PUBLIC rcl_ret_t rclc_client_set_timeout(struct rcl_client_t *client, uint32_t timeout_ms);

NROS_PUBLIC rcl_ret_t rclc_client_server_available(struct rcl_client_t *client, int32_t *out);

NROS_PUBLIC
rcl_ret_t rclc_client_wait_for_service(struct rcl_client_t *client,
                                       uint32_t timeout_ms);

NROS_PUBLIC
rcl_ret_t rcl_service_server_is_available(const struct rcl_node_t *node,
                                          const struct rcl_client_t *client,
                                          bool *is_available);

NROS_PUBLIC bool rclc_client_service_is_ready(const struct rcl_client_t *client);

NROS_PUBLIC
rcl_ret_t rclc_client_send_request_async(struct rcl_client_t *client,
                                         const uint8_t *request_data,
                                         size_t request_len);

NROS_PUBLIC
rcl_ret_t rclc_client_take_response(struct rcl_client_t *client,
                                    uint8_t *response_data,
                                    size_t response_capacity,
                                    size_t *response_len);

NROS_PUBLIC
rcl_ret_t rclc_client_call(struct rcl_client_t *client,
                           const uint8_t *request_data,
                           size_t request_len,
                           uint8_t *response_data,
                           size_t response_capacity,
                           size_t *response_len);

NROS_PUBLIC const char *rcl_client_get_service_name(const struct rcl_client_t *client);

NROS_PUBLIC bool rcl_client_is_valid(const struct rcl_client_t *client);

NROS_PUBLIC
rcl_ret_t rclc_service_request_subscription_get_actual_qos(const struct rcl_service_t *handle,
                                                           struct rclc_qos_t *out_qos);

NROS_PUBLIC
rcl_ret_t rclc_service_response_publisher_get_actual_qos(const struct rcl_service_t *handle,
                                                         struct rclc_qos_t *out_qos);

NROS_PUBLIC
rcl_ret_t rclc_client_request_publisher_get_actual_qos(const struct rcl_client_t *handle,
                                                       struct rclc_qos_t *out_qos);

NROS_PUBLIC
rcl_ret_t rclc_client_response_subscription_get_actual_qos(const struct rcl_client_t *handle,
                                                           struct rclc_qos_t *out_qos);

NROS_PUBLIC
rcl_ret_t rclc_polling_service_request_subscription_get_actual_qos(struct rclc_polling_service_t *handle,
                                                                   struct rclc_qos_t *out_qos);

NROS_PUBLIC
rcl_ret_t rclc_polling_service_response_publisher_get_actual_qos(struct rclc_polling_service_t *handle,
                                                                 struct rclc_qos_t *out_qos);

NROS_PUBLIC
rcl_ret_t rclc_polling_client_request_publisher_get_actual_qos(struct rclc_polling_client_t *handle,
                                                               struct rclc_qos_t *out_qos);

NROS_PUBLIC
rcl_ret_t rclc_polling_client_response_subscription_get_actual_qos(struct rclc_polling_client_t *handle,
                                                                   struct rclc_qos_t *out_qos);

NROS_PUBLIC struct rclc_polling_subscription_t rclc_get_zero_initialized_polling_subscription(void);

NROS_PUBLIC struct rcl_subscription_t rcl_get_zero_initialized_subscription(void);

NROS_PUBLIC
const struct rcl_subscription_options_t *rcl_subscription_get_options(const struct rcl_subscription_t *subscription);

NROS_PUBLIC struct rcl_subscription_options_t rcl_subscription_get_default_options(void);

NROS_PUBLIC
rcl_ret_t rclc_subscription_init_default(struct rcl_subscription_t *subscription,
                                         const struct rcl_node_t *node,
                                         const struct rclc_message_type_t *type_info,
                                         const char *topic_name);

NROS_PUBLIC
rcl_ret_t rclc_subscription_init_with_qos(struct rcl_subscription_t *subscription,
                                          const struct rcl_node_t *node,
                                          const struct rclc_message_type_t *type_info,
                                          const char *topic_name,
                                          const struct rclc_qos_t *qos);

NROS_PUBLIC
rcl_ret_t rclc_subscription_init_with_options(struct rcl_subscription_t *subscription,
                                              const struct rcl_node_t *node,
                                              const struct rclc_message_type_t *type_info,
                                              const char *topic_name,
                                              const struct rclc_qos_t *qos,
                                              const struct rcl_subscription_options_t *options);

NROS_PUBLIC
rcl_ret_t rclc_polling_subscription_init(struct rclc_polling_subscription_t *subscription,
                                         const struct rcl_node_t *node,
                                         const struct rclc_message_type_t *type_info,
                                         const char *topic_name);

NROS_PUBLIC
rcl_ret_t rclc_polling_subscription_init_with_qos(struct rclc_polling_subscription_t *subscription,
                                                  const struct rcl_node_t *node,
                                                  const struct rclc_message_type_t *type_info,
                                                  const char *topic_name,
                                                  const struct rclc_qos_t *qos);

NROS_PUBLIC
rcl_ret_t rclc_polling_subscription_set_wake_callback(struct rclc_polling_subscription_t *subscription,
                                                      struct rclc_wake_state_t *state,
                                                      void (*cb)(void*),
                                                      void *ctx);

NROS_PUBLIC
int32_t rclc_polling_subscription_take_serialized(struct rclc_polling_subscription_t *subscription,
                                                  uint8_t *buf,
                                                  size_t buf_len);

NROS_PUBLIC
rcl_ret_t rclc_polling_subscription_take(struct rclc_polling_subscription_t *subscription,
                                         void *ros_message,
                                         struct rmw_subscription_allocation_t *allocation);

NROS_PUBLIC
int32_t rclc_polling_subscription_take_validated(struct rclc_polling_subscription_t *subscription,
                                                 uint8_t *buf,
                                                 size_t buf_len,
                                                 struct rclc_integrity_status_t *out_status);

NROS_PUBLIC
int32_t rclc_polling_subscription_borrow(struct rclc_polling_subscription_t *subscription,
                                         const uint8_t **out_buf,
                                         size_t *out_len,
                                         void **out_token);

NROS_PUBLIC
rcl_ret_t rclc_polling_subscription_release(struct rclc_polling_subscription_t *subscription,
                                            void *token);

NROS_PUBLIC
int32_t rclc_polling_subscription_take_sequence(struct rclc_polling_subscription_t *subscription,
                                                uint8_t *buf,
                                                size_t per_msg_cap,
                                                size_t max_msgs,
                                                size_t *out_lens);

NROS_PUBLIC
rcl_ret_t rclc_subscription_get_actual_qos(const struct rcl_subscription_t *subscription,
                                           struct rclc_qos_t *out_qos);

NROS_PUBLIC
rcl_ret_t rclc_polling_subscription_get_actual_qos(struct rclc_polling_subscription_t *subscription,
                                                   struct rclc_qos_t *out_qos);

NROS_PUBLIC
rcl_ret_t rclc_polling_subscription_fini(struct rclc_polling_subscription_t *subscription);

NROS_PUBLIC
rcl_ret_t rcl_subscription_fini(struct rcl_subscription_t *subscription,
                                struct rcl_node_t *node);

NROS_PUBLIC
const char *rcl_subscription_get_topic_name(const struct rcl_subscription_t *subscription);

NROS_PUBLIC
rcl_ret_t rclc_subscription_get_publisher_count(const struct rcl_subscription_t *subscription,
                                                struct rclc_executor_t *executor,
                                                size_t *out_count);

NROS_PUBLIC bool rcl_subscription_is_valid(const struct rcl_subscription_t *subscription);

NROS_PUBLIC struct rclc_support_t rclc_support_get_zero_initialized(void);

NROS_PUBLIC
rcl_ret_t rclc_support_init(struct rclc_support_t *support,
                            int argc,
                            const char *const *argv,
                            const struct rcl_allocator_t *allocator);

NROS_PUBLIC
rcl_ret_t nros_c_support_init_baked(struct rclc_support_t *support,
                                    int argc,
                                    const char *const *argv,
                                    const struct rcl_allocator_t *allocator,
                                    const char *rmw,
                                    const char *locator,
                                    uint8_t domain_id);

NROS_PUBLIC
rcl_ret_t rclc_support_init_with_locator(struct rclc_support_t *support,
                                         const char *locator,
                                         uint8_t domain_id);

NROS_PUBLIC
rcl_ret_t rclc_support_init_named(struct rclc_support_t *support,
                                  const char *locator,
                                  uint8_t domain_id,
                                  const char *session_name);

NROS_PUBLIC
rcl_ret_t rclc_support_init_rmw(struct rclc_support_t *support,
                                const char *locator,
                                uint8_t domain_id,
                                const char *session_name,
                                const char *rmw);

NROS_PUBLIC rcl_ret_t rclc_support_fini(struct rclc_support_t *support);

NROS_PUBLIC bool rclc_support_is_valid(const struct rclc_support_t *support);

NROS_PUBLIC struct rcl_timer_t rcl_get_zero_initialized_timer(void);

NROS_PUBLIC
rcl_ret_t rclc_timer_init_default(struct rcl_timer_t *timer,
                                  struct rclc_support_t *support,
                                  uint64_t timeout_ns,
                                  rcl_timer_callback_t callback);

NROS_PUBLIC
rcl_ret_t rclc_timer_init_default2(struct rcl_timer_t *timer,
                                   struct rclc_support_t *support,
                                   uint64_t timeout_ns,
                                   rcl_timer_callback_t callback,
                                   bool autostart);

NROS_PUBLIC
rcl_ret_t rcl_timer_init(struct rcl_timer_t *timer,
                         struct rcl_clock_t *clock,
                         struct rcl_context_t *context,
                         int64_t period,
                         rcl_timer_callback_t callback,
                         struct rcl_allocator_t allocator);

NROS_PUBLIC
rcl_ret_t rcl_timer_init2(struct rcl_timer_t *timer,
                          struct rcl_clock_t *clock,
                          struct rcl_context_t *context,
                          int64_t period,
                          rcl_timer_callback_t callback,
                          struct rcl_allocator_t allocator,
                          bool autostart);

NROS_PUBLIC
rcl_ret_t rclc_timer_init_with_info(struct rcl_timer_t *timer,
                                    const struct rcl_clock_t *clock,
                                    uint64_t period_ns,
                                    rclc_timer_callback_with_info_t callback,
                                    bool autostart);

NROS_PUBLIC rcl_ret_t rcl_timer_cancel(struct rcl_timer_t *timer);

NROS_PUBLIC rcl_ret_t rcl_timer_reset(struct rcl_timer_t *timer);

NROS_PUBLIC rcl_ret_t rcl_timer_fini(struct rcl_timer_t *timer);

NROS_PUBLIC bool rclc_timer_is_valid(const struct rcl_timer_t *timer);

NROS_PUBLIC uint64_t rclc_timer_get_period(const struct rcl_timer_t *timer);

NROS_PUBLIC
rcl_ret_t rcl_timer_get_time_until_next_call(const struct rcl_timer_t *timer,
                                             int64_t *time_until_next_call_ns);

NROS_PUBLIC rcl_ret_t rcl_timer_is_canceled(const struct rcl_timer_t *timer, bool *is_canceled);

NROS_PUBLIC rcl_ret_t rcl_timer_is_ready(const struct rcl_timer_t *timer, bool *is_ready);

NROS_PUBLIC
rcl_ret_t rcl_timer_get_time_since_last_call(const struct rcl_timer_t *timer,
                                             int64_t *time_since_last_call_ns);

NROS_PUBLIC
rcl_ret_t rcl_timer_exchange_period(const struct rcl_timer_t *timer,
                                    int64_t new_period,
                                    int64_t *old_period);

NROS_PUBLIC
rcl_ret_t rcl_timer_get_next_call_time(const struct rcl_timer_t *timer,
                                       int64_t *next_call_time);
 
#ifdef __cplusplus
}  // extern "C"
#endif  // __cplusplus
 
#endif  /* NROS_GENERATED_H */