sol.hpp File Reference

#include <stdexcept>
#include <string>
#include <tuple>
#include <cstddef>
#include <functional>
#include <type_traits>
#include <cstdint>
#include <memory>
#include <array>
#include <iterator>
#include <iosfwd>
#include <lua.hpp>
#include <stddef.h>
#include <limits.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include <errno.h>
#include <stdio.h>
#include <utility>
#include <initializer_list>
#include <cassert>
#include <unordered_map>
#include <exception>
#include <cstring>
#include <cctype>
#include <locale>
#include <vector>
#include <forward_list>
#include <algorithm>
#include <cmath>
#include <limits>
#include <sstream>
#include <cstdio>
#include <bitset>

Go to the source code of this file.

Classes
class	sol::basic_reference< main_only >
struct	sol::proxy_base< Super >
struct	sol::proxy< Table, Key >
class	sol::usertype< T >
class	sol::simple_usertype< T >
class	sol::basic_table_core< top_level, base_type >
struct	sol::basic_environment< base_type >
class	sol::basic_function< base_t, aligned >
class	sol::basic_protected_function< base_t, aligned, handler_t >
class	sol::basic_object< base_type >
class	sol::basic_userdata< base_type >
class	sol::basic_lightuserdata< base_type >
class	sol::basic_coroutine< base_t >
class	sol::basic_thread< base_t >
struct	sol::as_table_t< T >
struct	sol::as_container_t< T >
struct	sol::nested< T >
struct	sol::light< L >
struct	sol::user< U >
struct	sol::as_args_t< T >
struct	sol::protect_t< T >
struct	sol::filter_wrapper< F, Filters >
struct	sol::usertype_traits< T >
struct	sol::unique_usertype_traits< T >
struct	sol::detail::direct_error_tag
class	sol::error
struct	sol::types< Args >
struct	sol::meta::detail::tuple_types_< Args >
struct	sol::meta::detail::tuple_types_< std::tuple< Args... > >
struct	sol::meta::pop_front_type< Arg >
struct	sol::meta::pop_front_type< types< Args... > >
struct	sol::meta::pop_front_type< types< Arg, Args... > >
struct	sol::meta::meta_detail::check_deducible_signature< F >
struct	sol::meta::meta_detail::check_deducible_signature< F >::nat
struct	sol::meta::has_deducible_signature< F >
struct	sol::meta::meta_detail::void_tuple_element< I, T >
struct	sol::meta::meta_detail::void_tuple_element< I, std::tuple<> >
struct	sol::meta::meta_detail::basic_traits< it_is_noexcept, has_c_variadic, T, R, Args >
struct	sol::meta::meta_detail::fx_traits< Signature, b >
struct	sol::meta::meta_detail::fx_traits< R(Args...), false >
struct	sol::meta::meta_detail::fx_traits< R(*)(Args...), false >
struct	sol::meta::meta_detail::fx_traits< R(Args...,...), false >
struct	sol::meta::meta_detail::fx_traits< R(*)(Args...,...), false >
struct	sol::meta::meta_detail::fx_traits< R(T::*)(Args...), false >
struct	sol::meta::meta_detail::fx_traits< R(T::*)(Args...,...), false >
struct	sol::meta::meta_detail::fx_traits< R(T::*)(Args...) const, false >
struct	sol::meta::meta_detail::fx_traits< R(T::*)(Args...,...) const, false >
struct	sol::meta::meta_detail::fx_traits< R(T::*)(Args...) const volatile, false >
struct	sol::meta::meta_detail::fx_traits< R(T::*)(Args...,...) const volatile, false >
struct	sol::meta::meta_detail::fx_traits< R(T::*)(Args...)&, false >
struct	sol::meta::meta_detail::fx_traits< R(T::*)(Args...,...)&, false >
struct	sol::meta::meta_detail::fx_traits< R(T::*)(Args...) const &, false >
struct	sol::meta::meta_detail::fx_traits< R(T::*)(Args...,...) const &, false >
struct	sol::meta::meta_detail::fx_traits< R(T::*)(Args...) const volatile &, false >
struct	sol::meta::meta_detail::fx_traits< R(T::*)(Args...,...) const volatile &, false >
struct	sol::meta::meta_detail::fx_traits< R(T::*)(Args...)&&, false >
struct	sol::meta::meta_detail::fx_traits< R(T::*)(Args...,...)&&, false >
struct	sol::meta::meta_detail::fx_traits< R(T::*)(Args...) const &&, false >
struct	sol::meta::meta_detail::fx_traits< R(T::*)(Args...,...) const &&, false >
struct	sol::meta::meta_detail::fx_traits< R(T::*)(Args...) const volatile &&, false >
struct	sol::meta::meta_detail::fx_traits< R(T::*)(Args...,...) const volatile &&, false >
struct	sol::meta::meta_detail::fx_traits< Signature, true >
struct	sol::meta::meta_detail::callable_traits< Signature, b >
struct	sol::meta::meta_detail::callable_traits< R(T::*), true >
struct	sol::meta::bind_traits< Signature >
struct	sol::basic_string_view< Char, Traits >
struct	sol::basic_string_view_hash< Ch, Tr >
struct	std::hash< ::sol::basic_string_view< Ch, Tr > >
struct	sol::meta::identity< T >
struct	sol::meta::is_tuple< Args >
struct	sol::meta::is_tuple< std::tuple< Args... > >
struct	sol::meta::is_builtin_type< T >
struct	sol::meta::unwrapped< T >
struct	sol::meta::unwrapped< std::reference_wrapper< T > >
struct	sol::meta::unwrap_unqualified< T >
struct	sol::meta::remove_member_pointer< T >
struct	sol::meta::remove_member_pointer< R T::* >
struct	sol::meta::remove_member_pointer< R T::*const >
struct	sol::meta::meta_detail::is_specialization_of< T, Templ >
struct	sol::meta::meta_detail::is_specialization_of< Templ< T... >, Templ >
struct	sol::meta::all_same< T,... >
struct	sol::meta::all_same< T, U, Args... >
struct	sol::meta::any_same< T,... >
struct	sol::meta::any_same< T, U, Args... >
struct	sol::meta::all< Args >
struct	sol::meta::all< T, Args... >
struct	sol::meta::any< Args >
struct	sol::meta::any< T, Args... >
struct	sol::meta::find_in_pack_v< V, Vs >
struct	sol::meta::find_in_pack_v< V, Vs1, Vs... >
struct	sol::meta::meta_detail::index_in_pack< I, T, Args >
struct	sol::meta::meta_detail::index_in_pack< I, T, T1, Args... >
struct	sol::meta::index_in_pack< T, Args >
struct	sol::meta::index_in< T, List >
struct	sol::meta::index_in< T, types< Args... > >
struct	sol::meta::at_in_pack< I, Args >
struct	sol::meta::at_in_pack< I, Arg, Args... >
struct	sol::meta::at_in_pack< 0, Arg, Args... >
struct	sol::meta::meta_detail::count_for_pack< Limit, I, Pred, Ts >
struct	sol::meta::count_for_pack< Pred, Ts >
struct	sol::meta::count_for< Pred, List >
struct	sol::meta::count_for< Pred, types< Args... > >
struct	sol::meta::count_for_to_pack< Limit, Pred, Ts >
struct	sol::meta::count_2_for_pack< Pred, Ts >
struct	sol::meta::return_type< Args >
struct	sol::meta::return_type< T >
struct	sol::meta::return_type<>
struct	sol::meta::meta_detail::always_true< typename >
struct	sol::meta::meta_detail::is_invokable_tester
struct	sol::meta::is_invokable< T >
struct	sol::meta::is_invokable< Fun(Args...)>
struct	sol::meta::meta_detail::is_callable< T, typename >
struct	sol::meta::meta_detail::is_callable< T, std::enable_if_t< std::is_final< unqualified_t< T > >::value &&std::is_class< unqualified_t< T > >::value &&std::is_same< decltype(void(&T::operator())), void >::value > >
struct	sol::meta::meta_detail::is_callable< T, std::enable_if_t<!std::is_final< unqualified_t< T > >::value &&std::is_class< unqualified_t< T > >::value &&std::is_destructible< unqualified_t< T > >::value > >
struct	sol::meta::meta_detail::is_callable< T, std::enable_if_t<!std::is_final< unqualified_t< T > >::value &&std::is_class< unqualified_t< T > >::value &&std::is_destructible< unqualified_t< T > >::value > >::F
struct	sol::meta::meta_detail::is_callable< T, std::enable_if_t<!std::is_final< unqualified_t< T > >::value &&std::is_class< unqualified_t< T > >::value &&std::is_destructible< unqualified_t< T > >::value > >::Derived
struct	sol::meta::meta_detail::is_callable< T, std::enable_if_t<!std::is_final< unqualified_t< T > >::value &&std::is_class< unqualified_t< T > >::value &&std::is_destructible< unqualified_t< T > >::value > >::Check< U, U >
struct	sol::meta::meta_detail::is_callable< T, std::enable_if_t<!std::is_final< unqualified_t< T > >::value &&std::is_class< unqualified_t< T > >::value &&!std::is_destructible< unqualified_t< T > >::value > >
struct	sol::meta::meta_detail::is_callable< T, std::enable_if_t<!std::is_final< unqualified_t< T > >::value &&std::is_class< unqualified_t< T > >::value &&!std::is_destructible< unqualified_t< T > >::value > >::F
struct	sol::meta::meta_detail::is_callable< T, std::enable_if_t<!std::is_final< unqualified_t< T > >::value &&std::is_class< unqualified_t< T > >::value &&!std::is_destructible< unqualified_t< T > >::value > >::Derived
struct	sol::meta::meta_detail::is_callable< T, std::enable_if_t<!std::is_final< unqualified_t< T > >::value &&std::is_class< unqualified_t< T > >::value &&!std::is_destructible< unqualified_t< T > >::value > >::Check< U, U >
struct	sol::meta::meta_detail::has_begin_end_impl
struct	sol::meta::meta_detail::has_key_type_impl
struct	sol::meta::meta_detail::has_mapped_type_impl
struct	sol::meta::meta_detail::has_value_type_impl
struct	sol::meta::meta_detail::has_iterator_impl
struct	sol::meta::meta_detail::has_key_value_pair_impl
struct	sol::meta::meta_detail::has_push_back_test< T >
struct	sol::meta::meta_detail::has_insert_test< T >
struct	sol::meta::meta_detail::has_insert_after_test< T >
struct	sol::meta::meta_detail::has_size_test< T >
struct	sol::meta::meta_detail::has_max_size_test< T >
struct	sol::meta::meta_detail::has_to_string_test< T >
struct	sol::meta::meta_detail::is_matched_lookup_impl< T, b >
struct	sol::meta::meta_detail::is_matched_lookup_impl< T, true >
struct	sol::meta::is_callable< T >
struct	sol::meta::has_begin_end< T >
struct	sol::meta::has_key_value_pair< T >
struct	sol::meta::has_key_type< T >
struct	sol::meta::has_mapped_type< T >
struct	sol::meta::has_iterator< T >
struct	sol::meta::has_value_type< T >
struct	sol::meta::is_associative< T >
struct	sol::meta::is_lookup< T >
struct	sol::meta::is_matched_lookup< T >
struct	sol::meta::is_pair< T >
struct	sol::meta::is_pair< std::pair< T1, T2 > >
struct	sol::meta::is_move_only< T >
struct	sol::meta::iterator_tag< T, typename >
struct	sol::meta::iterator_tag< T, std::conditional_t< false, typename T::iterator_category, void > >
struct	sol::detail::is_pointer_like< T >
struct	sol::detail::is_pointer_like< std::unique_ptr< T, D > >
struct	sol::detail::is_pointer_like< std::shared_ptr< T > >
struct	sol::detail::in_place_of_tag
struct	sol::detail::in_place_of_i< I >
struct	sol::detail::in_place_of_t< T >
struct	sol::in_place_tag
struct	sol::is_nothrow_move_constructible< T >
struct	sol::is_assignable< T, U >
struct	sol::is_nothrow_move_assignable< T >
struct	sol::is_nothrow_move_assignable< T >::has_nothrow_move_assign< X, has_any_move_assign >
struct	sol::is_nothrow_move_assignable< T >::has_nothrow_move_assign< X, true >
class	sol::optional< T >
struct	sol::detail_::has_overloaded_addressof< T >
struct	sol::trivial_init_t
struct	sol::nullopt_t
struct	sol::nullopt_t::init
class	sol::bad_optional_access
struct	sol::optional_base< T >
struct	sol::constexpr_optional_base< T >
class	sol::optional< T >
class	sol::optional< T & >
class	sol::optional< T && >
struct	std::hash< sol::optional< T > >
struct	std::hash< sol::optional< T & > >
struct	sol::meta::is_optional< T >
struct	sol::meta::is_optional< optional< T > >
struct	sol::stack::stack_detail::undefined_metatable< T >
struct	sol::detail::default_construct
struct	sol::detail::default_destruct
struct	sol::detail::deleter
struct	sol::detail::state_deleter
struct	sol::detail::tagged< Tag, T >
struct	sol::constructor_list< Args >
struct	sol::no_construction
struct	sol::call_construction
struct	sol::constructor_wrapper< Functions >
struct	sol::factory_wrapper< Functions >
struct	sol::destructor_wrapper< Function >
struct	sol::destructor_wrapper< void >
struct	sol::detail::filter_base_tag
struct	sol::static_stack_dependencies< Target, In >
struct	sol::returns_self_with< In >
struct	sol::stack_dependencies
struct	sol::filter_wrapper< F, Filters >
struct	sol::detail::unique_usertype< T >
struct	sol::detail::implicit_wrapper< T >
struct	sol::detail::unchecked_t
struct	sol::detail::yield_tag_t
struct	sol::lua_nil_t
struct	sol::detail::non_lua_nil_t
struct	sol::metatable_t
struct	sol::env_t
struct	sol::no_metatable_t
struct	sol::yielding_t< T >
struct	sol::unique_usertype_traits< T >
struct	sol::unique_usertype_traits< std::shared_ptr< T > >
struct	sol::unique_usertype_traits< std::unique_ptr< T, D > >
struct	sol::non_null< T >
struct	sol::function_sig< Args >
struct	sol::upvalue_index
struct	sol::raw_index
struct	sol::absolute_index
struct	sol::ref_index
struct	sol::stack_count
struct	sol::lightuserdata_value
struct	sol::userdata_value
struct	sol::light< L >
struct	sol::user< U >
struct	sol::metatable_registry_key< T >
struct	sol::closure< Upvalues >
struct	sol::closure<>
struct	sol::function_arguments< Sig, Ps >
struct	sol::as_table_t< T >
struct	sol::nested< T >
struct	sol::this_state
struct	sol::this_main_state
struct	sol::new_table
struct	sol::is_lua_reference< T >
struct	sol::is_lua_reference_or_proxy< T >
struct	sol::is_transparent_argument< T >
struct	sol::is_transparent_argument< this_state >
struct	sol::is_transparent_argument< this_main_state >
struct	sol::is_transparent_argument< this_environment >
struct	sol::is_transparent_argument< variadic_args >
struct	sol::is_variadic_arguments< T >
struct	sol::detail::is_initializer_list< T >
struct	sol::detail::is_initializer_list< std::initializer_list< T > >
struct	sol::detail::is_container< T, C >
struct	sol::detail::is_container< std::initializer_list< T > >
struct	sol::detail::is_container< T, std::enable_if_t< meta::is_string_like< meta::unqualified_t< T > >::value > >
struct	sol::detail::is_container< T, std::enable_if_t< meta::all< std::is_array< meta::unqualified_t< T > >, meta::neg< meta::any_same< std::remove_all_extents_t< meta::unqualified_t< T > >, char, wchar_t, char16_t, char32_t > > >::value > >
struct	sol::detail::is_container< T, std::enable_if_t< meta::all< meta::has_begin_end< meta::unqualified_t< T > >, meta::neg< is_initializer_list< meta::unqualified_t< T > > >, meta::neg< meta::is_string_like< meta::unqualified_t< T > > > >::value > >
struct	sol::is_container< T >
struct	sol::is_to_stringable< T >
struct	sol::detail::lua_type_of< T, typename >
struct	sol::detail::lua_type_of< std::basic_string< C, T, A > >
struct	sol::detail::lua_type_of< basic_string_view< C, T > >
struct	sol::detail::lua_type_of< char[N]>
struct	sol::detail::lua_type_of< wchar_t[N]>
struct	sol::detail::lua_type_of< char16_t[N]>
struct	sol::detail::lua_type_of< char32_t[N]>
struct	sol::detail::lua_type_of< char >
struct	sol::detail::lua_type_of< wchar_t >
struct	sol::detail::lua_type_of< char16_t >
struct	sol::detail::lua_type_of< char32_t >
struct	sol::detail::lua_type_of< const char * >
struct	sol::detail::lua_type_of< const char16_t * >
struct	sol::detail::lua_type_of< const char32_t * >
struct	sol::detail::lua_type_of< bool >
struct	sol::detail::lua_type_of< lua_nil_t >
struct	sol::detail::lua_type_of< nullopt_t >
struct	sol::detail::lua_type_of< detail::non_lua_nil_t >
struct	sol::detail::lua_type_of< std::nullptr_t >
struct	sol::detail::lua_type_of< error >
struct	sol::detail::lua_type_of< basic_table_core< b, Base > >
struct	sol::detail::lua_type_of< metatable_t >
struct	sol::detail::lua_type_of< basic_environment< B > >
struct	sol::detail::lua_type_of< env_t >
struct	sol::detail::lua_type_of< new_table >
struct	sol::detail::lua_type_of< as_table_t< T > >
struct	sol::detail::lua_type_of< std::initializer_list< T > >
struct	sol::detail::lua_type_of< basic_reference< b > >
struct	sol::detail::lua_type_of< stack_reference >
struct	sol::detail::lua_type_of< basic_object< Base > >
struct	sol::detail::lua_type_of< std::tuple< Args... > >
struct	sol::detail::lua_type_of< std::pair< A, B > >
struct	sol::detail::lua_type_of< void * >
struct	sol::detail::lua_type_of< const void * >
struct	sol::detail::lua_type_of< lightuserdata_value >
struct	sol::detail::lua_type_of< userdata_value >
struct	sol::detail::lua_type_of< light< T > >
struct	sol::detail::lua_type_of< user< T > >
struct	sol::detail::lua_type_of< basic_lightuserdata< Base > >
struct	sol::detail::lua_type_of< basic_userdata< Base > >
struct	sol::detail::lua_type_of< lua_CFunction >
struct	sol::detail::lua_type_of< std::remove_pointer_t< lua_CFunction > >
struct	sol::detail::lua_type_of< basic_function< Base, aligned > >
struct	sol::detail::lua_type_of< basic_protected_function< Base, aligned, Handler > >
struct	sol::detail::lua_type_of< basic_coroutine< Base > >
struct	sol::detail::lua_type_of< basic_thread< Base > >
struct	sol::detail::lua_type_of< std::function< Signature > >
struct	sol::detail::lua_type_of< optional< T > >
struct	sol::detail::lua_type_of< variadic_args >
struct	sol::detail::lua_type_of< variadic_results >
struct	sol::detail::lua_type_of< stack_count >
struct	sol::detail::lua_type_of< this_state >
struct	sol::detail::lua_type_of< this_main_state >
struct	sol::detail::lua_type_of< this_environment >
struct	sol::detail::lua_type_of< type >
struct	sol::detail::lua_type_of< T * >
struct	sol::detail::lua_type_of< T, std::enable_if_t< std::is_arithmetic< T >::value > >
struct	sol::detail::lua_type_of< T, std::enable_if_t< std::is_enum< T >::value > >
struct	sol::detail::lua_type_of< meta_function >
struct	sol::detail::lua_type_of< nested< T >, std::enable_if_t<::sol::is_container< T >::value > >
struct	sol::detail::lua_type_of< nested< T >, std::enable_if_t<!::sol::is_container< T >::value > >
struct	sol::detail::accumulate< C, v, V, Args >
struct	sol::detail::accumulate< C, v, V, T, Args... >
struct	sol::detail::accumulate_list< C, v, V, List >
struct	sol::detail::accumulate_list< C, v, V, types< Args... > >
struct	sol::is_unique_usertype< T >
struct	sol::lua_type_of< T >
struct	sol::lua_size< T >
struct	sol::lua_size< std::pair< A, B > >
struct	sol::lua_size< std::tuple< Args... > >
struct	sol::detail::void_<... >
struct	sol::detail::has_internal_marker_impl< T, typename >
struct	sol::detail::has_internal_marker_impl< T, typename void_< typename T::SOL_INTERNAL_UNSPECIALIZED_MARKER_ >::type >
struct	sol::detail::has_internal_marker< T >
struct	sol::is_lua_primitive< T >
struct	sol::is_main_threaded< T >
struct	sol::is_stack_based< T >
struct	sol::is_stack_based< variadic_args >
struct	sol::is_stack_based< unsafe_function_result >
struct	sol::is_stack_based< protected_function_result >
struct	sol::is_stack_based< stack_proxy >
struct	sol::is_stack_based< stack_proxy_base >
struct	sol::is_lua_primitive< T * >
struct	sol::is_lua_primitive< unsafe_function_result >
struct	sol::is_lua_primitive< protected_function_result >
struct	sol::is_lua_primitive< std::reference_wrapper< T > >
struct	sol::is_lua_primitive< user< T > >
struct	sol::is_lua_primitive< light< T > >
struct	sol::is_lua_primitive< optional< T > >
struct	sol::is_lua_primitive< as_table_t< T > >
struct	sol::is_lua_primitive< nested< T > >
struct	sol::is_lua_primitive< userdata_value >
struct	sol::is_lua_primitive< lightuserdata_value >
struct	sol::is_lua_primitive< non_null< T > >
struct	sol::is_proxy_primitive< T >
struct	sol::is_lua_index< T >
struct	sol::is_lua_index< raw_index >
struct	sol::is_lua_index< absolute_index >
struct	sol::is_lua_index< ref_index >
struct	sol::is_lua_index< upvalue_index >
struct	sol::lua_bind_traits< Signature >
struct	sol::is_table< T >
struct	sol::is_table< basic_table_core< x, T > >
struct	sol::is_function< T >
struct	sol::is_function< basic_function< T, aligned > >
struct	sol::is_function< basic_protected_function< T, aligned, Handler > >
struct	sol::is_lightuserdata< T >
struct	sol::is_lightuserdata< basic_lightuserdata< T > >
struct	sol::is_userdata< T >
struct	sol::is_userdata< basic_userdata< T > >
struct	sol::is_environment< T >
struct	sol::is_automagical< T >
struct	sol::detail::is_non_factory_constructor< T >
struct	sol::detail::is_non_factory_constructor< constructors< Args... > >
struct	sol::detail::is_non_factory_constructor< constructor_wrapper< Args... > >
struct	sol::detail::is_non_factory_constructor< no_construction >
struct	sol::detail::is_constructor< T >
struct	sol::detail::is_constructor< factory_wrapper< Args... > >
struct	sol::detail::is_constructor< protect_t< T > >
struct	sol::detail::is_constructor< filter_wrapper< F, Filters... > >
struct	sol::detail::is_destructor< T >
struct	sol::detail::is_destructor< destructor_wrapper< Fx > >
struct	sol::detail::add_destructor_tag
struct	sol::detail::check_destructor_tag
struct	sol::detail::verified_tag
struct	sol::usertype_traits< T >
struct	sol::base_list< Args >
struct	sol::detail::has_derived< T >
struct	sol::detail::inheritance< T, Bases >
struct	sol::type_panic_t
struct	sol::constructor_handler
struct	sol::argument_handler< F >
struct	sol::argument_handler< types< R, Args... > >
class	sol::stack_reference
struct	sol::stack::push_popper_at
struct	sol::stack::push_popper_n< top_level >
struct	sol::stack::push_popper_n< true >
struct	sol::stack::push_popper< bool, T, typename >
struct	sol::stack::push_popper< true, T, C >
struct	sol::stack::push_popper< false, T, std::enable_if_t< std::is_base_of< stack_reference, meta::unqualified_t< T > >::value > >
struct	sol::detail::global_tag
struct	sol::detail::no_safety_tag
class	sol::basic_reference< main_only >
struct	sol::detail::is_speshul< T >
struct	sol::tie_size< T >
struct	sol::is_tieable< T >
struct	sol::tie_t< Tn >
struct	sol::tie_size< tie_t< Tn... > >
struct	sol::stack_guard
struct	sol::detail::as_reference_tag
struct	sol::detail::as_pointer_tag< T >
struct	sol::detail::as_value_tag< T >
struct	sol::detail::as_table_tag< T >
struct	sol::stack::extensible< T >
struct	sol::stack::field_getter< T, bool, bool, typename >
struct	sol::stack::probe_field_getter< T, P, b, raw, typename >
struct	sol::stack::field_setter< T, bool, bool, typename >
struct	sol::stack::getter< T, typename >
struct	sol::stack::qualified_getter< T, C >
struct	sol::stack::userdata_getter< T, typename >
struct	sol::stack::popper< T, typename >
struct	sol::stack::pusher< T, typename >
struct	sol::stack::checker< T, expected, typename >
struct	sol::stack::qualified_checker< T, expected, C >
struct	sol::stack::userdata_checker< T, typename >
struct	sol::stack::check_getter< T, typename >
struct	sol::stack::qualified_check_getter< T, C >
struct	sol::stack::probe
struct	sol::stack::record
struct	sol::stack::stack_detail::strip< T >
struct	sol::stack::stack_detail::strip< std::reference_wrapper< T > >
struct	sol::stack::stack_detail::strip< user< T > >
struct	sol::stack::stack_detail::strip< non_null< T > >
struct	sol::stack::stack_detail::strip_extensible< T >
struct	sol::stack::stack_detail::strip_extensible< extensible< T > >
struct	sol::stack::stack_detail::check_types< b >
struct	sol::stack::stack_detail::check_types< false >
struct	sol::stack::stack_detail::basic_check< expected, check_func >
struct	sol::stack::userdata_checker< T, typename >
struct	sol::stack::checker< T, expected, typename >
struct	sol::stack::qualified_checker< T, expected, C >
struct	sol::stack::checker< T, type::number, std::enable_if_t< std::is_integral< T >::value > >
struct	sol::stack::checker< T, type::number, std::enable_if_t< std::is_floating_point< T >::value > >
struct	sol::stack::checker< lua_nil_t, expected, C >
struct	sol::stack::checker< detail::non_lua_nil_t, type::poly, C >
struct	sol::stack::checker< nullopt_t, expected, C >
struct	sol::stack::checker< this_state, type::poly, C >
struct	sol::stack::checker< this_main_state, type::poly, C >
struct	sol::stack::checker< this_environment, type::poly, C >
struct	sol::stack::checker< variadic_args, type::poly, C >
struct	sol::stack::checker< type, type::poly, C >
struct	sol::stack::checker< T, type::poly, C >
struct	sol::stack::checker< T, type::lightuserdata, C >
struct	sol::stack::checker< userdata_value, type::userdata, C >
struct	sol::stack::checker< basic_userdata< B >, type::userdata, C >
struct	sol::stack::checker< user< T >, type::userdata, C >
struct	sol::stack::checker< non_null< T >, type::userdata, C >
struct	sol::stack::checker< lua_CFunction, type::function, C >
struct	sol::stack::checker< std::remove_pointer_t< lua_CFunction >, type::function, C >
struct	sol::stack::checker< c_closure, type::function, C >
struct	sol::stack::checker< T, type::function, C >
struct	sol::stack::checker< T, type::table, C >
struct	sol::stack::checker< metatable_t, expected, C >
struct	sol::stack::checker< env_t, type::poly, C >
struct	sol::stack::checker< basic_environment< E >, type::poly, C >
struct	sol::stack::checker< detail::as_value_tag< T >, type::userdata, C >
struct	sol::stack::checker< detail::as_pointer_tag< T >, type::userdata, C >
struct	sol::stack::checker< T, type::userdata, C >
struct	sol::stack::checker< T *, type::userdata, C >
struct	sol::stack::checker< X, type::userdata, std::enable_if_t< is_unique_usertype< X >::value > >
struct	sol::stack::checker< std::reference_wrapper< T >, type::userdata, C >
struct	sol::stack::checker< std::tuple< Args... >, type::poly, C >
struct	sol::stack::checker< std::pair< A, B >, type::poly, C >
struct	sol::stack::checker< optional< T >, type::poly, C >
struct	sol::stack::qualified_checker< X, type::userdata, std::enable_if_t< is_container< meta::unqualified_t< X > >::value &&!std::is_reference< X >::value > >
struct	sol::overload_set< Functions >
struct	sol::unicode::decoded_result< It >
struct	sol::unicode::encoded_result< C >
struct	sol::unicode::unicode_detail
struct	sol::stack::userdata_getter< U >
struct	sol::stack::getter< T, typename >
struct	sol::stack::qualified_getter< T, C >
struct	sol::stack::getter< T, std::enable_if_t< std::is_floating_point< T >::value > >
struct	sol::stack::getter< T, std::enable_if_t< std::is_integral< T >::value > >
struct	sol::stack::getter< T, std::enable_if_t< std::is_enum< T >::value > >
struct	sol::stack::getter< as_table_t< T > >
struct	sol::stack::getter< as_table_t< std::forward_list< T, Al > > >
struct	sol::stack::getter< nested< T >, std::enable_if_t<!is_container< T >::value > >
struct	sol::stack::getter< nested< T >, std::enable_if_t< meta::all< is_container< T >, meta::neg< meta::has_key_value_pair< meta::unqualified_t< T > > > >::value > >
struct	sol::stack::getter< nested< T >, std::enable_if_t< meta::all< is_container< T >, meta::has_key_value_pair< meta::unqualified_t< T > > >::value > >
struct	sol::stack::getter< T, std::enable_if_t< is_lua_reference< T >::value > >
struct	sol::stack::getter< userdata_value >
struct	sol::stack::getter< lightuserdata_value >
struct	sol::stack::getter< light< T > >
struct	sol::stack::getter< user< T > >
struct	sol::stack::getter< user< T * > >
struct	sol::stack::getter< type >
struct	sol::stack::getter< bool >
struct	sol::stack::getter< std::string >
struct	sol::stack::getter< const char * >
struct	sol::stack::getter< char >
struct	sol::stack::getter< basic_string_view< char, Traits > >
struct	sol::stack::getter< std::basic_string< wchar_t, Traits, Al > >
struct	sol::stack::getter< std::basic_string< char16_t, Traits, Al > >
struct	sol::stack::getter< std::basic_string< char32_t, Traits, Al > >
struct	sol::stack::getter< char16_t >
struct	sol::stack::getter< char32_t >
struct	sol::stack::getter< wchar_t >
struct	sol::stack::getter< meta_function >
struct	sol::stack::getter< lua_nil_t >
struct	sol::stack::getter< std::nullptr_t >
struct	sol::stack::getter< nullopt_t >
struct	sol::stack::getter< this_state >
struct	sol::stack::getter< this_main_state >
struct	sol::stack::getter< lua_CFunction >
struct	sol::stack::getter< c_closure >
struct	sol::stack::getter< error >
struct	sol::stack::getter< void * >
struct	sol::stack::getter< const void * >
struct	sol::stack::getter< detail::as_value_tag< T > >
struct	sol::stack::getter< detail::as_pointer_tag< T > >
struct	sol::stack::getter< non_null< T * > >
struct	sol::stack::getter< T & >
struct	sol::stack::getter< std::reference_wrapper< T > >
struct	sol::stack::getter< T * >
struct	sol::stack::getter< T, std::enable_if_t< is_unique_usertype< T >::value > >
struct	sol::stack::getter< std::tuple< Tn... > >
struct	sol::stack::getter< std::pair< A, B > >
struct	sol::stack::qualified_getter< T, std::enable_if_t< !std::is_reference< T >::value &&is_container< meta::unqualified_t< T > >::value &&std::is_default_constructible< meta::unqualified_t< T > >::value &&!is_lua_primitive< T >::value &&!is_transparent_argument< T >::value > >
struct	sol::stack::check_getter< T, typename >
struct	sol::stack::check_getter< T, std::enable_if_t< is_lua_reference< T >::value > >
struct	sol::stack::check_getter< T, std::enable_if_t< std::is_integral< T >::value &&lua_type_of< T >::value==type::number > >
struct	sol::stack::check_getter< T, std::enable_if_t< std::is_enum< T >::value &&!meta::any_same< T, meta_function, type >::value > >
struct	sol::stack::check_getter< T, std::enable_if_t< std::is_floating_point< T >::value > >
struct	sol::stack::getter< optional< T > >
struct	sol::stack::qualified_check_getter< T, C >
struct	sol::stack::pusher< detail::as_value_tag< T > >
struct	sol::stack::pusher< detail::as_pointer_tag< T > >
struct	sol::stack::pusher< detail::as_reference_tag >
struct	sol::stack::pusher< T, typename >
struct	sol::stack::pusher< T *, meta::disable_if_t< meta::any< is_container< meta::unqualified_t< T > >, std::is_function< meta::unqualified_t< T > >, is_lua_reference< meta::unqualified_t< T > > >::value > >
struct	sol::stack::pusher< T, std::enable_if_t< is_unique_usertype< T >::value > >
struct	sol::stack::pusher< std::reference_wrapper< T > >
struct	sol::stack::pusher< T, std::enable_if_t< std::is_floating_point< T >::value > >
struct	sol::stack::pusher< T, std::enable_if_t< std::is_integral< T >::value > >
struct	sol::stack::pusher< T, std::enable_if_t< std::is_enum< T >::value > >
struct	sol::stack::pusher< detail::as_table_tag< T > >
struct	sol::stack::pusher< as_table_t< T >, std::enable_if_t< is_container< std::remove_pointer_t< meta::unwrap_unqualified_t< T > > >::value > >
struct	sol::stack::pusher< as_table_t< T >, std::enable_if_t<!is_container< std::remove_pointer_t< meta::unwrap_unqualified_t< T > > >::value > >
struct	sol::stack::pusher< nested< T >, std::enable_if_t< is_container< std::remove_pointer_t< meta::unwrap_unqualified_t< T > > >::value > >
struct	sol::stack::pusher< nested< T >, std::enable_if_t<!is_container< std::remove_pointer_t< meta::unwrap_unqualified_t< T > > >::value > >
struct	sol::stack::pusher< std::initializer_list< T > >
struct	sol::stack::pusher< T, std::enable_if_t< is_lua_reference< T >::value > >
struct	sol::stack::pusher< bool >
struct	sol::stack::pusher< lua_nil_t >
struct	sol::stack::pusher< stack_count >
struct	sol::stack::pusher< metatable_t >
struct	sol::stack::pusher< std::remove_pointer_t< lua_CFunction > >
struct	sol::stack::pusher< lua_CFunction >
struct	sol::stack::pusher< c_closure >
struct	sol::stack::pusher< closure< Arg, Args... > >
struct	sol::stack::pusher< void * >
struct	sol::stack::pusher< const void * >
struct	sol::stack::pusher< lightuserdata_value >
struct	sol::stack::pusher< light< T > >
struct	sol::stack::pusher< user< T > >
struct	sol::stack::pusher< userdata_value >
struct	sol::stack::pusher< const char * >
struct	sol::stack::pusher< char * >
struct	sol::stack::pusher< char[N]>
struct	sol::stack::pusher< char >
struct	sol::stack::pusher< std::basic_string< char, Traits, Al > >
struct	sol::stack::pusher< basic_string_view< Ch, Traits > >
struct	sol::stack::pusher< meta_function >
struct	sol::stack::pusher< absolute_index >
struct	sol::stack::pusher< raw_index >
struct	sol::stack::pusher< ref_index >
struct	sol::stack::pusher< const wchar_t * >
struct	sol::stack::pusher< wchar_t * >
struct	sol::stack::pusher< const char16_t * >
struct	sol::stack::pusher< char16_t * >
struct	sol::stack::pusher< const char32_t * >
struct	sol::stack::pusher< char32_t * >
struct	sol::stack::pusher< wchar_t[N]>
struct	sol::stack::pusher< char16_t[N]>
struct	sol::stack::pusher< char32_t[N]>
struct	sol::stack::pusher< wchar_t >
struct	sol::stack::pusher< char16_t >
struct	sol::stack::pusher< char32_t >
struct	sol::stack::pusher< std::basic_string< Ch, Traits, Al >, std::enable_if_t<!std::is_same< Ch, char >::value > >
struct	sol::stack::pusher< std::tuple< Args... > >
struct	sol::stack::pusher< std::pair< A, B > >
struct	sol::stack::pusher< optional< O > >
struct	sol::stack::pusher< nullopt_t >
struct	sol::stack::pusher< std::nullptr_t >
struct	sol::stack::pusher< this_state >
struct	sol::stack::pusher< this_main_state >
struct	sol::stack::pusher< new_table >
struct	sol::stack::popper< T, typename >
struct	sol::stack::popper< T, std::enable_if_t< is_stack_based< meta::unqualified_t< T > >::value > >
struct	sol::stack::field_getter< T, bool, bool, typename >
struct	sol::stack::field_getter< T, global, true, C >
struct	sol::stack::field_getter< metatable_t, b, raw, C >
struct	sol::stack::field_getter< env_t, b, raw, C >
struct	sol::stack::field_getter< T, true, raw, std::enable_if_t< meta::is_c_str< T >::value > >
struct	sol::stack::field_getter< T, false, false, std::enable_if_t< meta::is_c_str< T >::value > >
struct	sol::stack::field_getter< T, false, true, std::enable_if_t< std::is_integral< T >::value &&!std::is_same< bool, T >::value > >
struct	sol::stack::field_getter< std::tuple< Args... >, b, raw, C >
struct	sol::stack::field_getter< std::pair< A, B >, b, raw, C >
struct	sol::stack::field_setter< T, bool, bool, typename >
struct	sol::stack::field_setter< T, b, true, C >
struct	sol::stack::field_setter< metatable_t, b, raw, C >
struct	sol::stack::field_setter< T, true, raw, std::enable_if_t< meta::is_c_str< T >::value > >
struct	sol::stack::field_setter< T, false, false, std::enable_if_t< meta::is_c_str< T >::value > >
struct	sol::stack::field_setter< T, false, true, std::enable_if_t< std::is_integral< T >::value &&!std::is_same< bool, T >::value > >
struct	sol::stack::field_setter< std::tuple< Args... >, b, raw, C >
struct	sol::stack::field_setter< std::pair< A, B >, b, raw, C >
struct	sol::stack::probe_field_getter< T, P, b, raw, typename >
struct	sol::stack::probe_field_getter< std::pair< A, B >, P, b, raw, C >
struct	sol::stack::probe_field_getter< std::tuple< Args... >, P, b, raw, C >
struct	sol::stack::stack_detail::evaluator
struct	sol::proxy_base_tag
struct	sol::proxy_base< Super >
struct	sol::stack_iterator< proxy_t, is_const >
struct	sol::stack_proxy_base
struct	sol::stack::getter< stack_proxy_base >
struct	sol::stack::pusher< stack_proxy_base >
struct	sol::stack_proxy
struct	sol::stack::getter< stack_proxy >
struct	sol::stack::pusher< stack_proxy >
struct	sol::protected_function_result
struct	sol::stack::pusher< protected_function_result >
struct	sol::unsafe_function_result
struct	sol::stack::pusher< unsafe_function_result >
struct	sol::detail::is_speshul< unsafe_function_result >
struct	sol::detail::is_speshul< protected_function_result >
struct	sol::tie_size< unsafe_function_result >
struct	sol::tie_size< protected_function_result >
struct	sol::wrapper< F, typename >
struct	sol::wrapper< F, typename >::caller
struct	sol::wrapper< F, std::enable_if_t< std::is_function< std::remove_pointer_t< meta::unqualified_t< F > > >::value > >
struct	sol::wrapper< F, std::enable_if_t< std::is_function< std::remove_pointer_t< meta::unqualified_t< F > > >::value > >::caller
struct	sol::wrapper< F, std::enable_if_t< std::is_function< std::remove_pointer_t< meta::unqualified_t< F > > >::value > >::invoker< fx >
struct	sol::wrapper< F, std::enable_if_t< std::is_member_object_pointer< meta::unqualified_t< F > >::value > >
struct	sol::wrapper< F, std::enable_if_t< std::is_member_object_pointer< meta::unqualified_t< F > >::value > >::caller
struct	sol::wrapper< F, std::enable_if_t< std::is_member_object_pointer< meta::unqualified_t< F > >::value > >::invoker< fx >
struct	sol::member_function_wrapper< F, R, O, FArgs >
struct	sol::member_function_wrapper< F, R, O, FArgs >::caller
struct	sol::member_function_wrapper< F, R, O, FArgs >::invoker< fx >
struct	sol::wrapper< R(O::*)(Args...)>
struct	sol::wrapper< R(O::*)(Args...) const >
struct	sol::wrapper< R(O::*)(Args...) const volatile >
struct	sol::wrapper< R(O::*)(Args...)& >
struct	sol::wrapper< R(O::*)(Args...) const & >
struct	sol::wrapper< R(O::*)(Args...) const volatile & >
struct	sol::wrapper< R(O::*)(Args...,...)& >
struct	sol::wrapper< R(O::*)(Args...,...) const & >
struct	sol::wrapper< R(O::*)(Args...,...) const volatile & >
struct	sol::wrapper< R(O::*)(Args...) && >
struct	sol::wrapper< R(O::*)(Args...) const && >
struct	sol::wrapper< R(O::*)(Args...) const volatile && >
struct	sol::wrapper< R(O::*)(Args...,...) && >
struct	sol::wrapper< R(O::*)(Args...,...) const && >
struct	sol::wrapper< R(O::*)(Args...,...) const volatile && >
struct	sol::protect_t< T >
struct	sol::no_prop
struct	sol::property_wrapper< R, W >
struct	sol::readonly_wrapper< T >
struct	sol::var_wrapper< T >
struct	sol::meta::is_member_object< T >
struct	sol::meta::is_member_object< readonly_wrapper< T > >
struct	sol::call_detail::void_call< T, List >
struct	sol::call_detail::void_call< T, types< Args... > >
struct	sol::call_detail::constructor_match< T, checked, clean_stack >
struct	sol::call_detail::agnostic_lua_call_wrapper< F, is_index, is_variable, checked, boost, clean_stack, typename >
struct	sol::call_detail::agnostic_lua_call_wrapper< var_wrapper< T >, true, is_variable, checked, boost, clean_stack, C >
struct	sol::call_detail::agnostic_lua_call_wrapper< var_wrapper< T >, false, is_variable, checked, boost, clean_stack, C >
struct	sol::call_detail::agnostic_lua_call_wrapper< lua_CFunction_ref, is_index, is_variable, checked, boost, clean_stack, C >
struct	sol::call_detail::agnostic_lua_call_wrapper< lua_CFunction, is_index, is_variable, checked, boost, clean_stack, C >
struct	sol::call_detail::agnostic_lua_call_wrapper< no_prop, is_index, is_variable, checked, boost, clean_stack, C >
struct	sol::call_detail::agnostic_lua_call_wrapper< no_construction, is_index, is_variable, checked, boost, clean_stack, C >
struct	sol::call_detail::agnostic_lua_call_wrapper< bases< Args... >, is_index, is_variable, checked, boost, clean_stack, C >
struct	sol::call_detail::agnostic_lua_call_wrapper< std::reference_wrapper< T >, is_index, is_variable, checked, boost, clean_stack, C >
struct	sol::call_detail::lua_call_wrapper< T, F, is_index, is_variable, checked, boost, clean_stack, typename >
struct	sol::call_detail::lua_call_wrapper< T, F, is_index, is_variable, checked, boost, clean_stack, std::enable_if_t< std::is_member_function_pointer< F >::value > >
struct	sol::call_detail::lua_call_wrapper< T, F, false, is_variable, checked, boost, clean_stack, std::enable_if_t< std::is_member_object_pointer< F >::value > >
struct	sol::call_detail::lua_call_wrapper< T, F, true, is_variable, checked, boost, clean_stack, std::enable_if_t< std::is_member_object_pointer< F >::value > >
struct	sol::call_detail::lua_call_wrapper< T, readonly_wrapper< F >, false, is_variable, checked, boost, clean_stack, C >
struct	sol::call_detail::lua_call_wrapper< T, readonly_wrapper< F >, true, is_variable, checked, boost, clean_stack, C >
struct	sol::call_detail::lua_call_wrapper< T, constructor_list< Args... >, is_index, is_variable, checked, boost, clean_stack, C >
struct	sol::call_detail::lua_call_wrapper< T, constructor_wrapper< Cxs... >, is_index, is_variable, checked, boost, clean_stack, C >
struct	sol::call_detail::lua_call_wrapper< T, constructor_wrapper< Cxs... >, is_index, is_variable, checked, boost, clean_stack, C >::onmatch
struct	sol::call_detail::lua_call_wrapper< T, destructor_wrapper< Fx >, is_index, is_variable, checked, boost, clean_stack, std::enable_if_t< std::is_void< Fx >::value > >
struct	sol::call_detail::lua_call_wrapper< T, destructor_wrapper< Fx >, is_index, is_variable, checked, boost, clean_stack, std::enable_if_t<!std::is_void< Fx >::value > >
struct	sol::call_detail::lua_call_wrapper< T, overload_set< Fs... >, is_index, is_variable, checked, boost, clean_stack, C >
struct	sol::call_detail::lua_call_wrapper< T, overload_set< Fs... >, is_index, is_variable, checked, boost, clean_stack, C >::on_match
struct	sol::call_detail::lua_call_wrapper< T, factory_wrapper< Fs... >, is_index, is_variable, checked, boost, clean_stack, C >
struct	sol::call_detail::lua_call_wrapper< T, factory_wrapper< Fs... >, is_index, is_variable, checked, boost, clean_stack, C >::on_match
struct	sol::call_detail::lua_call_wrapper< T, property_wrapper< R, W >, is_index, is_variable, checked, boost, clean_stack, C >
struct	sol::call_detail::lua_call_wrapper< T, protect_t< V >, is_index, is_variable, checked, boost, clean_stack, C >
struct	sol::call_detail::lua_call_wrapper< T, filter_wrapper< F, Filters... >, is_index, is_variable, checked, boost, clean_stack, C >
struct	sol::call_detail::lua_call_wrapper< T, function_arguments< Sig, P >, is_index, is_variable, checked, boost, clean_stack, C >
struct	sol::call_detail::is_var_bind< T, typename >
struct	sol::call_detail::is_var_bind< T, std::enable_if_t< std::is_member_object_pointer< T >::value > >
struct	sol::call_detail::is_var_bind< no_prop >
struct	sol::call_detail::is_var_bind< property_wrapper< R, W > >
struct	sol::call_detail::is_var_bind< var_wrapper< T > >
struct	sol::call_detail::is_var_bind< readonly_wrapper< T > >
struct	sol::call_detail::is_var_bind< filter_wrapper< F, Filters... > >
struct	sol::is_variable_binding< T >
struct	sol::is_function_binding< T >
struct	sol::function_detail::c_call_matcher< Fxs >
struct	sol::wrap< F, f >
struct	sol::function_detail::upvalue_free_function< Function, is_yielding >
struct	sol::function_detail::upvalue_member_function< T, Function, is_yielding >
struct	sol::function_detail::upvalue_member_variable< T, Function, is_yielding >
struct	sol::function_detail::upvalue_member_variable< T, readonly_wrapper< Function >, is_yielding >
struct	sol::function_detail::upvalue_this_member_function< T, Function, is_yielding >
struct	sol::function_detail::upvalue_this_member_variable< T, Function, is_yielding >
struct	sol::function_detail::upvalue_this_member_variable< T, readonly_wrapper< Function >, is_yielding >
struct	sol::function_detail::functor_function< Func, is_yielding, no_trampoline >
struct	sol::function_detail::member_function< T, Function, is_yielding >
struct	sol::function_detail::member_variable< T, Function, is_yielding >
struct	sol::function_detail::overloaded_function< start_skew, Functions >
struct	sol::function_detail::class_indicator< T >
struct	sol::function_detail::call_indicator
struct	sol::stack::pusher< function_sig< Sigs... > >
struct	sol::stack::pusher< yielding_t< T > >
struct	sol::stack::pusher< function_arguments< T, Args... > >
struct	sol::stack::pusher< std::function< Signature > >
struct	sol::stack::pusher< Signature, std::enable_if_t< std::is_member_pointer< Signature >::value > >
struct	sol::stack::pusher< Signature, std::enable_if_t< meta::all< std::is_function< std::remove_pointer_t< Signature > >, meta::neg< std::is_same< Signature, lua_CFunction > >, meta::neg< std::is_same< Signature, std::remove_pointer_t< lua_CFunction > > > >::value > >
struct	sol::stack::pusher< overload_set< Functions... > >
struct	sol::stack::pusher< protect_t< T > >
struct	sol::stack::pusher< property_wrapper< F, G >, std::enable_if_t<!std::is_void< F >::value &&!std::is_void< G >::value > >
struct	sol::stack::pusher< property_wrapper< F, void > >
struct	sol::stack::pusher< property_wrapper< void, F > >
struct	sol::stack::pusher< var_wrapper< T > >
struct	sol::stack::pusher< factory_wrapper< Functions... > >
struct	sol::stack::pusher< no_construction >
struct	sol::stack::pusher< detail::tagged< T, constructor_list< Lists... > > >
struct	sol::stack::pusher< constructor_list< L0, Lists... > >
struct	sol::stack::pusher< detail::tagged< T, constructor_wrapper< Fxs... > > >
struct	sol::stack::pusher< constructor_wrapper< F, Fxs... > >
struct	sol::stack::pusher< detail::tagged< T, destructor_wrapper< void > > >
struct	sol::stack::pusher< detail::tagged< T, destructor_wrapper< Fx > > >
struct	sol::stack::pusher< destructor_wrapper< Fx > >
struct	sol::stack::pusher< filter_wrapper< F, Filters... > >
class	sol::basic_function< base_t, aligned >
struct	sol::detail::protected_handler< b, target_t >
class	sol::basic_protected_function< base_t, aligned, handler_t >
struct	sol::stack::getter< std::function< Signature > >
struct	sol::proxy< Table, Key >
struct	sol::stack::pusher< proxy< Table, Key > >
struct	sol::detail::deprecate_type< T >
class	sol::basic_object_base< base_t >
class	sol::basic_userdata< base_type >
class	sol::basic_lightuserdata< base_type >
struct	sol::as_args_t< T >
struct	sol::stack::pusher< as_args_t< T > >
struct	sol::variadic_args
struct	sol::stack::getter< variadic_args >
struct	sol::stack::pusher< variadic_args >
class	sol::basic_object< base_type >
struct	sol::container_traits< T >
struct	sol::as_container_t< T >
struct	sol::as_container_t< T & >
struct	sol::container_detail::has_clear_test< T >
struct	sol::container_detail::has_empty_test< T >
struct	sol::container_detail::has_erase_after_test< T >
struct	sol::container_detail::has_find_test< T, typename >
struct	sol::container_detail::has_find_test< T, std::enable_if_t< meta::is_lookup< T >::value > >
struct	sol::container_detail::has_erase_test< T >
struct	sol::container_detail::has_traits_find_test< T >
struct	sol::container_detail::has_traits_insert_test< T >
struct	sol::container_detail::has_traits_erase_test< T >
struct	sol::container_detail::has_traits_index_set_test< T >
struct	sol::container_detail::has_traits_index_get_test< T >
struct	sol::container_detail::has_traits_set_test< T >
struct	sol::container_detail::has_traits_get_test< T >
struct	sol::container_detail::has_traits_at_test< T >
struct	sol::container_detail::has_traits_pairs_test< T >
struct	sol::container_detail::has_traits_ipairs_test< T >
struct	sol::container_detail::has_traits_next_test< T >
struct	sol::container_detail::has_traits_add_test< T >
struct	sol::container_detail::has_traits_size_test< T >
struct	sol::container_detail::is_forced_container< T >
struct	sol::container_detail::is_forced_container< as_container_t< T > >
struct	sol::container_detail::container_decay< T >
struct	sol::container_detail::container_decay< as_container_t< T > >
struct	sol::container_detail::error_result
struct	sol::container_detail::container_traits_default< X, typename >
struct	sol::container_detail::container_traits_default< X, std::enable_if_t< meta::all< is_forced_container< meta::unqualified_t< X > >, meta::has_value_type< meta::unqualified_t< container_decay_t< X > > >, meta::has_iterator< meta::unqualified_t< container_decay_t< X > > > >::value > >
struct	sol::container_detail::container_traits_default< X, std::enable_if_t< meta::all< is_forced_container< meta::unqualified_t< X > >, meta::has_value_type< meta::unqualified_t< container_decay_t< X > > >, meta::has_iterator< meta::unqualified_t< container_decay_t< X > > > >::value > >::iter
struct	sol::container_detail::container_traits_default< X, std::enable_if_t< std::is_array< std::remove_pointer_t< meta::unwrap_unqualified_t< X > > >::value > >
struct	sol::container_detail::container_traits_default< X, std::enable_if_t< std::is_array< std::remove_pointer_t< meta::unwrap_unqualified_t< X > > >::value > >::iter
struct	sol::container_detail::container_traits_default< container_traits< X > >
struct	sol::container_traits< T >
struct	sol::container_usertype_metatable< X >
struct	sol::stack::stack_detail::metatable_setup< T, is_shim >
struct	sol::stack::pusher< as_container_t< T > >
struct	sol::stack::pusher< as_container_t< T * > >
struct	sol::stack::pusher< T, std::enable_if_t< meta::all< is_container< meta::unqualified_t< T > >, meta::neg< is_lua_reference< meta::unqualified_t< T > > > >::value > >
struct	sol::stack::pusher< T *, std::enable_if_t< meta::all< is_container< meta::unqualified_t< T > >, meta::neg< is_lua_reference< meta::unqualified_t< T > > > >::value > >
struct	sol::stack::checker< as_container_t< T >, type::userdata, C >
struct	sol::stack::getter< as_container_t< T > >
struct	sol::stack::getter< as_container_t< T > * >
struct	sol::usertype_detail::no_comp
struct	sol::stack::stack_detail::undefined_metatable< T >
struct	sol::usertype_detail::call_information
struct	sol::usertype_detail::variable_wrapper
struct	sol::usertype_detail::callable_binding< T, F >
struct	sol::usertype_detail::simple_map
struct	sol::usertype_metatable_core
struct	sol::usertype_detail::registrar
struct	sol::clean_type< T >
struct	sol::usertype_metatable< T, IndexSequence, Tn >
struct	sol::usertype_metatable< T, std::index_sequence< I... >, Tn... >
struct	sol::usertype_metatable< T, std::index_sequence< I... >, Tn... >::check_binding< Idx >
struct	sol::stack::pusher< usertype_metatable< T, std::index_sequence< I... >, Args... > >
struct	sol::simple_tag
struct	sol::simple_usertype_metatable< T >
struct	sol::stack::pusher< simple_usertype_metatable< T > >
class	sol::usertype< T >
class	sol::simple_usertype< T >
struct	sol::stack::pusher< usertype< T > >
class	sol::basic_table_iterator< reference_type >
struct	sol::detail::clean< n >
struct	sol::detail::ref_clean
class	sol::basic_table_core< top_level, base_type >
struct	sol::stack::getter< metatable_t >
struct	sol::basic_environment< base_type >
struct	sol::this_environment
struct	sol::stack::getter< env_t >
struct	sol::stack::getter< this_environment >
struct	sol::load_result
class	sol::state_view
struct	sol::lua_thread_state
struct	sol::stack::pusher< lua_thread_state >
struct	sol::stack::getter< lua_thread_state >
struct	sol::stack::check_getter< lua_thread_state >
class	sol::basic_thread< base_t >
class	sol::state
class	sol::basic_coroutine< base_t >
struct	sol::as_returns_t< T >
struct	sol::stack::pusher< as_returns_t< T > >
struct	sol::variadic_results
struct	sol::stack::pusher< variadic_results >

