Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 123456]

Nnlohmann
Cjsonb	A wrapper around nlohmann::json providing a qb::jsonb type, often used for binary JSON (BSON) or similar dense representations
Nqb
Nallocator
Cbase_pipe	Base class for the extensible buffer
Cpipe	Extensible buffer optimized for performance
Ncompression
Ndeflate
Cto_compress	Structure for passing compression parameters for deflate
Cto_uncompress	Structure for passing decompression parameters for deflate
Ngzip
Cto_compress	Structure for passing gzip compression parameters
Cto_uncompress	Structure for passing gzip decompression parameters
Ccompress_factory	Factory interface for creating compression providers
Ccompress_provider	Abstract interface for compression algorithm providers
Cdecompress_factory	Factory interface for creating decompression providers
Cdecompress_provider	Abstract interface for decompression algorithm providers
Coperation_result	Result of a compression/decompression operation
Ndetail
Chas_begin_end	Type trait to detect whether T has begin() and end() methods
Chas_const_iterator	Type trait to detect whether T has a const_iterator type
Cis_mappish_impl	Internal implementation to detect map-like types
Cis_mappish_impl< T, std::void_t< typename T::key_type, typename T::mapped_type, decltype(std::declval< T & >()[std::declval< const typename T::key_type & >()])> >	Specialization for types that have key_type, mapped_type, and operator[]
Cring_buffer_iterator	Iterator for ring_buffer
Ninternal
Cbest_size	Determines the optimal integer type for size storage based on max capacity
Cbest_size< _Size, false, true >	Specialization for sizes that fit in uint16_t but not uint8_t
Cbest_size< _Size, true, true >	Specialization for sizes that fit in uint8_t
Nio
Nasync
Nevent
Cbase	Base template class for all qb-io specific asynchronous event types
Cdisconnected	Event triggered when a connection is closed or lost
Cdispose	Event triggered just before an asynchronous I/O object is destroyed or cleaned up
Ceof	Event triggered when no more data is available for reading from an input stream
Ceos	Event triggered when all buffered data has been successfully written and sent to an output stream
Cextracted	Event triggered when a connection is extracted from an I/O object
Cfile	Event for file and directory attribute change monitoring
Chandshake	Event triggered when the handshake is complete
Cio	Event for file descriptor I/O readiness notifications (read/write)
Cpending_read	Event triggered when unprocessed data remains in the input buffer after protocol processing
Cpending_write	Event triggered when unsent data remains in the output buffer after a write operation
Csignal	Event for handling system signals asynchronously
Csignal<-1 >	Specialization for dynamic signal specification
Ctimer	Event for handling time-based operations (timers and timeouts)
Ntcp
Cacceptor	Handles accepting incoming TCP connections asynchronously
Cclient	Server-associated asynchronous TCP client
Cclient< _Derived, _Transport, void >
Cconnector	Handles asynchronous TCP connection establishment
Cserver	Asynchronous TCP server implementation
Nudp
Cclient	Asynchronous UDP client implementation
Cserver	Asynchronous UDP server implementation
CAProtocol	Abstract base class for I/O-component-aware protocols (CRTP)
Cbase	Base class for all qb-io asynchronous components that interact with the event listener
Cdirectory_watcher	CRTP base class for watching a directory for attribute changes
Cfile	Asynchronous file operations handler
Cfile_watcher	CRTP base class for watching a single file for attribute changes and processing its contents
Cinput	CRTP base class for managing asynchronous input operations with protocol processing
Cio	CRTP base class for managing bidirectional asynchronous I/O operations with protocol processing
Cio_handler	Session manager for asynchronous IO
CIProtocol	Base interface for all message processing protocols
CIRegisteredKernelEvent	Interface for kernel event registration and invocation
Clistener	Central event loop manager for asynchronous IO operations
CRegisteredKernelEvent	Template wrapper for concrete event handlers and their associated libev watchers
Coutput	CRTP base class for managing asynchronous output operations
CTimeout	Utility class to execute a function after a specified timeout using the event loop
Cwith_timeout	CRTP base class that adds timeout functionality to derived asynchronous components
Nepoll
CPoller	High-level epoll event poller
CProxy	Base class for epoll operations
Nprotocol
Caccept	Protocol for handling the acceptance of new network connections
Chandshake	Protocol for handling the handshake of a new connection
Nssl
CCertificate	Structure to hold essential SSL certificate information
CSession	Opaque wrapper for an OpenSSL SSL_SESSION object
Ntcp
Nssl
Clistener	Class implementing a secure SSL/TLS TCP listener for accepting encrypted connections
Csocket	Class implementing secure SSL/TLS TCP socket functionality
Clistener	Class implementing a TCP listener for accepting incoming connections
Csocket	Class implementing TCP socket functionality for reliable, stream-oriented communication
Ntransport
Caccept	Connection acceptance transport for TCP connections
Cfile	File transport providing stream-based access to local files
Csaccept	Secure connection acceptance transport for SSL/TLS TCP connections
Cstcp	Secure TCP (SSL/TLS) transport providing encrypted stream communication
Ctcp	TCP transport providing reliable, stream-based network communication
Cudp	UDP transport providing connectionless, datagram-based communication
Cidentity	Identifies a UDP endpoint, extending qb::io::endpoint with hashing support
Chasher	Hash function for udp::identity objects
CProxyOut	Proxy class providing a stream-like interface for sending UDP datagrams
Nudp
Csocket	Class implementing UDP socket functionality for datagram-based communication
Ccerr	Thread-safe error output class
Ccout	Thread-safe console output class
Cistream	Input stream template class
Costream	Output stream template class
Cstream	Combined input/output stream template class
Curi	Class for parsing, manipulating, and representing URIs
Cuse	Helper template providing type aliases for integrating qb-io asynchronous components
Ctcp	Provides type aliases for TCP-based asynchronous components
Cudp	Provides type aliases for UDP-based asynchronous components
Nlockfree
Nmpsc
Cringbuffer	Multi-Producer Single-Consumer ring buffer with fixed number of producers
Cringbuffer< T, max_size, 0 >	Multi-Producer Single-Consumer ring buffer with runtime-determined number of producers
Nspsc
Ninternal
Cringbuffer	Base implementation of the Single-Producer Single-Consumer ringbuffer
Cringbuffer	Fixed-size implementation of the SPSC ringbuffer
Cringbuffer< T, 0 >	Dynamic-size implementation of the SPSC ringbuffer
CSpinLock	A spinlock implementation for lightweight thread synchronization
Nprotocol
Nbase
Cbyte_terminated	Protocol for messages delimited by a specific single byte character
Cbytes_terminated	Protocol for messages delimited by a specific sequence of bytes (a string literal)
Csize_as_header	Protocol for messages where the payload is preceded by a fixed-size header indicating its length
Ntext
Cbasic_binary	Protocol for binary messages where the payload is preceded by a fixed-size header indicating its length
Cmessage	Structure representing a binary message
Cbasic_text	Protocol for text messages delimited by a specific character, yielding a specified string type
Cmessage	Structure representing a text message
Cjson	Protocol for parsing null-terminated JSON messages
Cmessage	Structure representing a JSON message
Cjson_packed	Protocol for parsing null-terminated, MessagePack encoded JSON messages
Cmessage	Structure representing a MessagePack encoded JSON message
Nrouter
Ninternal
CEventPolicy	Base policy for event handling
Cmemh	Multiple-Event Multiple-Handler router (generic version)
Cmemh< _RawEvent, _CleanEvent, void >	Multiple-Event Multiple-Handler router (heterogeneous version)
CSafeDispose	Helper to ensure safe disposal of events
Cmesh	Multiple-Event Single-Handler router
Csemh	Single-Event Multiple-Handler router (generic version)
Csemh< _RawEvent, void >	Single-Event Multiple-Handler router (heterogeneous version)
Csesh	Single-Event Single-Handler router
CActor	Base class for all actors in the qb framework
CEventBuilder	Helper class for building and sending events to actors
Cactor_factory_param	Utility struct for processing actor factory constructor arguments
CActorId	Unique identifier for actors
CActorProxy	Internal helper class for actor type and name management
CAskData	Event template for requesting data, typically without carrying data itself
CBroadcastId	Specialized ActorId for broadcasting messages to all actors on a core
CCoreIdBitSet	Efficient representation of a set of core IDs using a bitset
Citerator	Iterator for traversing set bits in a CoreIdBitSet
CCoreInitializer	Handles pre-start configuration for a single VirtualCore
CActorBuilder	Helper to fluently build multiple Actors for a CoreInitializer
CCoreSet	Manages a set of core identifiers
CCoreSpawnerParameter	Internal structure for passing parameters to core spawning functions
CCPU	Provides platform-independent access to CPU information
Ccrtp	Base class for implementing the Curiously Recurring Template Pattern (CRTP)
Ccrypto	Provides cryptographic operations and utilities
CArgon2Params	Parameters for the Argon2 algorithm
Cbase64	Base64 encoding and decoding utilities
CDuration	Represents a duration with nanosecond precision
CEvent	Base class for all events in the actor system
CEventQOS0	Event with lowest quality of service level
Cexpand	Utility for forcing parameter pack expansion in certain contexts
CFillEvent	Event template for events that carry and "fill" data
Chas_insert	Type trait to check if a type T has an insert(T::const_iterator, T::value_type) member function
Chas_insert< T, typename std::enable_if< std::is_same< decltype(std::declval< T >().insert(std::declval< typename T::const_iterator >(), std::declval< typename T::value_type >())), typename T::iterator >::value >::type >	Specialization for types with a valid insert method
Chas_push_back	Type trait to check if a type T has a push_back(T::value_type) member function
Chas_push_back< T, typename std::enable_if< std::is_void< decltype(std::declval< T >().push_back(std::declval< typename T::value_type >()))>::value >::type >	Specialization for types with a valid push_back method
CHighResTimePoint	Represents a high-resolution time point
CIActorFactory	Interface for actor factory classes
CICallback	Interface for actor callbacks
Cicase_basic_map	A case-insensitive map implementation
Cindex_builder	Generates a compile-time sequence of indices as an indexes_tuple
Cindex_builder< 0, indexes_tuple< Indexes... > >	Base case for index_builder
Cindex_builder< num, indexes_tuple< Indexes... > >	Recursive case for index_builder
Cindexes_tuple	Represents a compile-time tuple of size_t indexes
Cis_associative_container	Type trait to check if type T is an associative container
Cis_container	Type trait to check if a type T is a container
Cis_container< char[N]>	Specialization for character arrays, which are not considered containers
Cis_container< std::pair< T1, T2 > >	Specialization for std::pair, which is a container
Cis_container< std::tuple< Args... > >	Specialization for std::tuple, which is a container
Cis_container< std::valarray< T > >	Specialization for std::valarray, which is a container
Cis_container< T[N]>	Specialization for array types, which are containers
Cis_inserter	Type trait to check if a type T is an inserter iterator (e.g., std::back_inserter)
Cis_inserter< T, typename std::enable_if<!std::is_void< typename T::container_type >::value >::type >	Specialization for types that have a container_type
Cis_map_iterator	Type trait to check if an iterator T points to map elements (i.e., std::pair)
Cis_mappish	Type trait to check if a type T is map-like
Cis_pair	Type trait to check if a type is a std::pair
Cis_pair< std::pair< T, U > >	Specialization for std::pair, which returns true
Cis_sequence_container	Type trait to check if type T is a sequence container
Cis_specialization_of
Cis_specialization_of< Template, Template< Args... > >
Cis_terator	Type trait to check if a type Iter is an iterator
Cis_terator< Iter, typename std::enable_if< is_inserter< Iter >::value >::type >	Specialization for inserter iterators
Cis_terator< Iter, typename std::enable_if<!std::is_void< typename std::iterator_traits< Iter >::value_type >::value >::type >	Specialization for standard iterators
Citerator_type	Type trait to extract the value_type from an iterator Iter
Citerator_type< Iter, typename std::enable_if< is_inserter< Iter >::value >::type >	Specialization for inserter iterators
Cjwt	Comprehensive JWT implementation for the QB IO library
CCreateOptions	JWT creation options
CTokenParts	JWT token parts
CValidationResult	Result of JWT validation containing error code and payload if valid
CVerifyOptions	JWT verification options
CKillEvent	Event used to terminate an actor
CLocalTimePoint	Represents a local time point with nanosecond precision
CLogTimer	Utility for logging execution time of code blocks
CMain	The main controller for the QB Actor Framework engine
Cnocopy	Base class to make derived classes non-copyable
Cnth_type	Metafunction for selecting the Nth type in a variadic template parameter pack
Cnth_type< 0, T, Y... >	Base case for nth_type template
Cnth_type< num, T, Y... >	Recursive case for nth_type template
CPingEvent	Event used for actor health checks
CPipe	Represents a communication channel between actors
Cremove_reference_if	Conditionally removes a reference from type T if cond is true
Cremove_reference_if< T, true >	Specialization that actually removes the reference
CRequireEvent	Event used to query actor status
Cring_buffer	A fixed-size ring buffer (circular buffer) implementation
CScopedTimer	Utility for measuring code block execution time
CService	Internal base class for services
CServiceActor	SingletonActor base class, ensuring one instance per VirtualCore per Tag
CServiceEvent	Event type for service-to-service communication
CSharedCoreCommunication	Manages inter-core communication infrastructure (mailboxes)
CSignalEvent	Event used to handle system signals
Cstring	Fixed-size string with optimized storage
Cstring_to_lower	Utility class for case-insensitive string operations
CTActorFactory	Templated actor factory implementation
CTimePoint	Represents a point in time with nanosecond precision
CTscTimePoint	Represents a time point based on CPU's timestamp counter
Ctype	Template struct used for type identification in the event system
CUnregisterCallbackEvent	Event used to unregister an actor's callback
CUtcTimePoint	Represents a UTC time point with nanosecond precision
CVirtualCore	Manages a virtual processing core (worker thread) in the actor system
CWithData	Event template that includes data payload
CWithoutData	Event template without data payload
Nstd
Chash< qb::ActorId >	Specialization of std::hash for qb::ActorId
Chash< qb::Duration >	Specialization of std::hash for qb::Duration
Chash< qb::jsonb >	Specialization of std::hash for qb::jsonb
Chash< qb::TimePoint >	Specialization of std::hash for qb::TimePoint
Cambiguate	Helper class to force ambiguity of class members
CCacheLine	A structure automatically aligned to cache line boundaries
CEventBucket	A structure aligned to event bucket boundaries, typically matching cache line size
Cgot_type	Type trait to check if a type exists
Cgot_type< A >	Specialization that indicates the type exists
Chas_member	Type trait to check if a type has a specific member
Csig_check	Helper for signature checking