Class List

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

Nluabridge
CStack< E, std::enable_if_t< std::is_enum_v< E > > >
Nwelder
Ncarriages
Cmarker_resolution	Stitch-welding resolution: bind only where welder's markers say to
Cgreedy_resolution	Tack-welding resolution: bind an unmarked library greedily
Cbasic_carriage	A carriage: welder's reflection-driven traversal, parameterized on a Resolution (which markers it obeys)
Ndetail	The stored forms of the annotation vocabulary
Caccessor_spec	The stored form of a getter / setter mark: which property half the function supplies, for which languages, under which (optional) explicit name
Cany_type	A placeholder class type for shape-probing a member template inside a concept
Ccontainer_spec	One row of the reference-container table: a container template paired with the opaque binder kind it uses
Cdoc_spec	The stored form of a doc annotation: a summary docstring
Cenum_doc	The raw documentation pieces of an enum, handed to a style to assemble
Cenumerator_doc	One enumerator's documentation for the enum_doc list: its bound (target-language) name and its doc text
Cexclude_spec	The stored form of an exclude mark: the languages a member is hidden from
Cfield_access	Splice-based accessors for data member Mem — the pointer-to-member-free route the rods bind a protected field through
Cfixed_string	A string literal captured by value, length included, so it can live in a structural annotation constant
Cfunction_doc	The raw documentation pieces of a function, handed to a style to assemble
Cinclude_spec	The stored form of an include mark: the languages a member is opted into
Ckeep_alive_pair	A keep_alive lifetime dependency: a (nurse, patient) index pair
Ckeep_alive_spec	The stored form of a keep_alive annotation: a lifetime dependency between two of a call's entities, addressed by pybind11/nanobind's index convention (0 = the return value, 1 = the first argument — the implicit this for a method — 2 = the second, …)
Cmodule_welder	Pick the entry macro's welder: the user's optional override, else the rod's default welder::welder<rod>
Cmodule_welder< Default, First, Rest... >
Cno_reassign_spec	The stored form of a no_reassign mark: the languages a data member is bound read-only** for, independent of whether its C++ type is const
Conly_spec	The stored form of an only mark: the complete set of languages a member may bind for — implicitly, not for any other
Cparam_doc	One function parameter's documentation: its identifier (nullptr if unnamed) and its doc text (nullptr if undocumented)
Cpolicy_spec	The stored form of a policy annotation
Cproperty_entry	One resolved property: its getter and its (optional) setter
Creturn_doc_spec	The stored form of a returns annotation: a function's return-value doc
Creturn_policy_spec	The stored form of a return_policy annotation: a return-value policy, optionally scoped to some languages
Cscoped_registration	The scope-aware registration oracle: Resolution widened with the member-alias registrations of one class
Csynthesized_comparison
Ctparam_doc	One documented template parameter of an entity: the parameter's name (as spelled in the tparam annotation) and its doc text
Ctparam_spec	The stored form of a tparam annotation: one template parameter's doc
Ctrust_bindable_spec	The stored form of a trust_bindable member mark
Cweld_as_spec	The stored form of a weld_as annotation: a forced target-language name
Cweld_protected_spec	The stored form of a policy::weld_protected annotation: the languages a type's protected members are admitted for
Cweld_spec	The stored form of a weld annotation: the mask of target languages
Cwrapper_spec	One row of the element-wise STL-wrapper table
Ndiag
Clang_out_of_mask_range	Thrown by lang_bit (<welder/annotations.hpp>) when a lang value lies past the 32-bit language-mask width — instead of an opaque shift-overflow error
Cdangling_return_policy	Thrown by validate_return_policy (<welder/reflect.hpp>) — every rod runs it at its per-overload bind site — when a reference-category return_policy meets a by-value return
Cbare_mark_only	Thrown by member_bound (<welder/reflect.hpp>) when a member carries a bare [[=welder::mark::only]] — "only, for every language" restricts nothing, so the mark must be called
Cno_matching_virtual_slot	Thrown by virtual_slot (<welder/rods/python/trampoline.hpp>, reached through WELDER_PY_OVERRIDE_AS) when no overridable virtual of the class matches the requested name and function type
Cstale_hook_signature	Thrown by member_access_admitted (<welder/bind_traits.hpp>) when a resolution still declares its optional protected_participates hook under the superseded two-argument signature — which would otherwise be silently ignored (the detection is a requires probe)
Cmarked_move_constructor	Thrown by validate_move_ctor_marks (<welder/bind_traits.hpp>) — the carriage runs it for every welded class — when a move constructor carries an include/only mark
Caccessor_name_too_long	Thrown by the accessor_name factory helper (<welder/annotations.hpp>) when a getter/setter explicit property name exceeds the spec's inline capacity (the spec is deliberately not length-templated — see accessor_name_capacity)
Cmalformed_getter	Thrown by property_entries (<welder/bind_traits.hpp>) when a [[=welder::getter]] sits on a function that is not a getter shape: it must be a const member function taking no parameters and returning a value
Cmalformed_setter	Thrown by property_entries (<welder/bind_traits.hpp>) when a [[=welder::setter]] sits on a function that is not a setter shape: it must be a member function taking exactly one parameter
Caccessor_role_conflict	Thrown by property_entries (<welder/bind_traits.hpp>) when one function carries both a getter and a setter mark for the same language — a function supplies one property half, never both
Cduplicate_property_accessor	Thrown by property_entries (<welder/bind_traits.hpp>) when two getters (or two setters) resolve to the same property name for one language — a property has exactly one function per half
Csetter_without_getter	Thrown by property_entries (<welder/bind_traits.hpp>) when a participating setter's property has no participating getter in that language — welder binds no write-only properties
Caccessor_weld_as_conflict	Thrown by property_entries (<welder/bind_traits.hpp>) when an accessor-marked function also carries a weld_as — the accessor's explicit name is the property's rename tool, so the two would fight
Cstatic_property_accessor	Thrown by property_entries (<welder/bind_traits.hpp>) on an accessor-marked static member function: static properties are not supported yet (deferred — the Python frameworks have def_property_static, the Lua rods have no equivalent surface)
Cvirtual_property_accessor	Thrown by property_entries (<welder/bind_traits.hpp>) on an accessor-marked virtual member function: both Python rods dispatch overrides through a by-name attribute lookup, and a property object under that name would silently break the override protocol — rejected rather than bound subtly wrong
Cproperty_name_collision	Thrown by property_entries (<welder/bind_traits.hpp>) when a resolved property name collides with a bound data member or a (non-accessor) method of the same class surface
Nnaming
Cnone	The identity style: bind every C++ identifier unchanged
Cuniform	A single-convention style: reshape every kind to convention Kind, whatever the source spelling
Nrods
Nluabridge
Crod	The LuaBridge3 rod: a stateless policy type satisfying welder::rod
Cmodule_scope	A copyable handle to a welded module (or submodule) table: the borrowed Lua state plus the namespace path from the global table
Csession	Per-module session — unused: LuaBridge3 registers namespace variables as live properties eagerly (no deferred batch is needed, unlike sol2's live- variable proxy), so this is empty and open_module/close_module are no-ops
Cclass_handle	The class handle threaded from make_class to the add_* hooks: enough to re-open the class (its module, its Lua name) plus the C++ type (via type, recovered by the per-member hooks from decltype)
Cenum_handle	The enum handle threaded from make_enum to add_enumerator: the enclosing module, the enum's Lua name (a nested namespace of values) and whether it is scoped (an unscoped enum also mirrors its names onto the module)
Nluacats
Cclass_writer	A class handle
Cdocument	The growing LuaCATS document shared by every writer handle
Cenum_writer	An enum handle: the value table text accumulated by add_enumerator, flushed as a ---@enum block by RAII (same rationale as class_writer)
Cfunc_overload	One overload of a callee, pre-rendered into the pieces a group needs: the summary doc, the ---@param block, the ---@return line, the function argument list, and the fun(…) signature for a ---@overload line
Cmodule_writer	A module handle: the shared document plus this (sub)module's dotted table path
Crod	The LuaCATS stub rod: a stateless policy satisfying welder::rod that emits text instead of registering a live module
Csession	No deferred module state
Ctable_decl	A module/submodule table to declare (prefix = {}), with its optional doc
Nnanobind
Crod	The nanobind rod: a stateless policy type satisfying welder::rod
Nopaque_containers
Cdocument	The accumulator threaded through the rod's emission hooks: the deduped set of reference containers the welded namespace uses, and the renderer for the finished header
Centry	One container to open opaque: its C++ spelling, its derived target name, and whether a by_value mark excluded it (kept in the set so a later use site can be reconciled, but skipped at render)
Crod	The opaque-container generator rod (satisfies welder::rod)
Cmodule_handle	A copyable handle onto the growing document threaded through every emission primitive (the rod's module_type)
Cclass_handle	The per-class handle: it carries the document so the per-member hooks (add_field / add_method / …) can collect from members and signatures
Cenum_handle	The enum handle — enums use no containers, so it carries nothing
Csession	No deferred module state
Npybind11
Crod	The pybind11 rod: a stateless policy type satisfying welder::rod
Cenum_handle	Owning handle for a py::native_enum<E>, plus the scope + name to reach the finalized enum object
Npython
Cby_value_spec	The stored form of a by_value mark (a plain tag — it carries no state)
Cgoogle_style	Google-style docstring assembly (the default)
Cnumpy_style	NumPy-style docstring assembly (numpydoc)
Cpep8	PEP 8 naming: CapWords (PascalCase) for classes and enum types, snake_case for everything callable or data — methods, static methods, free functions, data members (properties), namespace variables — and submodules
Cscanned_trampoline	The outcome of scanning a base's namespace for its trampoline-annotated subclass
Csphinx_style	Sphinx-style docstring assembly (reStructuredText field lists)
Ctrampoline_spec	The stored form of a trampoline mark (a plain tag — it carries no state)
Nsol2
Cmetamethod	A member operator's sol2 metamethod, or {…, nullptr} if welder does not expose it
Crod	The sol2 rod: a stateless policy type satisfying welder::rod
Csession	Per-module session: the deferred state for live namespace variables
C_enum_binding	A welded enum's binding: the name→value table, how to mirror a name onto the enclosing scope, and whether the enum is scoped (an unscoped enum also mirrors its names onto the enclosing scope, like C++)
Ntrampolines
Cdocument	The growing generated header: the trampoline struct bodies and their trampoline_for registrations, kept apart so the structs can share one namespace generated { … } block and the registrations sit at global scope
Crod	The trampoline-generator rod: a stateless welder::rod that, instead of registering a live module, appends a compilable trampoline struct (plus its trampoline_for registration) for every welded virtual type it visits
Cmodule_handle	A copyable handle onto the growing document that the driver threads through every emission primitive (the rod's module_type)
Cclass_handle	The class handle the driver threads to the per-member hooks
Cenum_handle	The enum handle
Csession	No deferred module state
Cbind_flat_spec	The stored form of a bind_flat mark (a plain tag — it carries no state)
Cwelded_registration	The default registration oracle of the bindability gate: a program-defined class/enum type counts as registered iff it is welded for the language
Cwelder	Welder's binding entry point, parameterized on a rod