Namespaces
	sol
	sol::detail
	sol::meta
	sol::meta::detail
	sol::meta::meta_detail
	std
	sol::detail_
	sol::stack
	sol::stack::stack_detail
	sol::usertype_detail
	sol::adl_barrier_detail
	sol::unicode
	sol::function_detail
	sol::property_detail
	sol::filter_detail
	sol::call_detail
	sol::call_detail::overload_detail
	sol::container_detail

Macros
#define	SOL_HPP
#define	SOL_PRINT_ERRORS   0
#define	SOL_DEFAULT_PASS_ON_ERROR   0
#define	SOL_ENABLE_INTEROP   0
#define	SOL_STACK_STRING_OPTIMIZATION_SIZE   1024
#define	SOL_LUA_VERSION   500
#define	COMPAT53_INCLUDE_SOURCE   1
#define	KEPLER_PROJECT_COMPAT53_H_
#define	COMPAT53_PREFIX   kp_compat53
#define	COMPAT53_API   static
#define	COMPAT53_CONCAT_HELPER(a, b)   a##b
#define	COMPAT53_CONCAT(a, b)   COMPAT53_CONCAT_HELPER(a, b)
#define	LUA_KFUNCTION(_name)   static int (_name)(lua_State *L, int status, lua_KContext ctx)
#define	KEPLER_PROJECT_COMPAT53_C_
#define	TR2_OPTIONAL_REQUIRES(...)   typename ::std::enable_if<__VA_ARGS__::value, bool>::type = false
#define	OPTIONAL_HAS_THIS_RVALUE_REFS   0
#define	OPTIONAL_HAS_CONSTEXPR_INIT_LIST   0
#define	OPTIONAL_CONSTEXPR_INIT_LIST
#define	OPTIONAL_HAS_MOVE_ACCESSORS   0
#define	OPTIONAL_MUTABLE_CONSTEXPR   constexpr
#define	TR2_OPTIONAL_ASSERTED_EXPRESSION(CHECK, EXPR)   ((CHECK) ? (EXPR) : ([] { assert(!#CHECK); }(), (EXPR)))
#define	SOL_DEPRECATED   [[deprecated]]

