This inheritance list is sorted roughly, but not completely, alphabetically:

CActionClient< ActionT >	Comfortable wrapper around rclcpp_action::Client<ActionT>
CActionServerBase< ActionT >	Base class that hides the boilerplate of running a ROS 2 action server
CActionServerBase< easyfleet_interfaces::action::Manipulation >
CManipulationActionServerBase	Fixes ActionServerBase's action type to easyfleet_interfaces/Manipulation, so a concrete manipulation backend (MoveIt, a vendor SDK, a fake mock, ...) only has to subclass this and implement on_goal_received()/on_execute() – it never needs to spell out the action type itself
CManipulationFakeActionServer	Fake/mock implementation of the easyfleet_interfaces/Manipulation action
CManipulationFakeActionServer	Fake/mock implementation of the easyfleet_interfaces/Manipulation action
CManipulationFakeActionServer	Fake/mock implementation of the easyfleet_interfaces/Manipulation action
CManipulationFakeActionServer	Fake/mock implementation of the easyfleet_interfaces/Manipulation action
CActionServerBase< easyfleet_interfaces::action::Navigation >
CNavigationActionServerBase	Fixes ActionServerBase's action type to easyfleet_interfaces/Navigation, so a concrete navigation backend (Nav2, EasyNav, a fake mock, ...) only has to subclass this and implement on_goal_received()/on_execute() – it never needs to spell out the action type itself
CEasynavNavigationActionServer	Real navigation capability backed by EasyNav (via easynav::GoalManagerClient) and structured internally as a BehaviorTree.CPP tree
CNavigationFakeActionServer	Fake/mock implementation of the easyfleet_interfaces/Navigation action
CNavigationFakeActionServer	Fake/mock implementation of the easyfleet_interfaces/Navigation action
CActionServerBase< easyfleet_interfaces::action::Perception >
CPerceptionActionServerBase	Fixes ActionServerBase's action type to easyfleet_interfaces/Perception, so a concrete perception backend (a classic detector, a VLM-based one, a fake mock, ...) only has to subclass this and implement on_goal_received()/on_execute() – it never needs to spell out the action type itself
CPerceptionFakeActionServer	Fake/mock implementation of the easyfleet_interfaces/Perception action
CPerceptionFakeActionServer	Fake/mock implementation of the easyfleet_interfaces/Perception action
CPerceptionFakeActionServer	Fake/mock implementation of the easyfleet_interfaces/Perception action
CPerceptionFakeActionServer	Fake/mock implementation of the easyfleet_interfaces/Perception action
CCapabilityClient< ActionT >	The simplest possible way to ask a capability to do something
CCapabilityFactory	Pluginlib base class for "a thing that can build a capability node by name"
CCapabilityFactoryFor< ManipulationFakeActionServer >
CCapabilityFactoryFor< PerceptionFakeActionServer >
CCapabilityFactoryFor< ActionServerT >	Boilerplate-free CapabilityFactory for any Capability<ActionServerT>
CCapabilityInfo	Everything known about one running capability instance, gathered from its /capabilities (easyfleet_interfaces/CapabilityDescription) and /capabilities_status (easyfleet_interfaces/CapabilityStatus) messages
CCapabilityNodeBase	Non-template handle to an already-constructed Capability<ActionServerT> instance, exposing exactly the surface Robot/Deployment need to drive it – lifecycle transitions, its node (to add to an executor), and its identity – without needing to know ActionServerT
CCapability< ManipulationFakeActionServer >
CManipulationFakeCapability	The "manipulation" capability, backed by the fake/mock action server: a lifecycle node advertising a (mock) easyfleet_interfaces/Manipulation action, described by config/robot_2/manipulation.json
CManipulationFakeCapability	The "manipulation" capability, backed by the fake/mock action server: a lifecycle node advertising a (mock) easyfleet_interfaces/Manipulation action, described by config/robot_2/manipulation.json
CManipulationFakeCapability	The "manipulation" capability, backed by the fake/mock action server: a lifecycle node advertising a (mock) easyfleet_interfaces/Manipulation action, described by config/manipulation.json
CManipulationFakeCapability	The "manipulation" capability, backed by the fake/mock action server: a lifecycle node advertising a (mock) easyfleet_interfaces/Manipulation action, described by config/manipulation.json
CCapability< PerceptionFakeActionServer >
CPerceptionFakeCapability	The "perception" capability, backed by the fake/mock action server: a lifecycle node advertising a (mock) easyfleet_interfaces/Perception action, described by config/robot_1/perception.json
CPerceptionFakeCapability	The "perception" capability, backed by the fake/mock action server: a lifecycle node advertising a (mock) easyfleet_interfaces/Perception action, described by config/robot_1/perception.json
CPerceptionFakeCapability	The "perception" capability, backed by the fake/mock action server: a lifecycle node advertising a (mock) easyfleet_interfaces/Perception action, described by config/perception.json
CPerceptionFakeCapability	The "perception" capability, backed by the fake/mock action server: a lifecycle node advertising a (mock) easyfleet_interfaces/Perception action, described by config/perception.json
CCapability< EasynavNavigationActionServer >
CEasynavNavigationCapability	The "navigation" capability, backed by EasyNav: a lifecycle node advertising a real easyfleet_interfaces/Navigation action, described by config/easynav_robot/navigation_gazebo.json
CCapability< NavigationFakeActionServer >
CNavigationFakeCapability	The "navigation" capability, backed by the fake/mock action server: a lifecycle node advertising a (mock) easyfleet_interfaces/Navigation action, described by config/navigation.json
CNavigationFakeCapability	The "navigation" capability, backed by the fake/mock action server: a lifecycle node advertising a (mock) easyfleet_interfaces/Navigation action, described by config/navigation.json
CCapability< ActionServerT >	Lifecycle node that advertises a single action as a "capability"
CConflictDecision	Explains one pair's evaluation – only produced for pairs that are at least within ConflictParams::proximity_radius_m of each other (pairs nowhere near each other aren't worth reporting)
CConflictParams	Tunable geometry for imminent-conflict detection between two robots' planned paths
CDeployment	Everything one robot's process needs: load its capabilities, bring them up, run them until shutdown, tear them down
CFleetSession	Everything talking to a fleet from a mission-control process actually needs, regardless of what decides when to command which robot: the ROS node and background-spinning executor every RobotHandle rides on, one shared capability discovery pass, the registry of added robots, and the automatic status markers RobotHandle::run_capability() publishes
CActionClient< ActionT >::GoalResult	Terminal outcome of a goal, as delivered to a ResultCallback or returned by send_goal_and_wait()
CLifecycleNode
CCapability< ManipulationFakeActionServer >
CCapability< PerceptionFakeActionServer >
CCapability< EasynavNavigationActionServer >
CCapability< NavigationFakeActionServer >
CCapability< ActionServerT >	Lifecycle node that advertises a single action as a "capability"
CMapPublisherBase	One "map type" NavigationManagerNode can publish on /global_map
CCostmapMapPublisher	Publishes an OccupancyGrid map on /global_map
CNode
CNavigationManagerNode	Fleet-wide navigation manager
CCapabilityClient< ActionT >::Response	Final outcome of a request, as delivered to a ResponseCallback or returned by request_and_wait()
CRobotHandle	A remote robot's capabilities, as seen and commanded from a mission script
CRobotNavigationWatcher	Watches one robot's planned path and can pause/resume its navigation
CRoutesPublisher	Publishes a RoutesMap on /global_routes, and keeps it live-editable
CRunningCapabilityBase	Non-template interface RobotHandle holds one of per capability type it has ever run, so it doesn't need to know ActionT itself for anything but sending a fresh goal (see run(), on the concrete subclass only)
CRunningCapability< ActionT >	The one concrete RunningCapabilityBase implementation, parameterized by the actual action type a given capability type is run with
CSimpleController	The plain, manual controller: a mission script decides everything by hand (which robot runs which capability, when), SimpleController just hosts the FleetSession that makes talking to those robots possible
CStatefulActionNode
CFinish	Bookend BT node run after Navigate: takes 2 seconds and only prints a finishing message
CStartOff	Bookend BT node run before Navigate: takes 2 seconds and only prints a starting message
CNavigate	Drives EasyNav (via easynav::GoalManagerClient) to the waypoint named by the "goal_id" input port, resolved against a fixed id->pose registry (EasyNav itself has no named-waypoint concept – this node is where that resolution happens)
CStatusMarkerPublisher	Publishes a floating TEXT_VIEW_FACING marker above each robot's own base_link, showing a short, human-readable line of what that robot is currently doing (which capability, what state/result) – so watching the mission in RViz alone (no terminal) is enough for a non-expert to follow along
CThrottle	Value-semantics rate limiter: copies (e.g