Typedefs
using	sol::reference = basic_reference< false >
using	sol::main_reference = basic_reference< true >
template<bool b>
using	sol::table_core = basic_table_core< b, reference >
template<bool b>
using	sol::main_table_core = basic_table_core< b, main_reference >
template<bool b>
using	sol::stack_table_core = basic_table_core< b, stack_reference >
template<typename T >
using	sol::basic_table = basic_table_core< false, T >
typedef table_core< false >	sol::table
typedef table_core< true >	sol::global_table
typedef main_table_core< false >	sol::main_table
typedef main_table_core< true >	sol::main_global_table
typedef stack_table_core< false >	sol::stack_table
typedef stack_table_core< true >	sol::stack_global_table
using	sol::environment = basic_environment< reference >
using	sol::main_environment = basic_environment< main_reference >
using	sol::stack_environment = basic_environment< stack_reference >
using	sol::unsafe_function = basic_function< reference, false >
using	sol::safe_function = basic_protected_function< reference, false, reference >
using	sol::main_unsafe_function = basic_function< main_reference, false >
using	sol::main_safe_function = basic_protected_function< main_reference, false, reference >
using	sol::stack_unsafe_function = basic_function< stack_reference, false >
using	sol::stack_safe_function = basic_protected_function< stack_reference, false, reference >
using	sol::stack_aligned_unsafe_function = basic_function< stack_reference, true >
using	sol::stack_aligned_safe_function = basic_protected_function< stack_reference, true, reference >
using	sol::protected_function = safe_function
using	sol::main_protected_function = main_safe_function
using	sol::stack_protected_function = stack_safe_function
using	sol::stack_aligned_protected_function = stack_aligned_safe_function
using	sol::function = unsafe_function
using	sol::main_function = main_unsafe_function
using	sol::stack_function = stack_unsafe_function
using	sol::stack_aligned_function = stack_aligned_unsafe_function
using	sol::stack_aligned_stack_handler_function = basic_protected_function< stack_reference, true, stack_reference >
using	sol::safe_function_result = protected_function_result
using	sol::function_result = unsafe_function_result
using	sol::object = basic_object< reference >
using	sol::userdata = basic_userdata< reference >
using	sol::lightuserdata = basic_lightuserdata< reference >
using	sol::thread = basic_thread< reference >
using	sol::coroutine = basic_coroutine< reference >
using	sol::main_object = basic_object< main_reference >
using	sol::main_userdata = basic_userdata< main_reference >
using	sol::main_lightuserdata = basic_lightuserdata< main_reference >
using	sol::main_coroutine = basic_coroutine< main_reference >
using	sol::stack_object = basic_object< stack_reference >
using	sol::stack_userdata = basic_userdata< stack_reference >
using	sol::stack_lightuserdata = basic_lightuserdata< stack_reference >
using	sol::stack_thread = basic_thread< stack_reference >
using	sol::stack_coroutine = basic_coroutine< stack_reference >
using	sol::detail::swallow = std::initializer_list< int >
template<typename T >
using	sol::meta::unqualified = std::remove_cv< std::remove_reference_t< T >>
template<typename T >
using	sol::meta::unqualified_t = typename unqualified< T >::type
template<typename... Args>
using	sol::meta::tuple_types = typename detail::tuple_types_< Args... >::type
template<typename Arg >
using	sol::meta::pop_front_type_t = typename pop_front_type< Arg >::type
template<std::size_t N, typename Tuple >
using	sol::meta::tuple_element = std::tuple_element< N, std::remove_reference_t< Tuple >>
template<std::size_t N, typename Tuple >
using	sol::meta::tuple_element_t = std::tuple_element_t< N, std::remove_reference_t< Tuple >>
template<std::size_t N, typename Tuple >
using	sol::meta::unqualified_tuple_element = unqualified< tuple_element_t< N, Tuple >>
template<std::size_t N, typename Tuple >
using	sol::meta::unqualified_tuple_element_t = unqualified_t< tuple_element_t< N, Tuple >>
template<std::size_t I, typename T >
using	sol::meta::meta_detail::void_tuple_element_t = typename void_tuple_element< I, T >::type
template<typename Signature >
using	sol::meta::function_args_t = typename bind_traits< Signature >::args_list
template<typename Signature >
using	sol::meta::function_signature_t = typename bind_traits< Signature >::signature_type
template<typename Signature >
using	sol::meta::function_return_t = typename bind_traits< Signature >::return_type
using	sol::string_view = basic_string_view< char >
using	sol::wstring_view = basic_string_view< wchar_t >
using	sol::u16string_view = basic_string_view< char16_t >
using	sol::u32string_view = basic_string_view< char32_t >
using	sol::string_view_hash = std::hash< string_view >
template<std::size_t I>
using	sol::index_value = std::integral_constant< std::size_t, I >
typedef std::array< char, 1 >	sol::meta::sfinae_yes_t
typedef std::array< char, 2 >	sol::meta::sfinae_no_t
template<typename T >
using	sol::meta::identity_t = typename identity< T >::type
template<typename T >
using	sol::meta::unwrapped_t = typename unwrapped< T >::type
template<typename T >
using	sol::meta::unwrap_unqualified_t = typename unwrap_unqualified< T >::type
template<typename T >
using	sol::meta::remove_member_pointer_t = remove_member_pointer< T >
template<typename T , template< typename... > class Templ>
using	sol::meta::is_specialization_of = meta_detail::is_specialization_of< std::remove_cv_t< T >, Templ >
template<bool B>
using	sol::meta::boolean = std::integral_constant< bool, B >
template<typename T >
using	sol::meta::invoke_t = typename T::type
template<typename T >
using	sol::meta::invoke_b = boolean< T::value >
template<typename T >
using	sol::meta::neg = boolean<!T::value >
template<typename Condition , typename Then , typename Else >
using	sol::meta::condition = std::conditional_t< Condition::value, Then, Else >
template<bool value, typename T = void>
using	sol::meta::disable_if_t = std::enable_if_t<!value, T >
template<typename... Args>
using	sol::meta::enable = std::enable_if_t< all< Args... >::value, enable_t >
template<typename... Args>
using	sol::meta::disable = std::enable_if_t< neg< all< Args... >>::value, enable_t >
template<typename... Args>
using	sol::meta::enable_any = std::enable_if_t< any< Args... >::value, enable_t >
template<typename... Args>
using	sol::meta::disable_any = std::enable_if_t< neg< any< Args... >>::value, enable_t >
template<std::size_t I, typename... Args>
using	sol::meta::at_in_pack_t = typename at_in_pack< I, Args... >::type
template<typename... Args>
using	sol::meta::return_type_t = typename return_type< Args... >::type
template<typename T , typename U = T>
using	sol::meta::supports_op_less = decltype(meta_detail::supports_op_less_test(std::declval< T & >(), std::declval< U & >()))
template<typename T , typename U = T>
using	sol::meta::supports_op_equal = decltype(meta_detail::supports_op_equal_test(std::declval< T & >(), std::declval< U & >()))
template<typename T , typename U = T>
using	sol::meta::supports_op_less_equal = decltype(meta_detail::supports_op_less_equal_test(std::declval< T & >(), std::declval< U & >()))
template<typename T , typename U = std::ostream>
using	sol::meta::supports_ostream_op = decltype(meta_detail::supports_ostream_op(std::declval< T & >(), std::declval< U & >()))
template<typename T >
using	sol::meta::supports_adl_to_string = decltype(meta_detail::supports_adl_to_string(std::declval< T & >()))
template<typename T >
using	sol::meta::supports_to_string_member = meta::boolean< meta_detail::has_to_string_test< T >::value >
template<typename T >
using	sol::meta::has_push_back = meta::boolean< meta_detail::has_push_back_test< T >::value >
template<typename T >
using	sol::meta::has_max_size = meta::boolean< meta_detail::has_max_size_test< T >::value >
template<typename T >
using	sol::meta::has_insert = meta::boolean< meta_detail::has_insert_test< T >::value >
template<typename T >
using	sol::meta::has_insert_after = meta::boolean< meta_detail::has_insert_after_test< T >::value >
template<typename T >
using	sol::meta::has_size = meta::boolean< meta_detail::has_size_test< T >::value||meta_detail::has_size_test< const T >::value >
template<typename T >
using	sol::meta::is_string_like = any< is_specialization_of< meta::unqualified_t< T >, std::basic_string >, is_specialization_of< meta::unqualified_t< T >, basic_string_view >, meta::all< std::is_array< unqualified_t< T >>, meta::any_same< meta::unqualified_t< std::remove_all_extents_t< meta::unqualified_t< T >>>, char, char16_t, char32_t, wchar_t >> >
template<typename T >
using	sol::meta::is_string_constructible = any< meta::all< std::is_array< unqualified_t< T >>, std::is_same< meta::unqualified_t< std::remove_all_extents_t< meta::unqualified_t< T >>>, char >>, std::is_same< unqualified_t< T >, const char * >, std::is_same< unqualified_t< T >, char >, std::is_same< unqualified_t< T >, std::string >, std::is_same< unqualified_t< T >, std::initializer_list< char >> >
template<typename T >
using	sol::meta::is_c_str = any< std::is_same< std::decay_t< unqualified_t< T >>, const char * >, std::is_same< std::decay_t< unqualified_t< T >>, char * >, std::is_same< unqualified_t< T >, std::string >>
template<typename T >
using	sol::meta::is_not_move_only = neg< is_move_only< T >>
using	sol::in_place_t = in_place_tag(&)(detail::in_place_of_tag)
template<typename T >
using	sol::in_place_type_t = in_place_tag(&)(detail::in_place_of_t< T >)
template<std::size_t I>
using	sol::in_place_index_t = in_place_tag(&)(detail::in_place_of_i< I >)
template<typename T >
using	sol::is_trivially_destructible = ::std::has_trivial_destructor< T >
template<class T >
using	sol::OptionalBase = typename ::std::conditional< ::std::is_trivially_destructible< T >::value, constexpr_optional_base< typename ::std::remove_const< T >::type >, optional_base< typename ::std::remove_const< T >::type >>::type
template<typename... Args>
using	sol::constructors = constructor_list< Args... >
typedef static_stack_dependencies<-1, 1 >	sol::self_dependency
typedef returns_self_with	sol::returns_self
template<typename K , typename V , typename H = std::hash<K>, typename E = std::equal_to<>>
using	sol::usertype_detail::map_t = std::unordered_map< K, V, H, E >
typedef int(*	sol::detail::lua_CFunction_noexcept) (lua_State *L)
typedef lua_nil_t	sol::nil_t
typedef std::remove_pointer_t< lua_CFunction >	sol::lua_CFunction_ref
typedef closure	sol::c_closure
typedef meta_function	sol::meta_method
template<typename... Args>
using	sol::detail::has_constructor = meta::any< is_constructor< meta::unqualified_t< Args >>... >
template<typename... Args>
using	sol::detail::has_destructor = meta::any< is_destructor< meta::unqualified_t< Args >>... >
using	sol::exception_handler_function = int(*)(lua_State *, optional< const std::exception & >, string_view)
template<typename... Args>
using	sol::bases = base_list< Args... >
typedef bases	sol::base_classes_tag
using	sol::detail::inheritance_check_function = decltype(&inheritance< void >::type_check)
using	sol::detail::inheritance_cast_function = decltype(&inheritance< void >::type_cast)
using	sol::detail::inheritance_unique_cast_function = decltype(&inheritance< void >::type_unique_cast< void >)
using	sol::detail::unique_destructor = void(*)(void *)
using	sol::detail::unique_tag = const char *
template<typename T >
using	sol::stack::stack_detail::strip_t = typename strip< T >::type
template<typename T >
using	sol::stack::stack_detail::strip_extensible_t = typename strip_extensible< T >::type
using	sol::detail::typical_chunk_name_t = char[32]
template<typename T >
using	sol::detail::array_return_type = std::conditional_t< std::is_array< T >::value, std::add_lvalue_reference_t< T >, T >
template<typename T >
using	sol::container_detail::has_clear = meta::boolean< has_clear_test< T >::value >
template<typename T >
using	sol::container_detail::has_empty = meta::boolean< has_empty_test< T >::value >
template<typename T >
using	sol::container_detail::has_find = meta::boolean< has_find_test< T >::value >
template<typename T >
using	sol::container_detail::has_erase = meta::boolean< has_erase_test< T >::value >
template<typename T >
using	sol::container_detail::has_erase_after = meta::boolean< has_erase_after_test< T >::value >
template<typename T >
using	sol::container_detail::has_traits_get = meta::boolean< has_traits_get_test< T >::value >
template<typename T >
using	sol::container_detail::has_traits_at = meta::boolean< has_traits_at_test< T >::value >
template<typename T >
using	sol::container_detail::has_traits_set = meta::boolean< has_traits_set_test< T >::value >
template<typename T >
using	sol::container_detail::has_traits_index_get = meta::boolean< has_traits_index_get_test< T >::value >
template<typename T >
using	sol::container_detail::has_traits_index_set = meta::boolean< has_traits_index_set_test< T >::value >
template<typename T >
using	sol::container_detail::has_traits_pairs = meta::boolean< has_traits_pairs_test< T >::value >
template<typename T >
using	sol::container_detail::has_traits_ipairs = meta::boolean< has_traits_ipairs_test< T >::value >
template<typename T >
using	sol::container_detail::has_traits_next = meta::boolean< has_traits_next_test< T >::value >
template<typename T >
using	sol::container_detail::has_traits_add = meta::boolean< has_traits_add_test< T >::value >
template<typename T >
using	sol::container_detail::has_traits_size = meta::boolean< has_traits_size_test< T >::value >
template<typename T >
using	sol::container_detail::has_traits_clear = has_clear< T >
template<typename T >
using	sol::container_detail::has_traits_empty = has_empty< T >
template<typename T >
using	sol::container_detail::has_traits_find = meta::boolean< has_traits_find_test< T >::value >
template<typename T >
using	sol::container_detail::has_traits_insert = meta::boolean< has_traits_insert_test< T >::value >
template<typename T >
using	sol::container_detail::has_traits_erase = meta::boolean< has_traits_erase_test< T >::value >
template<typename T >
using	sol::container_detail::container_decay_t = typename container_decay< meta::unqualified_t< T >>::type
typedef void(*	sol::usertype_detail::base_walk) (lua_State *, bool &, int &, string_view &)
typedef int(*	sol::usertype_detail::member_search) (lua_State *, void *, usertype_metatable_core &, int)
typedef map_t< std::string, call_information >	sol::usertype_detail::mapping_t
typedef map_t< std::string, std::unique_ptr< variable_wrapper > >	sol::usertype_detail::variable_map
typedef map_t< std::string, object >	sol::usertype_detail::function_map
template<typename T >
using	sol::clean_type_t = typename clean_type< T >::type

Enumerations
enum	sol::meta::enable_t { sol::meta::enable_t::_ }
enum	sol::lib : char {   sol::lib::base, sol::lib::package, sol::lib::coroutine, sol::lib::string,   sol::lib::os, sol::lib::math, sol::lib::table, sol::lib::debug,   sol::lib::bit32, sol::lib::io, sol::lib::ffi, sol::lib::jit,   sol::lib::utf8, sol::lib::count }
enum	sol::call_syntax { sol::call_syntax::dot = 0, sol::call_syntax::colon = 1 }
enum	sol::load_mode { sol::load_mode::any = 0, sol::load_mode::text = 1, sol::load_mode::binary = 2 }
enum	sol::call_status : int {   sol::call_status::ok = LUA_OK, sol::call_status::yielded = LUA_YIELD, sol::call_status::runtime = LUA_ERRRUN, sol::call_status::memory = LUA_ERRMEM,   sol::call_status::handler = LUA_ERRERR, sol::call_status::gc = LUA_ERRGCMM, sol::call_status::syntax = LUA_ERRSYNTAX, sol::call_status::file = LUA_ERRFILE }
enum	sol::thread_status : int {   sol::thread_status::ok = LUA_OK, sol::thread_status::yielded = LUA_YIELD, sol::thread_status::runtime = LUA_ERRRUN, sol::thread_status::memory = LUA_ERRMEM,   sol::thread_status::gc = LUA_ERRGCMM, sol::thread_status::handler = LUA_ERRERR, sol::thread_status::dead = -1 }
enum	sol::load_status : int {   sol::load_status::ok = LUA_OK, sol::load_status::syntax = LUA_ERRSYNTAX, sol::load_status::memory = LUA_ERRMEM, sol::load_status::gc = LUA_ERRGCMM,   sol::load_status::file = LUA_ERRFILE }
enum	sol::type : int {   sol::type::none = LUA_TNONE, sol::type::lua_nil = LUA_TNIL, sol::type::nil = lua_nil, sol::type::string = LUA_TSTRING,   sol::type::number = LUA_TNUMBER, sol::type::thread = LUA_TTHREAD, sol::type::boolean = LUA_TBOOLEAN, sol::type::function = LUA_TFUNCTION,   sol::type::userdata = LUA_TUSERDATA, sol::type::lightuserdata = LUA_TLIGHTUSERDATA, sol::type::table = LUA_TTABLE, sol::type::poly = -0xFFFF }
enum	sol::meta_function {   sol::meta_function::construct, sol::meta_function::index, sol::meta_function::new_index, sol::meta_function::mode,   sol::meta_function::call, sol::meta_function::call_function = call, sol::meta_function::metatable, sol::meta_function::to_string,   sol::meta_function::length, sol::meta_function::unary_minus, sol::meta_function::addition, sol::meta_function::subtraction,   sol::meta_function::multiplication, sol::meta_function::division, sol::meta_function::modulus, sol::meta_function::power_of,   sol::meta_function::involution = power_of, sol::meta_function::concatenation, sol::meta_function::equal_to, sol::meta_function::less_than,   sol::meta_function::less_than_or_equal_to, sol::meta_function::garbage_collect, sol::meta_function::floor_division, sol::meta_function::bitwise_left_shift,   sol::meta_function::bitwise_right_shift, sol::meta_function::bitwise_not, sol::meta_function::bitwise_and, sol::meta_function::bitwise_or,   sol::meta_function::bitwise_xor, sol::meta_function::pairs, sol::meta_function::ipairs, sol::meta_function::next,   sol::meta_function::type, sol::meta_function::type_info }
enum	sol::unicode::error_code {   sol::unicode::error_code::ok = 0, sol::unicode::error_code::invalid_code_point, sol::unicode::error_code::invalid_code_unit, sol::unicode::error_code::invalid_leading_surrogate,   sol::unicode::error_code::invalid_trailing_surrogate, sol::unicode::error_code::sequence_too_short, sol::unicode::error_code::overlong_sequence }

Functions
template<typename T , typename U , typename = decltype(std::declval<T&>() < std::declval<U&>())>
std::true_type	sol::meta::meta_detail::supports_op_less_test (const T &, const U &)
std::false_type	sol::meta::meta_detail::supports_op_less_test (...)
template<typename T , typename U , typename = decltype(std::declval<T&>() == std::declval<U&>())>
std::true_type	sol::meta::meta_detail::supports_op_equal_test (const T &, const U &)
std::false_type	sol::meta::meta_detail::supports_op_equal_test (...)
template<typename T , typename U , typename = decltype(std::declval<T&>() <= std::declval<U&>())>
std::true_type	sol::meta::meta_detail::supports_op_less_equal_test (const T &, const U &)
std::false_type	sol::meta::meta_detail::supports_op_less_equal_test (...)
template<typename T , typename OS , typename = decltype(std::declval<OS&>() << std::declval<T&>())>
std::true_type	sol::meta::meta_detail::supports_ostream_op (const T &, const OS &)
std::false_type	sol::meta::meta_detail::supports_ostream_op (...)
template<typename T , typename = decltype(to_string(std::declval<T&>()))>
std::true_type	sol::meta::meta_detail::supports_adl_to_string (const T &)
std::false_type	sol::meta::meta_detail::supports_adl_to_string (...)
template<typename T , meta::disable< meta::is_specialization_of< meta::unqualified_t< T >, std::tuple >> = meta::enabler>
decltype(auto)	sol::meta::meta_detail::force_tuple (T &&x)
template<typename... X>
decltype(auto)	sol::meta::tuplefy (X &&... x)
template<std::size_t I, typename Tuple >
decltype(auto)	sol::detail::forward_get (Tuple &&tuple)
template<std::size_t... I, typename Tuple >
auto	sol::detail::forward_tuple_impl (std::index_sequence< I... >, Tuple &&tuple) -> decltype(std::tuple< decltype(forward_get< I >(tuple))... >(forward_get< I >(tuple)...))
template<typename Tuple >
auto	sol::detail::forward_tuple (Tuple &&tuple)
template<typename T >
auto	sol::detail::unwrap (T &&item) -> decltype(std::forward< T >(item))
template<typename T >
T &	sol::detail::unwrap (std::reference_wrapper< T > arg)
template<typename T , meta::enable< meta::neg< is_pointer_like< meta::unqualified_t< T >>>> = meta::enabler>
auto	sol::detail::deref (T &&item) -> decltype(std::forward< T >(item))
template<typename T , meta::disable< is_pointer_like< meta::unqualified_t< T >>, meta::neg< std::is_pointer< meta::unqualified_t< T >>>> = meta::enabler>
auto	sol::detail::deref_non_pointer (T &&item) -> decltype(std::forward< T >(item))
template<typename T >
T *	sol::detail::ptr (T &val)
template<typename T >
T *	sol::detail::ptr (std::reference_wrapper< T > val)
template<typename T >
T *	sol::detail::ptr (T *val)
constexpr in_place_tag	sol::in_place (detail::in_place_of_tag)
template<typename T >
constexpr in_place_tag	sol::in_place (detail::in_place_of_t< T >)
template<std::size_t I>
constexpr in_place_tag	sol::in_place (detail::in_place_of_i< I >)
constexpr in_place_tag	sol::in_place_of (detail::in_place_of_tag)
template<typename T >
constexpr in_place_tag	sol::in_place_type (detail::in_place_of_t< T >)
template<std::size_t I>
constexpr in_place_tag	sol::in_place_index (detail::in_place_of_i< I >)
template<class T >
constexpr T &&	sol::constexpr_forward (typename ::std::remove_reference< T >::type &t) noexcept
template<class T >
constexpr T &&	sol::constexpr_forward (typename ::std::remove_reference< T >::type &&t) noexcept
template<class T >
constexpr ::std::remove_reference< T >::type &&	sol::constexpr_move (T &&t) noexcept
template<typename T , TR2_OPTIONAL_REQUIRES(!has_overloaded_addressof< T >) >
constexpr T *	sol::detail_::static_addressof (T &ref)
template<typename T , TR2_OPTIONAL_REQUIRES(has_overloaded_addressof< T >) >
T *	sol::detail_::static_addressof (T &ref)
template<class U >
constexpr U	sol::detail_::convert (U v)
template<class T >
constexpr bool	sol::operator== (const optional< T > &x, const optional< T > &y)
template<class T >
constexpr bool	sol::operator!= (const optional< T > &x, const optional< T > &y)
template<class T >
constexpr bool	sol::operator< (const optional< T > &x, const optional< T > &y)
template<class T >
constexpr bool	sol::operator> (const optional< T > &x, const optional< T > &y)
template<class T >
constexpr bool	sol::operator<= (const optional< T > &x, const optional< T > &y)
template<class T >
constexpr bool	sol::operator>= (const optional< T > &x, const optional< T > &y)
template<class T >
constexpr bool	sol::operator== (const optional< T > &x, nullopt_t) noexcept
template<class T >
constexpr bool	sol::operator== (nullopt_t, const optional< T > &x) noexcept
template<class T >
constexpr bool	sol::operator!= (const optional< T > &x, nullopt_t) noexcept
template<class T >
constexpr bool	sol::operator!= (nullopt_t, const optional< T > &x) noexcept
template<class T >
constexpr bool	sol::operator< (const optional< T > &, nullopt_t) noexcept
template<class T >
constexpr bool	sol::operator< (nullopt_t, const optional< T > &x) noexcept
template<class T >
constexpr bool	sol::operator<= (const optional< T > &x, nullopt_t) noexcept
template<class T >
constexpr bool	sol::operator<= (nullopt_t, const optional< T > &) noexcept
template<class T >
constexpr bool	sol::operator> (const optional< T > &x, nullopt_t) noexcept
template<class T >
constexpr bool	sol::operator> (nullopt_t, const optional< T > &) noexcept
template<class T >
constexpr bool	sol::operator>= (const optional< T > &, nullopt_t) noexcept
template<class T >
constexpr bool	sol::operator>= (nullopt_t, const optional< T > &x) noexcept
template<class T >
constexpr bool	sol::operator== (const optional< T > &x, const T &v)
template<class T >
constexpr bool	sol::operator== (const T &v, const optional< T > &x)
template<class T >
constexpr bool	sol::operator!= (const optional< T > &x, const T &v)
template<class T >
constexpr bool	sol::operator!= (const T &v, const optional< T > &x)
template<class T >
constexpr bool	sol::operator< (const optional< T > &x, const T &v)
template<class T >
constexpr bool	sol::operator> (const T &v, const optional< T > &x)
template<class T >
constexpr bool	sol::operator> (const optional< T > &x, const T &v)
template<class T >
constexpr bool	sol::operator< (const T &v, const optional< T > &x)
template<class T >
constexpr bool	sol::operator>= (const optional< T > &x, const T &v)
template<class T >
constexpr bool	sol::operator<= (const T &v, const optional< T > &x)
template<class T >
constexpr bool	sol::operator<= (const optional< T > &x, const T &v)
template<class T >
constexpr bool	sol::operator>= (const T &v, const optional< T > &x)
template<class T >
constexpr bool	sol::operator== (const optional< T &> &x, const T &v)
template<class T >
constexpr bool	sol::operator== (const T &v, const optional< T &> &x)
template<class T >
constexpr bool	sol::operator!= (const optional< T &> &x, const T &v)
template<class T >
constexpr bool	sol::operator!= (const T &v, const optional< T &> &x)
template<class T >
constexpr bool	sol::operator< (const optional< T &> &x, const T &v)
template<class T >
constexpr bool	sol::operator> (const T &v, const optional< T &> &x)
template<class T >
constexpr bool	sol::operator> (const optional< T &> &x, const T &v)
template<class T >
constexpr bool	sol::operator< (const T &v, const optional< T &> &x)
template<class T >
constexpr bool	sol::operator>= (const optional< T &> &x, const T &v)
template<class T >
constexpr bool	sol::operator<= (const T &v, const optional< T &> &x)
template<class T >
constexpr bool	sol::operator<= (const optional< T &> &x, const T &v)
template<class T >
constexpr bool	sol::operator>= (const T &v, const optional< T &> &x)
template<class T >
constexpr bool	sol::operator== (const optional< const T &> &x, const T &v)
template<class T >
constexpr bool	sol::operator== (const T &v, const optional< const T &> &x)
template<class T >
constexpr bool	sol::operator!= (const optional< const T &> &x, const T &v)
template<class T >
constexpr bool	sol::operator!= (const T &v, const optional< const T &> &x)
template<class T >
constexpr bool	sol::operator< (const optional< const T &> &x, const T &v)
template<class T >
constexpr bool	sol::operator> (const T &v, const optional< const T &> &x)
template<class T >
constexpr bool	sol::operator> (const optional< const T &> &x, const T &v)
template<class T >
constexpr bool	sol::operator< (const T &v, const optional< const T &> &x)
template<class T >
constexpr bool	sol::operator>= (const optional< const T &> &x, const T &v)
template<class T >
constexpr bool	sol::operator<= (const T &v, const optional< const T &> &x)
template<class T >
constexpr bool	sol::operator<= (const optional< const T &> &x, const T &v)
template<class T >
constexpr bool	sol::operator>= (const T &v, const optional< const T &> &x)
template<class T >
void	sol::swap (optional< T > &x, optional< T > &y) noexcept(noexcept(x.swap(y)))
template<class T >
constexpr optional< typename ::std::decay< T >::type >	sol::make_optional (T &&v)
template<class X >
constexpr optional< X & >	sol::make_optional (::std::reference_wrapper< X > v)
template<typename T , typename Regs , typename Fx >
void	sol::usertype_detail::insert_default_registrations (Regs &l, int &index, Fx &&fx)
template<typename T , typename Regs , meta::enable< meta::neg< std::is_pointer< T >>, std::is_destructible< T >> = meta::enabler>
void	sol::usertype_detail::make_destructor (Regs &l, int &index)
template<typename T , typename Dx , typename... Args>
std::unique_ptr< T, Dx >	sol::detail::make_unique_deleter (Args &&... args)
template<typename... Functions>
auto	sol::initializers (Functions &&... functions)
template<typename... Functions>
auto	sol::factories (Functions &&... functions)
template<typename Fx >
auto	sol::destructor (Fx &&fx)
template<typename F , typename... Args>
auto	sol::filters (F &&f, Args &&... args)
bool	sol::operator== (lua_nil_t, lua_nil_t)
bool	sol::operator!= (lua_nil_t, lua_nil_t)
template<typename F >
yielding_t< std::decay_t< F > >	sol::yielding (F &&f)
template<typename T >
auto	sol::make_light (T &l)
template<typename T >
auto	sol::make_user (T &&u)
template<typename T >
auto	sol::meta_registry_key (T &&key)
template<typename... Args>
closure< Args... >	sol::make_closure (lua_CFunction f, Args &&... args)
template<typename Sig = function_sig<>, typename... Args>
auto	sol::as_function (Args &&... args)
template<typename Sig = function_sig<>, typename... Args>
auto	sol::as_function_reference (Args &&... args)
template<typename T >
as_table_t< T >	sol::as_table_ref (T &&container)
template<typename T >
as_table_t< meta::unqualified_t< T > >	sol::as_table (T &&container)
template<typename T >
nested< T >	sol::as_nested_ref (T &&container)
template<typename T >
nested< meta::unqualified_t< T > >	sol::as_nested (T &&container)
const std::string &	sol::to_string (call_status c)
bool	sol::is_indeterminate_call_failure (call_status c)
const std::string &	sol::to_string (load_status c)
const std::string &	sol::to_string (load_mode c)
const std::array< std::string, 32 > &	sol::meta_function_names ()
const std::string &	sol::to_string (meta_function mf)
type	sol::type_of (lua_State *L, int index)
std::string	sol::type_name (lua_State *L, type t)
template<typename T >
type	sol::type_of ()
const char(&	sol::detail::default_exception_handler_name ())[11]
int	sol::detail::default_exception_handler (lua_State *L, optional< const std::exception &>, string_view what)
int	sol::detail::call_exception_handler (lua_State *L, optional< const std::exception &> maybe_ex, string_view what)
template<lua_CFunction f>
int	sol::detail::static_trampoline (lua_State *L)
template<lua_CFunction f>
int	sol::detail::static_trampoline_noexcept (lua_State *L) noexcept
template<typename Fx , typename... Args>
int	sol::detail::trampoline (lua_State *L, Fx &&f, Args &&... args)
int	sol::detail::c_trampoline (lua_State *L, lua_CFunction f)
template<typename F , F fx>
int	sol::detail::typed_static_trampoline_raw (std::true_type, lua_State *L)
template<typename F , F fx>
int	sol::detail::typed_static_trampoline_raw (std::false_type, lua_State *L)
template<typename F , F fx>
int	sol::detail::typed_static_trampoline (lua_State *L)
void	sol::set_default_exception_handler (lua_State *L, exception_handler_function exf=&detail::default_exception_handler)
template<typename T >
std::string	sol::detail::demangle_once ()
template<typename T >
std::string	sol::detail::short_demangle_once ()
template<typename T >
const std::string &	sol::detail::demangle ()
template<typename T >
const std::string &	sol::detail::short_demangle ()
decltype(auto)	sol::detail::base_class_check_key ()
decltype(auto)	sol::detail::base_class_cast_key ()
decltype(auto)	sol::detail::base_class_index_propogation_key ()
decltype(auto)	sol::detail::base_class_new_index_propogation_key ()
std::string	sol::associated_type_name (lua_State *L, int index, type t)
int	sol::type_panic_string (lua_State *L, int index, type expected, type actual, const std::string &message="") noexcept(false)
int	sol::type_panic_c_str (lua_State *L, int index, type expected, type actual, const char *message=nullptr) noexcept(false)
int	sol::no_panic (lua_State *, int, type, type, const char *=nullptr) noexcept
void	sol::type_error (lua_State *L, int expected, int actual) noexcept(false)
void	sol::type_error (lua_State *L, type expected, type actual) noexcept(false)
void	sol::type_assert (lua_State *L, int index, type expected, type actual) noexcept(false)
void	sol::type_assert (lua_State *L, int index, type expected)
bool	sol::detail::xmovable (lua_State *leftL, lua_State *rightL)
bool	sol::operator== (const stack_reference &l, const stack_reference &r)
bool	sol::operator!= (const stack_reference &l, const stack_reference &r)
bool	sol::operator== (const stack_reference &lhs, const lua_nil_t &)
bool	sol::operator== (const lua_nil_t &, const stack_reference &rhs)
bool	sol::operator!= (const stack_reference &lhs, const lua_nil_t &)
bool	sol::operator!= (const lua_nil_t &, const stack_reference &rhs)
const char(&	sol::detail::default_main_thread_name ())[9]
void	sol::stack::remove (lua_State *L, int rawindex, int count)
template<bool top_level = false, typename T >
push_popper< top_level, T >	sol::stack::push_pop (T &&x)
template<typename T >
push_popper_at	sol::stack::push_pop_at (T &&x)
template<bool top_level = false>
push_popper_n< top_level >	sol::stack::pop_n (lua_State *L, int x)
lua_State *	sol::main_thread (lua_State *L, lua_State *backup_if_unsupported=nullptr)
template<bool b>
lua_State *	sol::detail::pick_main_thread (lua_State *L, lua_State *backup_if_unsupported=nullptr)
template<bool lb, bool rb>
bool	sol::operator== (const basic_reference< lb > &l, const basic_reference< rb > &r)
template<bool lb, bool rb>
bool	sol::operator!= (const basic_reference< lb > &l, const basic_reference< rb > &r)
template<bool lb>
bool	sol::operator== (const basic_reference< lb > &lhs, const lua_nil_t &)
template<bool rb>
bool	sol::operator== (const lua_nil_t &, const basic_reference< rb > &rhs)
template<bool lb>
bool	sol::operator!= (const basic_reference< lb > &lhs, const lua_nil_t &)
template<bool rb>
bool	sol::operator!= (const lua_nil_t &, const basic_reference< rb > &rhs)
template<typename... Tn>
tie_t< std::remove_reference_t< Tn >... >	sol::adl_barrier_detail::tie (Tn &&... argn)
void	sol::detail::stack_fail (int, int)
void *	sol::detail::align (std::size_t alignment, std::size_t size, void *&ptr, std::size_t &space, std::size_t &required_space)
void *	sol::detail::align (std::size_t alignment, std::size_t size, void *&ptr, std::size_t &space)
template<typename... Args>
std::size_t	sol::detail::aligned_space_for (void *alignment=nullptr)
void *	sol::detail::align_usertype_pointer (void *ptr)
template<bool pre_aligned = false>
void *	sol::detail::align_usertype_unique_destructor (void *ptr)
template<bool pre_aligned = false>
void *	sol::detail::align_usertype_unique_tag (void *ptr)
template<typename T , bool pre_aligned = false>
void *	sol::detail::align_usertype_unique (void *ptr)
template<typename T >
void *	sol::detail::align_user (void *ptr)
template<typename T >
T **	sol::detail::usertype_allocate_pointer (lua_State *L)
template<typename T >
T *	sol::detail::usertype_allocate (lua_State *L)
template<typename T , typename Real >
Real *	sol::detail::usertype_unique_allocate (lua_State *L, T **&pref, unique_destructor *&dx, unique_tag *&id)
template<typename T >
T *	sol::detail::user_allocate (lua_State *L)
template<typename T >
int	sol::detail::usertype_alloc_destruct (lua_State *L)
template<typename T >
int	sol::detail::unique_destruct (lua_State *L)
template<typename T >
int	sol::detail::user_alloc_destruct (lua_State *L)
template<typename T , typename Real >
void	sol::detail::usertype_unique_alloc_destroy (void *memory)
template<typename T >
int	sol::detail::cannot_destruct (lua_State *L)
template<typename T >
void	sol::detail::reserve (T &, std::size_t)
template<typename T , typename Al >
void	sol::detail::reserve (std::vector< T, Al > &arr, std::size_t hint)
template<typename T , typename Tr , typename Al >
void	sol::detail::reserve (std::basic_string< T, Tr, Al > &arr, std::size_t hint)
template<typename C >
static int	sol::stack::stack_detail::get_size_hint (const C &c)
template<typename V , typename Al >
static int	sol::stack::stack_detail::get_size_hint (const std::forward_list< V, Al > &)
template<typename T >
decltype(auto)	sol::stack::stack_detail::unchecked_unqualified_get (lua_State *L, int index, record &tracking)
template<typename T >
decltype(auto)	sol::stack::stack_detail::unchecked_get (lua_State *L, int index, record &tracking)
template<typename T , typename Arg , typename... Args>
int	sol::stack::stack_detail::push_reference (lua_State *L, Arg &&arg, Args &&... args)
template<typename T , typename Handler >
bool	sol::stack::stack_detail::check_usertype (std::false_type, lua_State *L, int index, type indextype, Handler &&handler, record &tracking)
template<typename T , typename Handler >
bool	sol::stack::stack_detail::check_usertype (std::true_type, lua_State *L, int index, type indextype, Handler &&handler, record &tracking)
bool	sol::stack::maybe_indexable (lua_State *L, int index=-1)
int	sol::stack::top (lua_State *L)
bool	sol::stack::is_main_thread (lua_State *L)
void	sol::stack::coroutine_create_guard (lua_State *L)
template<typename T , typename... Args>
int	sol::stack::push (lua_State *L, T &&t, Args &&... args)
template<typename T , typename Arg , typename... Args, typename = std::enable_if_t<!std::is_same<T, Arg>::value>>
int	sol::stack::push (lua_State *L, Arg &&arg, Args &&... args)
template<typename T , typename... Args>
int	sol::stack::push_reference (lua_State *L, T &&t, Args &&... args)
template<typename T , typename Arg , typename... Args>
int	sol::stack::push_reference (lua_State *L, Arg &&arg, Args &&... args)
int	sol::stack::multi_push (lua_State *)
template<typename T , typename... Args>
int	sol::stack::multi_push (lua_State *L, T &&t, Args &&... args)
int	sol::stack::multi_push_reference (lua_State *)
template<typename T , typename... Args>
int	sol::stack::multi_push_reference (lua_State *L, T &&t, Args &&... args)
template<typename T , typename Handler >
bool	sol::stack::check (lua_State *L, int index, Handler &&handler, record &tracking)
template<typename T , typename Handler >
bool	sol::stack::check (lua_State *L, int index, Handler &&handler)
template<typename T >
bool	sol::stack::check (lua_State *L, int index=-lua_size< meta::unqualified_t< T >>::value)
template<typename T , typename Handler >
bool	sol::stack::unqualified_check (lua_State *L, int index, Handler &&handler, record &tracking)
template<typename T , typename Handler >
bool	sol::stack::unqualified_check (lua_State *L, int index, Handler &&handler)
template<typename T >
bool	sol::stack::unqualified_check (lua_State *L, int index=-lua_size< meta::unqualified_t< T >>::value)
template<typename T , typename Handler >
bool	sol::stack::check_usertype (lua_State *L, int index, Handler &&handler, record &tracking)
template<typename T , typename Handler >
bool	sol::stack::check_usertype (lua_State *L, int index, Handler &&handler)
template<typename T >
bool	sol::stack::check_usertype (lua_State *L, int index=-lua_size< meta::unqualified_t< T >>::value)
template<typename T , typename Handler >
decltype(auto)	sol::stack::unqualified_check_get (lua_State *L, int index, Handler &&handler, record &tracking)
template<typename T , typename Handler >
decltype(auto)	sol::stack::unqualified_check_get (lua_State *L, int index, Handler &&handler)
template<typename T >
decltype(auto)	sol::stack::unqualified_check_get (lua_State *L, int index=-lua_size< meta::unqualified_t< T >>::value)
template<typename T , typename Handler >
decltype(auto)	sol::stack::check_get (lua_State *L, int index, Handler &&handler, record &tracking)
template<typename T , typename Handler >
decltype(auto)	sol::stack::check_get (lua_State *L, int index, Handler &&handler)
template<typename T >
decltype(auto)	sol::stack::check_get (lua_State *L, int index=-lua_size< meta::unqualified_t< T >>::value)
template<typename T >
decltype(auto)	sol::stack::stack_detail::tagged_unqualified_get (types< T >, lua_State *L, int index, record &tracking)
template<typename T >
decltype(auto)	sol::stack::stack_detail::tagged_get (types< T >, lua_State *L, int index, record &tracking)
template<bool b, typename... Args, typename Handler >
bool	sol::stack::multi_check (lua_State *L, int index, Handler &&handler, record &tracking)
template<bool b, typename... Args, typename Handler >
bool	sol::stack::multi_check (lua_State *L, int index, Handler &&handler)
template<bool b, typename... Args>
bool	sol::stack::multi_check (lua_State *L, int index)
template<typename... Args, typename Handler >
bool	sol::stack::multi_check (lua_State *L, int index, Handler &&handler, record &tracking)
template<typename... Args, typename Handler >
bool	sol::stack::multi_check (lua_State *L, int index, Handler &&handler)
template<typename... Args>
bool	sol::stack::multi_check (lua_State *L, int index)
template<typename T >
decltype(auto)	sol::stack::get_usertype (lua_State *L, int index, record &tracking)
template<typename T >
decltype(auto)	sol::stack::get_usertype (lua_State *L, int index=-lua_size< meta::unqualified_t< T >>::value)
template<typename T >
decltype(auto)	sol::stack::unqualified_get (lua_State *L, int index, record &tracking)
template<typename T >
decltype(auto)	sol::stack::unqualified_get (lua_State *L, int index=-lua_size< meta::unqualified_t< T >>::value)
template<typename T >
decltype(auto)	sol::stack::get (lua_State *L, int index, record &tracking)
template<typename T >
decltype(auto)	sol::stack::get (lua_State *L, int index=-lua_size< meta::unqualified_t< T >>::value)
template<typename T >
decltype(auto)	sol::stack::pop (lua_State *L)
template<bool global = false, bool raw = false, typename Key >
void	sol::stack::get_field (lua_State *L, Key &&key)
template<bool global = false, bool raw = false, typename Key >
void	sol::stack::get_field (lua_State *L, Key &&key, int tableindex)
template<bool global = false, typename Key >
void	sol::stack::raw_get_field (lua_State *L, Key &&key)
template<bool global = false, typename Key >
void	sol::stack::raw_get_field (lua_State *L, Key &&key, int tableindex)
template<bool global = false, bool raw = false, typename C = detail::non_lua_nil_t, typename Key >
probe	sol::stack::probe_get_field (lua_State *L, Key &&key)
template<bool global = false, bool raw = false, typename C = detail::non_lua_nil_t, typename Key >
probe	sol::stack::probe_get_field (lua_State *L, Key &&key, int tableindex)
template<bool global = false, typename C = detail::non_lua_nil_t, typename Key >
probe	sol::stack::probe_raw_get_field (lua_State *L, Key &&key)
template<bool global = false, typename C = detail::non_lua_nil_t, typename Key >
probe	sol::stack::probe_raw_get_field (lua_State *L, Key &&key, int tableindex)
template<bool global = false, bool raw = false, typename Key , typename Value >
void	sol::stack::set_field (lua_State *L, Key &&key, Value &&value)
template<bool global = false, bool raw = false, typename Key , typename Value >
void	sol::stack::set_field (lua_State *L, Key &&key, Value &&value, int tableindex)
template<bool global = false, typename Key , typename Value >
void	sol::stack::raw_set_field (lua_State *L, Key &&key, Value &&value)
template<bool global = false, typename Key , typename Value >
void	sol::stack::raw_set_field (lua_State *L, Key &&key, Value &&value, int tableindex)
template<typename T , typename F >
void	sol::stack::modify_unique_usertype_as (const stack_reference &obj, F &&f)
template<typename F >
void	sol::stack::modify_unique_usertype (const stack_reference &obj, F &&f)
template<typename T , bool poptable = true>
bool	sol::stack::stack_detail::check_metatable (lua_State *L, int index=-2)
template<typename... Args>
decltype(auto)	sol::overload (Args &&... args)
const string_view &	sol::unicode::to_string (error_code ec)
encoded_result< char >	sol::unicode::code_point_to_utf8 (char32_t codepoint)
encoded_result< char16_t >	sol::unicode::code_point_to_utf16 (char32_t codepoint)
encoded_result< char32_t >	sol::unicode::code_point_to_utf32 (char32_t codepoint)
template<typename It >
decoded_result< It >	sol::unicode::utf8_to_code_point (It it, It last)
template<typename It >
decoded_result< It >	sol::unicode::utf16_to_code_point (It it, It last)
template<typename It >
decoded_result< It >	sol::unicode::utf32_to_code_point (It it, It last)
int	sol::stack::push_environment_of (lua_State *L, int index=-1)
template<typename T >
int	sol::stack::push_environment_of (const T &target)
const std::string &	sol::detail::default_chunk_name ()
template<std::size_t N>
const char *	sol::detail::make_chunk_name (const string_view &code, const std::string &chunkname, char(&basechunkname)[N])
template<typename T >
int	sol::stack::stack_detail::push_as_upvalues (lua_State *L, T &item)
template<typename T >
std::pair< T, int >	sol::stack::stack_detail::get_as_upvalues (lua_State *L, int index=2)
template<bool checkargs = detail::default_safe_function_calls, std::size_t... I, typename R , typename... Args, typename Fx , typename... FxArgs, typename = std::enable_if_t<!std::is_void<R>::value >>
decltype(auto)	sol::stack::stack_detail::call (types< R >, types< Args... > ta, std::index_sequence< I... > tai, lua_State *L, int start, Fx &&fx, FxArgs &&... args)
template<bool checkargs = detail::default_safe_function_calls, std::size_t... I, typename... Args, typename Fx , typename... FxArgs>
void	sol::stack::stack_detail::call (types< void >, types< Args... > ta, std::index_sequence< I... > tai, lua_State *L, int start, Fx &&fx, FxArgs &&... args)
template<typename T >
int	sol::stack::set_ref (lua_State *L, T &&arg, int tableindex=-2)
template<bool check_args = detail::default_safe_function_calls, typename R , typename... Args, typename Fx , typename... FxArgs, typename = std::enable_if_t<!std::is_void<R>::value>>
decltype(auto)	sol::stack::call (types< R > tr, types< Args... > ta, lua_State *L, int start, Fx &&fx, FxArgs &&... args)
template<bool check_args = detail::default_safe_function_calls, typename R , typename... Args, typename Fx , typename... FxArgs, typename = std::enable_if_t<!std::is_void<R>::value>>
decltype(auto)	sol::stack::call (types< R > tr, types< Args... > ta, lua_State *L, Fx &&fx, FxArgs &&... args)
template<bool check_args = detail::default_safe_function_calls, typename... Args, typename Fx , typename... FxArgs>
void	sol::stack::call (types< void > tr, types< Args... > ta, lua_State *L, int start, Fx &&fx, FxArgs &&... args)
template<bool check_args = detail::default_safe_function_calls, typename... Args, typename Fx , typename... FxArgs>
void	sol::stack::call (types< void > tr, types< Args... > ta, lua_State *L, Fx &&fx, FxArgs &&... args)
template<bool check_args = detail::default_safe_function_calls, typename R , typename... Args, typename Fx , typename... FxArgs, typename = std::enable_if_t<!std::is_void<R>::value>>
decltype(auto)	sol::stack::call_from_top (types< R > tr, types< Args... > ta, lua_State *L, Fx &&fx, FxArgs &&... args)
template<bool check_args = detail::default_safe_function_calls, typename... Args, typename Fx , typename... FxArgs>
void	sol::stack::call_from_top (types< void > tr, types< Args... > ta, lua_State *L, Fx &&fx, FxArgs &&... args)
template<bool check_args = detail::default_safe_function_calls, bool clean_stack = true, typename... Args, typename Fx , typename... FxArgs>
int	sol::stack::call_into_lua (types< void > tr, types< Args... > ta, lua_State *L, int start, Fx &&fx, FxArgs &&... fxargs)
template<bool check_args = detail::default_safe_function_calls, bool clean_stack = true, typename Ret0 , typename... Ret, typename... Args, typename Fx , typename... FxArgs, typename = std::enable_if_t<meta::neg<std::is_void<Ret0>>::value>>
int	sol::stack::call_into_lua (types< Ret0, Ret... >, types< Args... > ta, lua_State *L, int start, Fx &&fx, FxArgs &&... fxargs)
template<bool check_args = detail::default_safe_function_calls, bool clean_stack = true, typename Fx , typename... FxArgs>
int	sol::stack::call_lua (lua_State *L, int start, Fx &&fx, FxArgs &&... fxargs)
call_syntax	sol::stack::get_call_syntax (lua_State *L, const string_view &key, int index)
void	sol::stack::script (lua_State *L, const string_view &code, const std::string &chunkname=detail::default_chunk_name(), load_mode mode=load_mode::any)
void	sol::stack::script_file (lua_State *L, const std::string &filename, load_mode mode=load_mode::any)
void	sol::stack::luajit_exception_handler (lua_State *L, int(*handler)(lua_State *, lua_CFunction)=detail::c_trampoline)
void	sol::stack::luajit_exception_off (lua_State *L)
template<typename proxy_t , bool is_const>
stack_iterator< proxy_t, is_const >	sol::operator+ (typename stack_iterator< proxy_t, is_const >::difference_type n, const stack_iterator< proxy_t, is_const > &r)
template<std::size_t I, typename... Args, typename T >
stack_proxy	sol::detail::get (types< Args... >, index_value< 0 >, index_value< I >, const T &fr)
template<std::size_t I, std::size_t N, typename Arg , typename... Args, typename T , meta::enable< meta::boolean<(N > 0)> >
stack_proxy	sol::detail::get (types< Arg, Args... >, index_value< N >, index_value< I >, const T &fr)
template<std::size_t I>
stack_proxy	sol::get (const unsafe_function_result &fr)
template<std::size_t I, typename... Args>
stack_proxy	sol::get (types< Args... > t, const unsafe_function_result &fr)
template<std::size_t I>
stack_proxy	sol::get (const protected_function_result &fr)
template<std::size_t I, typename... Args>
stack_proxy	sol::get (types< Args... > t, const protected_function_result &fr)
template<typename Fx , int start = 1, bool is_yielding = false>
int	sol::function_detail::call (lua_State *L)
template<typename T >
auto	sol::protect (T &&value)
template<typename R , typename W >
decltype(auto)	sol::property_detail::property (std::true_type, R &&read, W &&write)
template<typename W , typename R >
decltype(auto)	sol::property_detail::property (std::false_type, W &&write, R &&read)
template<typename R >
decltype(auto)	sol::property_detail::property (std::true_type, R &&read)
template<typename W >
decltype(auto)	sol::property_detail::property (std::false_type, W &&write)
template<typename F , typename G >
decltype(auto)	sol::property (F &&f, G &&g)
template<typename F >
decltype(auto)	sol::property (F &&f)
template<typename F >
decltype(auto)	sol::readonly_property (F &&f)
template<typename F >
decltype(auto)	sol::writeonly_property (F &&f)
template<typename R , typename T >
auto	sol::readonly (R T::*v)
template<typename V >
auto	sol::var (V &&v)
template<int I, int... In>
void	sol::filter_detail::handle_filter (static_stack_dependencies< I, In... >, lua_State *L, int &)
template<int... In>
void	sol::filter_detail::handle_filter (returns_self_with< In... >, lua_State *L, int &pushed)
void	sol::filter_detail::handle_filter (const stack_dependencies &sdeps, lua_State *L, int &)
template<typename P , meta::disable< std::is_base_of< detail::filter_base_tag, meta::unqualified_t< P >>> = meta::enabler>
void	sol::filter_detail::handle_filter (P &&p, lua_State *L, int &pushed)
int	sol::function_detail::no_construction_error (lua_State *L)
template<typename R , typename W >
auto &	sol::call_detail::pick (std::true_type, property_wrapper< R, W > &f)
template<typename R , typename W >
auto &	sol::call_detail::pick (std::false_type, property_wrapper< R, W > &f)
template<std::size_t... M, typename Match , typename... Args>
int	sol::call_detail::overload_detail::overload_match_arity (types<>, std::index_sequence<>, std::index_sequence< M... >, Match &&, lua_State *L, int, int, Args &&...)
template<typename Fx , typename... Fxs, std::size_t I, std::size_t... In, std::size_t... M, typename Match , typename... Args>
int	sol::call_detail::overload_detail::overload_match_arity (types< Fx, Fxs... >, std::index_sequence< I, In... >, std::index_sequence< M... >, Match &&matchfx, lua_State *L, int fxarity, int start, Args &&... args)
template<std::size_t... M, typename Match , typename... Args>
int	sol::call_detail::overload_detail::overload_match_arity_single (types<>, std::index_sequence<>, std::index_sequence< M... >, Match &&matchfx, lua_State *L, int fxarity, int start, Args &&... args)
template<typename Fx , std::size_t I, std::size_t... M, typename Match , typename... Args>
int	sol::call_detail::overload_detail::overload_match_arity_single (types< Fx >, std::index_sequence< I >, std::index_sequence< M... >, Match &&matchfx, lua_State *L, int fxarity, int start, Args &&... args)
template<typename Fx , typename Fx1 , typename... Fxs, std::size_t I, std::size_t I1, std::size_t... In, std::size_t... M, typename Match , typename... Args>
int	sol::call_detail::overload_detail::overload_match_arity_single (types< Fx, Fx1, Fxs... >, std::index_sequence< I, I1, In... >, std::index_sequence< M... >, Match &&matchfx, lua_State *L, int fxarity, int start, Args &&... args)
template<typename... Functions, typename Match , typename... Args>
int	sol::call_detail::overload_match_arity (Match &&matchfx, lua_State *L, int fxarity, int start, Args &&... args)
template<typename... Functions, typename Match , typename... Args>
int	sol::call_detail::overload_match (Match &&matchfx, lua_State *L, int start, Args &&... args)
template<typename T , typename... TypeLists, typename Match , typename... Args>
int	sol::call_detail::construct_match (Match &&matchfx, lua_State *L, int fxarity, int start, Args &&... args)
template<typename T , bool checked, bool clean_stack, typename... TypeLists>
int	sol::call_detail::construct_trampolined (lua_State *L)
template<typename T , bool checked, bool clean_stack, typename... TypeLists>
int	sol::call_detail::construct (lua_State *L)
template<typename T , bool is_index, bool is_variable, int boost = 0, bool checked = detail::default_safe_function_calls, bool clean_stack = true, typename Fx , typename... Args>
int	sol::call_detail::call_wrapped (lua_State *L, Fx &&fx, Args &&... args)
template<typename T , bool is_index, bool is_variable, typename F , int start = 1, bool checked = detail::default_safe_function_calls, bool clean_stack = true>
int	sol::call_detail::call_user (lua_State *L)
template<typename F , F fx>
int	sol::function_detail::call_wrapper_variable (std::false_type, lua_State *L)
template<typename R , typename V , V , typename T >
int	sol::function_detail::call_set_assignable (std::false_type, T &&, lua_State *L)
template<typename R , typename V , V variable, typename T >
int	sol::function_detail::call_set_assignable (std::true_type, lua_State *L, T &&mem)
template<typename R , typename V , V , typename T >
int	sol::function_detail::call_set_variable (std::false_type, lua_State *L, T &&)
template<typename R , typename V , V variable, typename T >
int	sol::function_detail::call_set_variable (std::true_type, lua_State *L, T &&mem)
template<typename V , V variable>
int	sol::function_detail::call_wrapper_variable (std::true_type, lua_State *L)
template<typename F , F fx>
int	sol::function_detail::call_wrapper_function (std::false_type, lua_State *L)
template<typename F , F fx>
int	sol::function_detail::call_wrapper_function (std::true_type, lua_State *L)
template<typename F , F fx>
int	sol::function_detail::call_wrapper_entry (lua_State *L) noexcept(meta::bind_traits< F >::is_noexcept)
template<typename F , F fx>
int	sol::function_detail::c_call_raw (std::true_type, lua_State *L)
template<typename F , F fx>
int	sol::function_detail::c_call_raw (std::false_type, lua_State *L)
template<typename F , F fx>
int	sol::c_call (lua_State *L)
template<typename... Fxs>
int	sol::c_call (lua_State *L)
template<typename R , typename... Args, typename F , typename = std::result_of_t<meta::unqualified_t<F>(Args...)>>
constexpr auto	sol::detail::resolve_i (types< R(Args...)>, F &&) -> R(meta::unqualified_t< F >::*)(Args...)
template<typename F , typename U = meta::unqualified_t<F>>
constexpr auto	sol::detail::resolve_f (std::true_type, F &&f) -> decltype(resolve_i(types< meta::function_signature_t< decltype(&U::operator())>>(), std::forward< F >(f)))
template<typename F >
constexpr void	sol::detail::resolve_f (std::false_type, F &&)
template<typename F , typename U = meta::unqualified_t<F>>
constexpr auto	sol::detail::resolve_i (types<>, F &&f) -> decltype(resolve_f(meta::has_deducible_signature< U >(), std::forward< F >(f)))
template<typename... Args, typename F , typename R = std::result_of_t<F&(Args...)>>
constexpr auto	sol::detail::resolve_i (types< Args... >, F &&f) -> decltype(resolve_i(types< R(Args...)>(), std::forward< F >(f)))
template<typename Sig , typename C >
constexpr Sig C::*	sol::detail::resolve_v (std::false_type, Sig C::*mem_func_ptr)
template<typename Sig , typename C >
constexpr Sig C::*	sol::detail::resolve_v (std::true_type, Sig C::*mem_variable_ptr)
template<typename... Args, typename R >
constexpr auto	sol::resolve (R fun_ptr(Args...)) -> R(*)(Args...)
template<typename Sig >
constexpr Sig *	sol::resolve (Sig *fun_ptr)
template<typename... Args, typename R , typename C >
constexpr auto	sol::resolve (R(C::*mem_ptr)(Args...)) -> R(C::*)(Args...)
template<typename Sig , typename C >
constexpr Sig C::*	sol::resolve (Sig C::*mem_ptr)
template<typename... Sig, typename F , meta::disable< std::is_function< meta::unqualified_t< F >>> = meta::enabler>
constexpr auto	sol::resolve (F &&f) -> decltype(detail::resolve_i(types< Sig... >(), std::forward< F >(f)))
const char(&	sol::detail::default_handler_name ())[9]
template<typename base_t , typename T >
basic_function< base_t >	sol::detail::force_cast (T &p)
template<typename Reference , bool is_main_ref = false>
static Reference	sol::detail::get_default_handler (lua_State *L)
template<typename T >
static void	sol::detail::set_default_handler (lua_State *L, const T &ref)
template<typename Table , typename Key , typename T >
bool	sol::operator== (T &&left, const proxy< Table, Key > &right)
template<typename Table , typename Key , typename T >
bool	sol::operator== (const proxy< Table, Key > &right, T &&left)
template<typename Table , typename Key , typename T >
bool	sol::operator!= (T &&left, const proxy< Table, Key > &right)
template<typename Table , typename Key , typename T >
bool	sol::operator!= (const proxy< Table, Key > &right, T &&left)
template<typename Table , typename Key >
bool	sol::operator== (lua_nil_t, const proxy< Table, Key > &right)
template<typename Table , typename Key >
bool	sol::operator== (const proxy< Table, Key > &right, lua_nil_t)
template<typename Table , typename Key >
bool	sol::operator!= (lua_nil_t, const proxy< Table, Key > &right)
template<typename Table , typename Key >
bool	sol::operator!= (const proxy< Table, Key > &right, lua_nil_t)
template<typename Source >
auto	sol::as_args (Source &&source)
template<typename R = reference, bool should_pop = !is_stack_based<R>::value, typename T >
R	sol::make_reference (lua_State *L, T &&value)
template<typename T , typename R = reference, bool should_pop = !is_stack_based<R>::value, typename... Args>
R	sol::make_reference (lua_State *L, Args &&... args)
template<typename T >
object	sol::make_object (lua_State *L, T &&value)
template<typename T , typename... Args>
object	sol::make_object (lua_State *L, Args &&... args)
template<typename T >
auto	sol::as_container (T &&value)
template<typename T >
decltype(auto)	sol::container_detail::get_key (std::false_type, T &&t)
template<typename T >
decltype(auto)	sol::container_detail::get_key (std::true_type, T &&t)
template<typename T >
decltype(auto)	sol::container_detail::get_value (std::false_type, T &&t)
template<typename T >
decltype(auto)	sol::container_detail::get_value (std::true_type, T &&t)
int	sol::container_detail::handle_errors (lua_State *L, const error_result &er)
template<typename T >
int	sol::usertype_detail::is_check (lua_State *L)
template<typename T >
int	sol::usertype_detail::member_default_to_string (std::true_type, lua_State *L)
template<typename T >
int	sol::usertype_detail::member_default_to_string (std::false_type, lua_State *L)
template<typename T >
int	sol::usertype_detail::adl_default_to_string (std::true_type, lua_State *L)
template<typename T >
int	sol::usertype_detail::adl_default_to_string (std::false_type, lua_State *L)
template<typename T >
int	sol::usertype_detail::oss_default_to_string (std::true_type, lua_State *L)
template<typename T >
int	sol::usertype_detail::oss_default_to_string (std::false_type, lua_State *L)
template<typename T >
int	sol::usertype_detail::default_to_string (lua_State *L)
template<typename T , typename Op >
int	sol::usertype_detail::comparsion_operator_wrap (lua_State *L)
template<typename T , typename Op , typename Supports , typename Regs , meta::enable< Supports > = meta::enabler>
void	sol::usertype_detail::make_reg_op (Regs &l, int &index, const char *name)
template<typename T , typename Supports , typename Regs , meta::enable< Supports > = meta::enabler>
void	sol::usertype_detail::make_to_string_op (Regs &l, int &index)
template<typename T , typename Regs , meta::enable< meta::has_deducible_signature< T >> = meta::enabler>
void	sol::usertype_detail::make_call_op (Regs &l, int &index)
template<typename T , typename Regs >
void	sol::usertype_detail::make_length_op_const (std::true_type, Regs &l, int &index)
template<typename T , typename Regs >
void	sol::usertype_detail::make_length_op_const (std::false_type, Regs &l, int &index)
template<typename T , typename Regs , meta::enable< meta::has_size< T >, meta::has_size< const T >> = meta::enabler>
void	sol::usertype_detail::make_length_op (Regs &l, int &index)
template<typename T , typename Regs , typename Fx >
void	sol::usertype_detail::insert_default_registrations (std::false_type, Regs &, int &, Fx &&)
template<typename T , typename Regs , typename Fx >
void	sol::usertype_detail::insert_default_registrations (std::true_type, Regs &l, int &index, Fx &&fx)
int	sol::usertype_detail::is_indexer (string_view s)
int	sol::usertype_detail::is_indexer (meta_function mf)
int	sol::usertype_detail::is_indexer (call_construction)
int	sol::usertype_detail::is_indexer (base_classes_tag)
auto	sol::usertype_detail::make_string_view (string_view s)
auto	sol::usertype_detail::make_string_view (call_construction)
auto	sol::usertype_detail::make_string_view (meta_function mf)
auto	sol::usertype_detail::make_string_view (base_classes_tag)
template<typename Arg >
std::string	sol::usertype_detail::make_string (Arg &&arg)
template<typename N >
luaL_Reg	sol::usertype_detail::make_reg (N &&n, lua_CFunction f)
bool	sol::usertype_detail::is_toplevel (lua_State *L, int index=magic_index)
int	sol::usertype_detail::runtime_object_call (lua_State *L, void *, usertype_metatable_core &umc, int runtimetarget)
template<typename T , bool is_index>
int	sol::usertype_detail::indexing_fail (lua_State *L)
int	sol::usertype_detail::runtime_new_index (lua_State *L, void *, usertype_metatable_core &, int runtimetarget)
template<typename T , bool is_simple>
int	sol::usertype_detail::metatable_new_index (lua_State *L)
template<bool is_index, typename Base >
static void	sol::usertype_detail::walk_single_base (lua_State *L, bool &found, int &ret, string_view &)
template<bool is_index, typename... Bases>
static void	sol::usertype_detail::walk_all_bases (lua_State *L, bool &found, int &ret, string_view &accessor)
int	sol::usertype_detail::call_indexing_object (lua_State *L, object &f)
template<typename T , bool is_index, bool toplevel = false, bool has_indexing = false>
int	sol::usertype_detail::simple_core_indexing_call (lua_State *L)
template<typename T , bool has_indexing = false>
int	sol::usertype_detail::simple_real_index_call (lua_State *L)
template<typename T , bool has_indexing = false>
int	sol::usertype_detail::simple_real_new_index_call (lua_State *L)
template<typename T , bool has_indexing = false>
int	sol::usertype_detail::simple_index_call (lua_State *L)
template<typename T , bool has_indexing = false>
int	sol::usertype_detail::simple_new_index_call (lua_State *L)
int	sol::detail::fail_on_newindex (lua_State *L)
template<typename T , typename E >
void	sol::set_environment (const basic_environment< E > &env, const T &target)
template<typename E = reference, typename T >
basic_environment< E >	sol::get_environment (const T &target)
void	sol::register_main_thread (lua_State *L)
int	sol::default_at_panic (lua_State *L)
int	sol::default_traceback_error_handler (lua_State *L)
void	sol::set_default_state (lua_State *L, lua_CFunction panic_function=&default_at_panic, lua_CFunction traceback_function=c_call< decltype(&default_traceback_error_handler), &default_traceback_error_handler >, exception_handler_function exf=detail::default_exception_handler)
std::size_t	sol::total_memory_used (lua_State *L)
protected_function_result	sol::script_pass_on_error (lua_State *, protected_function_result result)
protected_function_result	sol::script_throw_on_error (lua_State *L, protected_function_result result)
protected_function_result	sol::script_default_on_error (lua_State *L, protected_function_result pfr)
template<typename Source >
auto	sol::as_returns (Source &&source)

Variables
const auto	sol::detail::direct_error = direct_error_tag{}
constexpr const auto	sol::meta::enabler = enable_t::_
constexpr struct sol::trivial_init_t	sol::trivial_init
constexpr nullopt_t	sol::nullopt {nullopt_t::init()}
const bool	sol::detail::default_safe_function_calls
const auto	sol::default_constructor = constructors<types<>>{}
const auto	sol::no_constructor = no_construction{}
const auto	sol::call_constructor = call_construction{}
const destructor_wrapper< void >	sol::default_destructor {}
const unchecked_t	sol::detail::unchecked = unchecked_t{}
const yield_tag_t	sol::detail::yield_tag = yield_tag_t{}
const lua_nil_t	sol::lua_nil {}
const nil_t	sol::nil {}
const metatable_t	sol::metatable_key = {}
const env_t	sol::env_key = {}
const no_metatable_t	sol::no_metatable = {}
struct sol::detail::verified_tag	sol::detail::verified
const auto	sol::base_classes = base_classes_tag()
const type_panic_t	sol::type_panic = {}
struct sol::detail::global_tag	sol::detail::global_
struct sol::detail::no_safety_tag	sol::detail::no_safety
const int	sol::usertype_detail::metatable_index = 2
const int	sol::usertype_detail::metatable_core_index = 3
const int	sol::usertype_detail::filler_index = 4
const int	sol::usertype_detail::magic_index = 5
const int	sol::usertype_detail::simple_metatable_index = 2
const int	sol::usertype_detail::index_function_index = 3
const int	sol::usertype_detail::newindex_function_index = 4
const lua_Integer	sol::usertype_detail::toplevel_magic = static_cast<lua_Integer>(0xCCC2CCC1)
struct sol::simple_tag	sol::simple
const new_table	sol::create = new_table{}

Macro Definition Documentation

COMPAT53_API

#define COMPAT53_API   static

COMPAT53_CONCAT

#define COMPAT53_CONCAT	(		a,
			b
	)		COMPAT53_CONCAT_HELPER(a, b)

COMPAT53_CONCAT_HELPER

#define COMPAT53_CONCAT_HELPER	(		a,
			b
	)		a##b

COMPAT53_INCLUDE_SOURCE

#define COMPAT53_INCLUDE_SOURCE   1

COMPAT53_PREFIX

#define COMPAT53_PREFIX   kp_compat53

KEPLER_PROJECT_COMPAT53_C_

#define KEPLER_PROJECT_COMPAT53_C_

KEPLER_PROJECT_COMPAT53_H_

#define KEPLER_PROJECT_COMPAT53_H_

LUA_KFUNCTION

#define LUA_KFUNCTION

(

_name

)

static int (_name)(lua_State *L, int status, lua_KContext ctx)

OPTIONAL_CONSTEXPR_INIT_LIST

#define OPTIONAL_CONSTEXPR_INIT_LIST

OPTIONAL_HAS_CONSTEXPR_INIT_LIST

#define OPTIONAL_HAS_CONSTEXPR_INIT_LIST   0

OPTIONAL_HAS_MOVE_ACCESSORS

#define OPTIONAL_HAS_MOVE_ACCESSORS   0

OPTIONAL_HAS_THIS_RVALUE_REFS

#define OPTIONAL_HAS_THIS_RVALUE_REFS   0

OPTIONAL_MUTABLE_CONSTEXPR

#define OPTIONAL_MUTABLE_CONSTEXPR   constexpr

SOL_DEFAULT_PASS_ON_ERROR

#define SOL_DEFAULT_PASS_ON_ERROR   0

SOL_DEPRECATED

#define SOL_DEPRECATED   [[deprecated]]

SOL_ENABLE_INTEROP

#define SOL_ENABLE_INTEROP   0

SOL_HPP

#define SOL_HPP

SOL_LUA_VERSION

#define SOL_LUA_VERSION   500

SOL_PRINT_ERRORS

#define SOL_PRINT_ERRORS   0

SOL_STACK_STRING_OPTIMIZATION_SIZE

#define SOL_STACK_STRING_OPTIMIZATION_SIZE   1024

TR2_OPTIONAL_ASSERTED_EXPRESSION

#define TR2_OPTIONAL_ASSERTED_EXPRESSION	(		CHECK,
			EXPR
	)		((CHECK) ? (EXPR) : ([] { assert(!#CHECK); }(), (EXPR)))

TR2_OPTIONAL_REQUIRES

#define TR2_OPTIONAL_REQUIRES

(

...

)

typename ::std::enable_if<__VA_ARGS__::value, bool>::type = false