// WARNING: Please don't edit this file. It was generated by Python/WinRT v1.0.0-beta.2

#include "pybase.h"
#include "py.Windows.System.RemoteSystems.h"

PyTypeObject* py::winrt_type<winrt::Windows::System::RemoteSystems::KnownRemoteSystemCapabilities>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystem>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemAddedEventArgs>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemApp>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemAppRegistration>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemAuthorizationKindFilter>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemConnectionInfo>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemConnectionRequest>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemDiscoveryTypeFilter>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemEnumerationCompletedEventArgs>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemKindFilter>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemKinds>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemRemovedEventArgs>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemSession>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemSessionAddedEventArgs>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemSessionController>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemSessionCreationResult>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemSessionDisconnectedEventArgs>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemSessionInfo>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemSessionInvitation>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemSessionInvitationListener>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemSessionInvitationReceivedEventArgs>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemSessionJoinRequest>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemSessionJoinRequestedEventArgs>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemSessionJoinResult>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemSessionMessageChannel>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemSessionOptions>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemSessionParticipant>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemSessionParticipantAddedEventArgs>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemSessionParticipantRemovedEventArgs>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemSessionParticipantWatcher>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemSessionRemovedEventArgs>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemSessionUpdatedEventArgs>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemSessionValueSetReceivedEventArgs>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemSessionWatcher>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemStatusTypeFilter>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemUpdatedEventArgs>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemWatcher>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemWatcherErrorOccurredEventArgs>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemWebAccountFilter>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::System::RemoteSystems::IRemoteSystemFilter>::python_type;

namespace py::cpp::Windows::System::RemoteSystems
{
    // ----- KnownRemoteSystemCapabilities class --------------------
    constexpr const char* const _type_name_KnownRemoteSystemCapabilities = "KnownRemoteSystemCapabilities";

    static PyObject* _new_KnownRemoteSystemCapabilities(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
    {
        py::set_invalid_activation_error(_type_name_KnownRemoteSystemCapabilities);
        return nullptr;
    }

    static PyObject* KnownRemoteSystemCapabilities_get_AppService(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(winrt::Windows::System::RemoteSystems::KnownRemoteSystemCapabilities::AppService());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* KnownRemoteSystemCapabilities_get_LaunchUri(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(winrt::Windows::System::RemoteSystems::KnownRemoteSystemCapabilities::LaunchUri());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* KnownRemoteSystemCapabilities_get_RemoteSession(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(winrt::Windows::System::RemoteSystems::KnownRemoteSystemCapabilities::RemoteSession());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* KnownRemoteSystemCapabilities_get_SpatialEntity(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(winrt::Windows::System::RemoteSystems::KnownRemoteSystemCapabilities::SpatialEntity());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_KnownRemoteSystemCapabilities[] = {
        { "get_app_service", reinterpret_cast<PyCFunction>(KnownRemoteSystemCapabilities_get_AppService), METH_NOARGS | METH_STATIC, nullptr },
        { "get_launch_uri", reinterpret_cast<PyCFunction>(KnownRemoteSystemCapabilities_get_LaunchUri), METH_NOARGS | METH_STATIC, nullptr },
        { "get_remote_session", reinterpret_cast<PyCFunction>(KnownRemoteSystemCapabilities_get_RemoteSession), METH_NOARGS | METH_STATIC, nullptr },
        { "get_spatial_entity", reinterpret_cast<PyCFunction>(KnownRemoteSystemCapabilities_get_SpatialEntity), METH_NOARGS | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_KnownRemoteSystemCapabilities[] = {
        { }
    };

    static PyType_Slot _type_slots_KnownRemoteSystemCapabilities[] = 
    {
        { Py_tp_new, _new_KnownRemoteSystemCapabilities },
        { Py_tp_methods, _methods_KnownRemoteSystemCapabilities },
        { Py_tp_getset, _getset_KnownRemoteSystemCapabilities },
        { },
    };

    static PyType_Spec _type_spec_KnownRemoteSystemCapabilities =
    {
        "_winsdk_Windows_System_RemoteSystems.KnownRemoteSystemCapabilities",
        0,
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_KnownRemoteSystemCapabilities
    };

    // ----- RemoteSystem class --------------------
    constexpr const char* const _type_name_RemoteSystem = "RemoteSystem";

    static PyObject* _new_RemoteSystem(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
    {
        py::set_invalid_activation_error(_type_name_RemoteSystem);
        return nullptr;
    }

    static void _dealloc_RemoteSystem(py::wrapper::Windows::System::RemoteSystems::RemoteSystem* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* RemoteSystem_CreateWatcher(PyObject* /*unused*/, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            try
            {
                return py::convert(winrt::Windows::System::RemoteSystems::RemoteSystem::CreateWatcher());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Foundation::Collections::IIterable<winrt::Windows::System::RemoteSystems::IRemoteSystemFilter>>(args, 0);

                return py::convert(winrt::Windows::System::RemoteSystems::RemoteSystem::CreateWatcher(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RemoteSystem_CreateWatcherForUser(PyObject* /*unused*/, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::System::User>(args, 0);

                return py::convert(winrt::Windows::System::RemoteSystems::RemoteSystem::CreateWatcherForUser(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 2)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::System::User>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Foundation::Collections::IIterable<winrt::Windows::System::RemoteSystems::IRemoteSystemFilter>>(args, 1);

                return py::convert(winrt::Windows::System::RemoteSystems::RemoteSystem::CreateWatcherForUser(param0, param1));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RemoteSystem_FindByHostNameAsync(PyObject* /*unused*/, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Networking::HostName>(args, 0);

                return py::convert(winrt::Windows::System::RemoteSystems::RemoteSystem::FindByHostNameAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RemoteSystem_GetCapabilitySupportedAsync(py::wrapper::Windows::System::RemoteSystems::RemoteSystem* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::hstring>(args, 0);

                return py::convert(self->obj.GetCapabilitySupportedAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RemoteSystem_IsAuthorizationKindEnabled(PyObject* /*unused*/, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::System::RemoteSystems::RemoteSystemAuthorizationKind>(args, 0);

                return py::convert(winrt::Windows::System::RemoteSystems::RemoteSystem::IsAuthorizationKindEnabled(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RemoteSystem_RequestAccessAsync(PyObject* /*unused*/, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            try
            {
                return py::convert(winrt::Windows::System::RemoteSystems::RemoteSystem::RequestAccessAsync());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RemoteSystem_get_DisplayName(py::wrapper::Windows::System::RemoteSystems::RemoteSystem* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.DisplayName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystem_get_Id(py::wrapper::Windows::System::RemoteSystems::RemoteSystem* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Id());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystem_get_IsAvailableByProximity(py::wrapper::Windows::System::RemoteSystems::RemoteSystem* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.IsAvailableByProximity());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystem_get_Kind(py::wrapper::Windows::System::RemoteSystems::RemoteSystem* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Kind());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystem_get_Status(py::wrapper::Windows::System::RemoteSystems::RemoteSystem* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Status());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystem_get_IsAvailableBySpatialProximity(py::wrapper::Windows::System::RemoteSystems::RemoteSystem* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.IsAvailableBySpatialProximity());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystem_get_ManufacturerDisplayName(py::wrapper::Windows::System::RemoteSystems::RemoteSystem* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ManufacturerDisplayName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystem_get_ModelDisplayName(py::wrapper::Windows::System::RemoteSystems::RemoteSystem* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ModelDisplayName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystem_get_Platform(py::wrapper::Windows::System::RemoteSystems::RemoteSystem* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Platform());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystem_get_Apps(py::wrapper::Windows::System::RemoteSystems::RemoteSystem* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Apps());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystem_get_User(py::wrapper::Windows::System::RemoteSystems::RemoteSystem* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.User());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_RemoteSystem(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::System::RemoteSystems::RemoteSystem>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RemoteSystem[] = {
        { "create_watcher", reinterpret_cast<PyCFunction>(RemoteSystem_CreateWatcher), METH_VARARGS | METH_STATIC, nullptr },
        { "create_watcher_for_user", reinterpret_cast<PyCFunction>(RemoteSystem_CreateWatcherForUser), METH_VARARGS | METH_STATIC, nullptr },
        { "find_by_host_name_async", reinterpret_cast<PyCFunction>(RemoteSystem_FindByHostNameAsync), METH_VARARGS | METH_STATIC, nullptr },
        { "get_capability_supported_async", reinterpret_cast<PyCFunction>(RemoteSystem_GetCapabilitySupportedAsync), METH_VARARGS, nullptr },
        { "is_authorization_kind_enabled", reinterpret_cast<PyCFunction>(RemoteSystem_IsAuthorizationKindEnabled), METH_VARARGS | METH_STATIC, nullptr },
        { "request_access_async", reinterpret_cast<PyCFunction>(RemoteSystem_RequestAccessAsync), METH_VARARGS | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_RemoteSystem), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RemoteSystem[] = {
        { "display_name", reinterpret_cast<getter>(RemoteSystem_get_DisplayName), nullptr, nullptr, nullptr },
        { "id", reinterpret_cast<getter>(RemoteSystem_get_Id), nullptr, nullptr, nullptr },
        { "is_available_by_proximity", reinterpret_cast<getter>(RemoteSystem_get_IsAvailableByProximity), nullptr, nullptr, nullptr },
        { "kind", reinterpret_cast<getter>(RemoteSystem_get_Kind), nullptr, nullptr, nullptr },
        { "status", reinterpret_cast<getter>(RemoteSystem_get_Status), nullptr, nullptr, nullptr },
        { "is_available_by_spatial_proximity", reinterpret_cast<getter>(RemoteSystem_get_IsAvailableBySpatialProximity), nullptr, nullptr, nullptr },
        { "manufacturer_display_name", reinterpret_cast<getter>(RemoteSystem_get_ManufacturerDisplayName), nullptr, nullptr, nullptr },
        { "model_display_name", reinterpret_cast<getter>(RemoteSystem_get_ModelDisplayName), nullptr, nullptr, nullptr },
        { "platform", reinterpret_cast<getter>(RemoteSystem_get_Platform), nullptr, nullptr, nullptr },
        { "apps", reinterpret_cast<getter>(RemoteSystem_get_Apps), nullptr, nullptr, nullptr },
        { "user", reinterpret_cast<getter>(RemoteSystem_get_User), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_RemoteSystem[] = 
    {
        { Py_tp_new, _new_RemoteSystem },
        { Py_tp_dealloc, _dealloc_RemoteSystem },
        { Py_tp_methods, _methods_RemoteSystem },
        { Py_tp_getset, _getset_RemoteSystem },
        { },
    };

    static PyType_Spec _type_spec_RemoteSystem =
    {
        "_winsdk_Windows_System_RemoteSystems.RemoteSystem",
        sizeof(py::wrapper::Windows::System::RemoteSystems::RemoteSystem),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RemoteSystem
    };

    // ----- RemoteSystemAddedEventArgs class --------------------
    constexpr const char* const _type_name_RemoteSystemAddedEventArgs = "RemoteSystemAddedEventArgs";

    static PyObject* _new_RemoteSystemAddedEventArgs(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
    {
        py::set_invalid_activation_error(_type_name_RemoteSystemAddedEventArgs);
        return nullptr;
    }

    static void _dealloc_RemoteSystemAddedEventArgs(py::wrapper::Windows::System::RemoteSystems::RemoteSystemAddedEventArgs* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* RemoteSystemAddedEventArgs_get_RemoteSystem(py::wrapper::Windows::System::RemoteSystems::RemoteSystemAddedEventArgs* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.RemoteSystem());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_RemoteSystemAddedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::System::RemoteSystems::RemoteSystemAddedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RemoteSystemAddedEventArgs[] = {
        { "_from", reinterpret_cast<PyCFunction>(_from_RemoteSystemAddedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RemoteSystemAddedEventArgs[] = {
        { "remote_system", reinterpret_cast<getter>(RemoteSystemAddedEventArgs_get_RemoteSystem), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_RemoteSystemAddedEventArgs[] = 
    {
        { Py_tp_new, _new_RemoteSystemAddedEventArgs },
        { Py_tp_dealloc, _dealloc_RemoteSystemAddedEventArgs },
        { Py_tp_methods, _methods_RemoteSystemAddedEventArgs },
        { Py_tp_getset, _getset_RemoteSystemAddedEventArgs },
        { },
    };

    static PyType_Spec _type_spec_RemoteSystemAddedEventArgs =
    {
        "_winsdk_Windows_System_RemoteSystems.RemoteSystemAddedEventArgs",
        sizeof(py::wrapper::Windows::System::RemoteSystems::RemoteSystemAddedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RemoteSystemAddedEventArgs
    };

    // ----- RemoteSystemApp class --------------------
    constexpr const char* const _type_name_RemoteSystemApp = "RemoteSystemApp";

    static PyObject* _new_RemoteSystemApp(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
    {
        py::set_invalid_activation_error(_type_name_RemoteSystemApp);
        return nullptr;
    }

    static void _dealloc_RemoteSystemApp(py::wrapper::Windows::System::RemoteSystems::RemoteSystemApp* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* RemoteSystemApp_get_Attributes(py::wrapper::Windows::System::RemoteSystems::RemoteSystemApp* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Attributes());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystemApp_get_DisplayName(py::wrapper::Windows::System::RemoteSystems::RemoteSystemApp* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.DisplayName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystemApp_get_Id(py::wrapper::Windows::System::RemoteSystems::RemoteSystemApp* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Id());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystemApp_get_IsAvailableByProximity(py::wrapper::Windows::System::RemoteSystems::RemoteSystemApp* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.IsAvailableByProximity());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystemApp_get_IsAvailableBySpatialProximity(py::wrapper::Windows::System::RemoteSystems::RemoteSystemApp* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.IsAvailableBySpatialProximity());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystemApp_get_ConnectionToken(py::wrapper::Windows::System::RemoteSystems::RemoteSystemApp* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ConnectionToken());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystemApp_get_User(py::wrapper::Windows::System::RemoteSystems::RemoteSystemApp* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.User());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_RemoteSystemApp(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::System::RemoteSystems::RemoteSystemApp>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RemoteSystemApp[] = {
        { "_from", reinterpret_cast<PyCFunction>(_from_RemoteSystemApp), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RemoteSystemApp[] = {
        { "attributes", reinterpret_cast<getter>(RemoteSystemApp_get_Attributes), nullptr, nullptr, nullptr },
        { "display_name", reinterpret_cast<getter>(RemoteSystemApp_get_DisplayName), nullptr, nullptr, nullptr },
        { "id", reinterpret_cast<getter>(RemoteSystemApp_get_Id), nullptr, nullptr, nullptr },
        { "is_available_by_proximity", reinterpret_cast<getter>(RemoteSystemApp_get_IsAvailableByProximity), nullptr, nullptr, nullptr },
        { "is_available_by_spatial_proximity", reinterpret_cast<getter>(RemoteSystemApp_get_IsAvailableBySpatialProximity), nullptr, nullptr, nullptr },
        { "connection_token", reinterpret_cast<getter>(RemoteSystemApp_get_ConnectionToken), nullptr, nullptr, nullptr },
        { "user", reinterpret_cast<getter>(RemoteSystemApp_get_User), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_RemoteSystemApp[] = 
    {
        { Py_tp_new, _new_RemoteSystemApp },
        { Py_tp_dealloc, _dealloc_RemoteSystemApp },
        { Py_tp_methods, _methods_RemoteSystemApp },
        { Py_tp_getset, _getset_RemoteSystemApp },
        { },
    };

    static PyType_Spec _type_spec_RemoteSystemApp =
    {
        "_winsdk_Windows_System_RemoteSystems.RemoteSystemApp",
        sizeof(py::wrapper::Windows::System::RemoteSystems::RemoteSystemApp),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RemoteSystemApp
    };

    // ----- RemoteSystemAppRegistration class --------------------
    constexpr const char* const _type_name_RemoteSystemAppRegistration = "RemoteSystemAppRegistration";

    static PyObject* _new_RemoteSystemAppRegistration(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
    {
        py::set_invalid_activation_error(_type_name_RemoteSystemAppRegistration);
        return nullptr;
    }

    static void _dealloc_RemoteSystemAppRegistration(py::wrapper::Windows::System::RemoteSystems::RemoteSystemAppRegistration* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* RemoteSystemAppRegistration_GetDefault(PyObject* /*unused*/, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            try
            {
                return py::convert(winrt::Windows::System::RemoteSystems::RemoteSystemAppRegistration::GetDefault());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RemoteSystemAppRegistration_GetForUser(PyObject* /*unused*/, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::System::User>(args, 0);

                return py::convert(winrt::Windows::System::RemoteSystems::RemoteSystemAppRegistration::GetForUser(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RemoteSystemAppRegistration_SaveAsync(py::wrapper::Windows::System::RemoteSystems::RemoteSystemAppRegistration* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            try
            {
                return py::convert(self->obj.SaveAsync());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RemoteSystemAppRegistration_get_Attributes(py::wrapper::Windows::System::RemoteSystems::RemoteSystemAppRegistration* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Attributes());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystemAppRegistration_get_User(py::wrapper::Windows::System::RemoteSystems::RemoteSystemAppRegistration* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.User());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_RemoteSystemAppRegistration(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::System::RemoteSystems::RemoteSystemAppRegistration>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RemoteSystemAppRegistration[] = {
        { "get_default", reinterpret_cast<PyCFunction>(RemoteSystemAppRegistration_GetDefault), METH_VARARGS | METH_STATIC, nullptr },
        { "get_for_user", reinterpret_cast<PyCFunction>(RemoteSystemAppRegistration_GetForUser), METH_VARARGS | METH_STATIC, nullptr },
        { "save_async", reinterpret_cast<PyCFunction>(RemoteSystemAppRegistration_SaveAsync), METH_VARARGS, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_RemoteSystemAppRegistration), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RemoteSystemAppRegistration[] = {
        { "attributes", reinterpret_cast<getter>(RemoteSystemAppRegistration_get_Attributes), nullptr, nullptr, nullptr },
        { "user", reinterpret_cast<getter>(RemoteSystemAppRegistration_get_User), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_RemoteSystemAppRegistration[] = 
    {
        { Py_tp_new, _new_RemoteSystemAppRegistration },
        { Py_tp_dealloc, _dealloc_RemoteSystemAppRegistration },
        { Py_tp_methods, _methods_RemoteSystemAppRegistration },
        { Py_tp_getset, _getset_RemoteSystemAppRegistration },
        { },
    };

    static PyType_Spec _type_spec_RemoteSystemAppRegistration =
    {
        "_winsdk_Windows_System_RemoteSystems.RemoteSystemAppRegistration",
        sizeof(py::wrapper::Windows::System::RemoteSystems::RemoteSystemAppRegistration),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RemoteSystemAppRegistration
    };

    // ----- RemoteSystemAuthorizationKindFilter class --------------------
    constexpr const char* const _type_name_RemoteSystemAuthorizationKindFilter = "RemoteSystemAuthorizationKindFilter";

    static PyObject* _new_RemoteSystemAuthorizationKindFilter(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
    {
        if (kwds != nullptr)
        {
            py::set_invalid_kwd_args_error();
            return nullptr;
        }

        Py_ssize_t arg_count = PyTuple_Size(args);
        if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::System::RemoteSystems::RemoteSystemAuthorizationKind>(args, 0);

                winrt::Windows::System::RemoteSystems::RemoteSystemAuthorizationKindFilter instance{ param0 };
                return py::wrap(instance, type);
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static void _dealloc_RemoteSystemAuthorizationKindFilter(py::wrapper::Windows::System::RemoteSystems::RemoteSystemAuthorizationKindFilter* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* RemoteSystemAuthorizationKindFilter_get_RemoteSystemAuthorizationKind(py::wrapper::Windows::System::RemoteSystems::RemoteSystemAuthorizationKindFilter* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.RemoteSystemAuthorizationKind());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_RemoteSystemAuthorizationKindFilter(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::System::RemoteSystems::RemoteSystemAuthorizationKindFilter>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RemoteSystemAuthorizationKindFilter[] = {
        { "_from", reinterpret_cast<PyCFunction>(_from_RemoteSystemAuthorizationKindFilter), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RemoteSystemAuthorizationKindFilter[] = {
        { "remote_system_authorization_kind", reinterpret_cast<getter>(RemoteSystemAuthorizationKindFilter_get_RemoteSystemAuthorizationKind), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_RemoteSystemAuthorizationKindFilter[] = 
    {
        { Py_tp_new, _new_RemoteSystemAuthorizationKindFilter },
        { Py_tp_dealloc, _dealloc_RemoteSystemAuthorizationKindFilter },
        { Py_tp_methods, _methods_RemoteSystemAuthorizationKindFilter },
        { Py_tp_getset, _getset_RemoteSystemAuthorizationKindFilter },
        { },
    };

    static PyType_Spec _type_spec_RemoteSystemAuthorizationKindFilter =
    {
        "_winsdk_Windows_System_RemoteSystems.RemoteSystemAuthorizationKindFilter",
        sizeof(py::wrapper::Windows::System::RemoteSystems::RemoteSystemAuthorizationKindFilter),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RemoteSystemAuthorizationKindFilter
    };

    // ----- RemoteSystemConnectionInfo class --------------------
    constexpr const char* const _type_name_RemoteSystemConnectionInfo = "RemoteSystemConnectionInfo";

    static PyObject* _new_RemoteSystemConnectionInfo(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
    {
        py::set_invalid_activation_error(_type_name_RemoteSystemConnectionInfo);
        return nullptr;
    }

    static void _dealloc_RemoteSystemConnectionInfo(py::wrapper::Windows::System::RemoteSystems::RemoteSystemConnectionInfo* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* RemoteSystemConnectionInfo_TryCreateFromAppServiceConnection(PyObject* /*unused*/, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::ApplicationModel::AppService::AppServiceConnection>(args, 0);

                return py::convert(winrt::Windows::System::RemoteSystems::RemoteSystemConnectionInfo::TryCreateFromAppServiceConnection(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RemoteSystemConnectionInfo_get_IsProximal(py::wrapper::Windows::System::RemoteSystems::RemoteSystemConnectionInfo* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.IsProximal());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_RemoteSystemConnectionInfo(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::System::RemoteSystems::RemoteSystemConnectionInfo>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RemoteSystemConnectionInfo[] = {
        { "try_create_from_app_service_connection", reinterpret_cast<PyCFunction>(RemoteSystemConnectionInfo_TryCreateFromAppServiceConnection), METH_VARARGS | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_RemoteSystemConnectionInfo), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RemoteSystemConnectionInfo[] = {
        { "is_proximal", reinterpret_cast<getter>(RemoteSystemConnectionInfo_get_IsProximal), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_RemoteSystemConnectionInfo[] = 
    {
        { Py_tp_new, _new_RemoteSystemConnectionInfo },
        { Py_tp_dealloc, _dealloc_RemoteSystemConnectionInfo },
        { Py_tp_methods, _methods_RemoteSystemConnectionInfo },
        { Py_tp_getset, _getset_RemoteSystemConnectionInfo },
        { },
    };

    static PyType_Spec _type_spec_RemoteSystemConnectionInfo =
    {
        "_winsdk_Windows_System_RemoteSystems.RemoteSystemConnectionInfo",
        sizeof(py::wrapper::Windows::System::RemoteSystems::RemoteSystemConnectionInfo),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RemoteSystemConnectionInfo
    };

    // ----- RemoteSystemConnectionRequest class --------------------
    constexpr const char* const _type_name_RemoteSystemConnectionRequest = "RemoteSystemConnectionRequest";

    static PyObject* _new_RemoteSystemConnectionRequest(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
    {
        if (kwds != nullptr)
        {
            py::set_invalid_kwd_args_error();
            return nullptr;
        }

        Py_ssize_t arg_count = PyTuple_Size(args);
        if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::System::RemoteSystems::RemoteSystem>(args, 0);

                winrt::Windows::System::RemoteSystems::RemoteSystemConnectionRequest instance{ param0 };
                return py::wrap(instance, type);
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static void _dealloc_RemoteSystemConnectionRequest(py::wrapper::Windows::System::RemoteSystems::RemoteSystemConnectionRequest* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* RemoteSystemConnectionRequest_CreateForApp(PyObject* /*unused*/, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::System::RemoteSystems::RemoteSystemApp>(args, 0);

                return py::convert(winrt::Windows::System::RemoteSystems::RemoteSystemConnectionRequest::CreateForApp(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RemoteSystemConnectionRequest_CreateFromConnectionToken(PyObject* /*unused*/, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::hstring>(args, 0);

                return py::convert(winrt::Windows::System::RemoteSystems::RemoteSystemConnectionRequest::CreateFromConnectionToken(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RemoteSystemConnectionRequest_CreateFromConnectionTokenForUser(PyObject* /*unused*/, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::System::User>(args, 0);
                auto param1 = py::convert_to<winrt::hstring>(args, 1);

                return py::convert(winrt::Windows::System::RemoteSystems::RemoteSystemConnectionRequest::CreateFromConnectionTokenForUser(param0, param1));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RemoteSystemConnectionRequest_get_RemoteSystem(py::wrapper::Windows::System::RemoteSystems::RemoteSystemConnectionRequest* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.RemoteSystem());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystemConnectionRequest_get_RemoteSystemApp(py::wrapper::Windows::System::RemoteSystems::RemoteSystemConnectionRequest* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.RemoteSystemApp());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystemConnectionRequest_get_ConnectionToken(py::wrapper::Windows::System::RemoteSystems::RemoteSystemConnectionRequest* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ConnectionToken());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_RemoteSystemConnectionRequest(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::System::RemoteSystems::RemoteSystemConnectionRequest>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RemoteSystemConnectionRequest[] = {
        { "create_for_app", reinterpret_cast<PyCFunction>(RemoteSystemConnectionRequest_CreateForApp), METH_VARARGS | METH_STATIC, nullptr },
        { "create_from_connection_token", reinterpret_cast<PyCFunction>(RemoteSystemConnectionRequest_CreateFromConnectionToken), METH_VARARGS | METH_STATIC, nullptr },
        { "create_from_connection_token_for_user", reinterpret_cast<PyCFunction>(RemoteSystemConnectionRequest_CreateFromConnectionTokenForUser), METH_VARARGS | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_RemoteSystemConnectionRequest), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RemoteSystemConnectionRequest[] = {
        { "remote_system", reinterpret_cast<getter>(RemoteSystemConnectionRequest_get_RemoteSystem), nullptr, nullptr, nullptr },
        { "remote_system_app", reinterpret_cast<getter>(RemoteSystemConnectionRequest_get_RemoteSystemApp), nullptr, nullptr, nullptr },
        { "connection_token", reinterpret_cast<getter>(RemoteSystemConnectionRequest_get_ConnectionToken), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_RemoteSystemConnectionRequest[] = 
    {
        { Py_tp_new, _new_RemoteSystemConnectionRequest },
        { Py_tp_dealloc, _dealloc_RemoteSystemConnectionRequest },
        { Py_tp_methods, _methods_RemoteSystemConnectionRequest },
        { Py_tp_getset, _getset_RemoteSystemConnectionRequest },
        { },
    };

    static PyType_Spec _type_spec_RemoteSystemConnectionRequest =
    {
        "_winsdk_Windows_System_RemoteSystems.RemoteSystemConnectionRequest",
        sizeof(py::wrapper::Windows::System::RemoteSystems::RemoteSystemConnectionRequest),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RemoteSystemConnectionRequest
    };

    // ----- RemoteSystemDiscoveryTypeFilter class --------------------
    constexpr const char* const _type_name_RemoteSystemDiscoveryTypeFilter = "RemoteSystemDiscoveryTypeFilter";

    static PyObject* _new_RemoteSystemDiscoveryTypeFilter(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
    {
        if (kwds != nullptr)
        {
            py::set_invalid_kwd_args_error();
            return nullptr;
        }

        Py_ssize_t arg_count = PyTuple_Size(args);
        if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::System::RemoteSystems::RemoteSystemDiscoveryType>(args, 0);

                winrt::Windows::System::RemoteSystems::RemoteSystemDiscoveryTypeFilter instance{ param0 };
                return py::wrap(instance, type);
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static void _dealloc_RemoteSystemDiscoveryTypeFilter(py::wrapper::Windows::System::RemoteSystems::RemoteSystemDiscoveryTypeFilter* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* RemoteSystemDiscoveryTypeFilter_get_RemoteSystemDiscoveryType(py::wrapper::Windows::System::RemoteSystems::RemoteSystemDiscoveryTypeFilter* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.RemoteSystemDiscoveryType());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_RemoteSystemDiscoveryTypeFilter(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::System::RemoteSystems::RemoteSystemDiscoveryTypeFilter>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RemoteSystemDiscoveryTypeFilter[] = {
        { "_from", reinterpret_cast<PyCFunction>(_from_RemoteSystemDiscoveryTypeFilter), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RemoteSystemDiscoveryTypeFilter[] = {
        { "remote_system_discovery_type", reinterpret_cast<getter>(RemoteSystemDiscoveryTypeFilter_get_RemoteSystemDiscoveryType), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_RemoteSystemDiscoveryTypeFilter[] = 
    {
        { Py_tp_new, _new_RemoteSystemDiscoveryTypeFilter },
        { Py_tp_dealloc, _dealloc_RemoteSystemDiscoveryTypeFilter },
        { Py_tp_methods, _methods_RemoteSystemDiscoveryTypeFilter },
        { Py_tp_getset, _getset_RemoteSystemDiscoveryTypeFilter },
        { },
    };

    static PyType_Spec _type_spec_RemoteSystemDiscoveryTypeFilter =
    {
        "_winsdk_Windows_System_RemoteSystems.RemoteSystemDiscoveryTypeFilter",
        sizeof(py::wrapper::Windows::System::RemoteSystems::RemoteSystemDiscoveryTypeFilter),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RemoteSystemDiscoveryTypeFilter
    };

    // ----- RemoteSystemEnumerationCompletedEventArgs class --------------------
    constexpr const char* const _type_name_RemoteSystemEnumerationCompletedEventArgs = "RemoteSystemEnumerationCompletedEventArgs";

    static PyObject* _new_RemoteSystemEnumerationCompletedEventArgs(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
    {
        py::set_invalid_activation_error(_type_name_RemoteSystemEnumerationCompletedEventArgs);
        return nullptr;
    }

    static void _dealloc_RemoteSystemEnumerationCompletedEventArgs(py::wrapper::Windows::System::RemoteSystems::RemoteSystemEnumerationCompletedEventArgs* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* _from_RemoteSystemEnumerationCompletedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::System::RemoteSystems::RemoteSystemEnumerationCompletedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RemoteSystemEnumerationCompletedEventArgs[] = {
        { "_from", reinterpret_cast<PyCFunction>(_from_RemoteSystemEnumerationCompletedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RemoteSystemEnumerationCompletedEventArgs[] = {
        { }
    };

    static PyType_Slot _type_slots_RemoteSystemEnumerationCompletedEventArgs[] = 
    {
        { Py_tp_new, _new_RemoteSystemEnumerationCompletedEventArgs },
        { Py_tp_dealloc, _dealloc_RemoteSystemEnumerationCompletedEventArgs },
        { Py_tp_methods, _methods_RemoteSystemEnumerationCompletedEventArgs },
        { Py_tp_getset, _getset_RemoteSystemEnumerationCompletedEventArgs },
        { },
    };

    static PyType_Spec _type_spec_RemoteSystemEnumerationCompletedEventArgs =
    {
        "_winsdk_Windows_System_RemoteSystems.RemoteSystemEnumerationCompletedEventArgs",
        sizeof(py::wrapper::Windows::System::RemoteSystems::RemoteSystemEnumerationCompletedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RemoteSystemEnumerationCompletedEventArgs
    };

    // ----- RemoteSystemKindFilter class --------------------
    constexpr const char* const _type_name_RemoteSystemKindFilter = "RemoteSystemKindFilter";

    static PyObject* _new_RemoteSystemKindFilter(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
    {
        if (kwds != nullptr)
        {
            py::set_invalid_kwd_args_error();
            return nullptr;
        }

        Py_ssize_t arg_count = PyTuple_Size(args);
        if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Foundation::Collections::IIterable<winrt::hstring>>(args, 0);

                winrt::Windows::System::RemoteSystems::RemoteSystemKindFilter instance{ param0 };
                return py::wrap(instance, type);
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static void _dealloc_RemoteSystemKindFilter(py::wrapper::Windows::System::RemoteSystems::RemoteSystemKindFilter* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* RemoteSystemKindFilter_get_RemoteSystemKinds(py::wrapper::Windows::System::RemoteSystems::RemoteSystemKindFilter* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.RemoteSystemKinds());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_RemoteSystemKindFilter(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::System::RemoteSystems::RemoteSystemKindFilter>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RemoteSystemKindFilter[] = {
        { "_from", reinterpret_cast<PyCFunction>(_from_RemoteSystemKindFilter), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RemoteSystemKindFilter[] = {
        { "remote_system_kinds", reinterpret_cast<getter>(RemoteSystemKindFilter_get_RemoteSystemKinds), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_RemoteSystemKindFilter[] = 
    {
        { Py_tp_new, _new_RemoteSystemKindFilter },
        { Py_tp_dealloc, _dealloc_RemoteSystemKindFilter },
        { Py_tp_methods, _methods_RemoteSystemKindFilter },
        { Py_tp_getset, _getset_RemoteSystemKindFilter },
        { },
    };

    static PyType_Spec _type_spec_RemoteSystemKindFilter =
    {
        "_winsdk_Windows_System_RemoteSystems.RemoteSystemKindFilter",
        sizeof(py::wrapper::Windows::System::RemoteSystems::RemoteSystemKindFilter),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RemoteSystemKindFilter
    };

    // ----- RemoteSystemKinds class --------------------
    constexpr const char* const _type_name_RemoteSystemKinds = "RemoteSystemKinds";

    static PyObject* _new_RemoteSystemKinds(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
    {
        py::set_invalid_activation_error(_type_name_RemoteSystemKinds);
        return nullptr;
    }

    static PyObject* RemoteSystemKinds_get_Desktop(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(winrt::Windows::System::RemoteSystems::RemoteSystemKinds::Desktop());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystemKinds_get_Holographic(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(winrt::Windows::System::RemoteSystems::RemoteSystemKinds::Holographic());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystemKinds_get_Hub(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(winrt::Windows::System::RemoteSystems::RemoteSystemKinds::Hub());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystemKinds_get_Phone(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(winrt::Windows::System::RemoteSystems::RemoteSystemKinds::Phone());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystemKinds_get_Xbox(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(winrt::Windows::System::RemoteSystems::RemoteSystemKinds::Xbox());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystemKinds_get_Iot(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(winrt::Windows::System::RemoteSystems::RemoteSystemKinds::Iot());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystemKinds_get_Laptop(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(winrt::Windows::System::RemoteSystems::RemoteSystemKinds::Laptop());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystemKinds_get_Tablet(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(winrt::Windows::System::RemoteSystems::RemoteSystemKinds::Tablet());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RemoteSystemKinds[] = {
        { "get_desktop", reinterpret_cast<PyCFunction>(RemoteSystemKinds_get_Desktop), METH_NOARGS | METH_STATIC, nullptr },
        { "get_holographic", reinterpret_cast<PyCFunction>(RemoteSystemKinds_get_Holographic), METH_NOARGS | METH_STATIC, nullptr },
        { "get_hub", reinterpret_cast<PyCFunction>(RemoteSystemKinds_get_Hub), METH_NOARGS | METH_STATIC, nullptr },
        { "get_phone", reinterpret_cast<PyCFunction>(RemoteSystemKinds_get_Phone), METH_NOARGS | METH_STATIC, nullptr },
        { "get_xbox", reinterpret_cast<PyCFunction>(RemoteSystemKinds_get_Xbox), METH_NOARGS | METH_STATIC, nullptr },
        { "get_iot", reinterpret_cast<PyCFunction>(RemoteSystemKinds_get_Iot), METH_NOARGS | METH_STATIC, nullptr },
        { "get_laptop", reinterpret_cast<PyCFunction>(RemoteSystemKinds_get_Laptop), METH_NOARGS | METH_STATIC, nullptr },
        { "get_tablet", reinterpret_cast<PyCFunction>(RemoteSystemKinds_get_Tablet), METH_NOARGS | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RemoteSystemKinds[] = {
        { }
    };

    static PyType_Slot _type_slots_RemoteSystemKinds[] = 
    {
        { Py_tp_new, _new_RemoteSystemKinds },
        { Py_tp_methods, _methods_RemoteSystemKinds },
        { Py_tp_getset, _getset_RemoteSystemKinds },
        { },
    };

    static PyType_Spec _type_spec_RemoteSystemKinds =
    {
        "_winsdk_Windows_System_RemoteSystems.RemoteSystemKinds",
        0,
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RemoteSystemKinds
    };

    // ----- RemoteSystemRemovedEventArgs class --------------------
    constexpr const char* const _type_name_RemoteSystemRemovedEventArgs = "RemoteSystemRemovedEventArgs";

    static PyObject* _new_RemoteSystemRemovedEventArgs(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
    {
        py::set_invalid_activation_error(_type_name_RemoteSystemRemovedEventArgs);
        return nullptr;
    }

    static void _dealloc_RemoteSystemRemovedEventArgs(py::wrapper::Windows::System::RemoteSystems::RemoteSystemRemovedEventArgs* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* RemoteSystemRemovedEventArgs_get_RemoteSystemId(py::wrapper::Windows::System::RemoteSystems::RemoteSystemRemovedEventArgs* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.RemoteSystemId());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_RemoteSystemRemovedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::System::RemoteSystems::RemoteSystemRemovedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RemoteSystemRemovedEventArgs[] = {
        { "_from", reinterpret_cast<PyCFunction>(_from_RemoteSystemRemovedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RemoteSystemRemovedEventArgs[] = {
        { "remote_system_id", reinterpret_cast<getter>(RemoteSystemRemovedEventArgs_get_RemoteSystemId), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_RemoteSystemRemovedEventArgs[] = 
    {
        { Py_tp_new, _new_RemoteSystemRemovedEventArgs },
        { Py_tp_dealloc, _dealloc_RemoteSystemRemovedEventArgs },
        { Py_tp_methods, _methods_RemoteSystemRemovedEventArgs },
        { Py_tp_getset, _getset_RemoteSystemRemovedEventArgs },
        { },
    };

    static PyType_Spec _type_spec_RemoteSystemRemovedEventArgs =
    {
        "_winsdk_Windows_System_RemoteSystems.RemoteSystemRemovedEventArgs",
        sizeof(py::wrapper::Windows::System::RemoteSystems::RemoteSystemRemovedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RemoteSystemRemovedEventArgs
    };

    // ----- RemoteSystemSession class --------------------
    constexpr const char* const _type_name_RemoteSystemSession = "RemoteSystemSession";

    static PyObject* _new_RemoteSystemSession(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
    {
        py::set_invalid_activation_error(_type_name_RemoteSystemSession);
        return nullptr;
    }

    static void _dealloc_RemoteSystemSession(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSession* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* RemoteSystemSession_Close(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSession* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            try
            {
                self->obj.Close();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RemoteSystemSession_CreateParticipantWatcher(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSession* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            try
            {
                return py::convert(self->obj.CreateParticipantWatcher());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RemoteSystemSession_CreateWatcher(PyObject* /*unused*/, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            try
            {
                return py::convert(winrt::Windows::System::RemoteSystems::RemoteSystemSession::CreateWatcher());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RemoteSystemSession_SendInvitationAsync(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSession* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::System::RemoteSystems::RemoteSystem>(args, 0);

                return py::convert(self->obj.SendInvitationAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RemoteSystemSession_get_ControllerDisplayName(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSession* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ControllerDisplayName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystemSession_get_DisplayName(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSession* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.DisplayName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystemSession_get_Id(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSession* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Id());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystemSession_add_Disconnected(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSession* self, PyObject* arg) noexcept
    {
        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Windows::System::RemoteSystems::RemoteSystemSession, winrt::Windows::System::RemoteSystems::RemoteSystemSessionDisconnectedEventArgs>>(arg);

            return py::convert(self->obj.Disconnected(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystemSession_remove_Disconnected(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSession* self, PyObject* arg) noexcept
    {
        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.Disconnected(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_RemoteSystemSession(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::System::RemoteSystems::RemoteSystemSession>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _enter_RemoteSystemSession(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSession* self) noexcept
    {
        Py_INCREF(self);
        return reinterpret_cast<PyObject*>(self);
    }

    static PyObject* _exit_RemoteSystemSession(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSession* self) noexcept
    {
        try
        {
            self->obj.Close();
            Py_RETURN_FALSE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RemoteSystemSession[] = {
        { "close", reinterpret_cast<PyCFunction>(RemoteSystemSession_Close), METH_VARARGS, nullptr },
        { "create_participant_watcher", reinterpret_cast<PyCFunction>(RemoteSystemSession_CreateParticipantWatcher), METH_VARARGS, nullptr },
        { "create_watcher", reinterpret_cast<PyCFunction>(RemoteSystemSession_CreateWatcher), METH_VARARGS | METH_STATIC, nullptr },
        { "send_invitation_async", reinterpret_cast<PyCFunction>(RemoteSystemSession_SendInvitationAsync), METH_VARARGS, nullptr },
        { "add_disconnected", reinterpret_cast<PyCFunction>(RemoteSystemSession_add_Disconnected), METH_O, nullptr },
        { "remove_disconnected", reinterpret_cast<PyCFunction>(RemoteSystemSession_remove_Disconnected), METH_O, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_RemoteSystemSession), METH_O | METH_STATIC, nullptr },
        { "__enter__", reinterpret_cast<PyCFunction>(_enter_RemoteSystemSession), METH_NOARGS, nullptr },
        { "__exit__",  reinterpret_cast<PyCFunction>(_exit_RemoteSystemSession), METH_VARARGS, nullptr },
        { }
    };

    static PyGetSetDef _getset_RemoteSystemSession[] = {
        { "controller_display_name", reinterpret_cast<getter>(RemoteSystemSession_get_ControllerDisplayName), nullptr, nullptr, nullptr },
        { "display_name", reinterpret_cast<getter>(RemoteSystemSession_get_DisplayName), nullptr, nullptr, nullptr },
        { "id", reinterpret_cast<getter>(RemoteSystemSession_get_Id), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_RemoteSystemSession[] = 
    {
        { Py_tp_new, _new_RemoteSystemSession },
        { Py_tp_dealloc, _dealloc_RemoteSystemSession },
        { Py_tp_methods, _methods_RemoteSystemSession },
        { Py_tp_getset, _getset_RemoteSystemSession },
        { },
    };

    static PyType_Spec _type_spec_RemoteSystemSession =
    {
        "_winsdk_Windows_System_RemoteSystems.RemoteSystemSession",
        sizeof(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSession),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RemoteSystemSession
    };

    // ----- RemoteSystemSessionAddedEventArgs class --------------------
    constexpr const char* const _type_name_RemoteSystemSessionAddedEventArgs = "RemoteSystemSessionAddedEventArgs";

    static PyObject* _new_RemoteSystemSessionAddedEventArgs(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
    {
        py::set_invalid_activation_error(_type_name_RemoteSystemSessionAddedEventArgs);
        return nullptr;
    }

    static void _dealloc_RemoteSystemSessionAddedEventArgs(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionAddedEventArgs* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* RemoteSystemSessionAddedEventArgs_get_SessionInfo(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionAddedEventArgs* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.SessionInfo());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_RemoteSystemSessionAddedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::System::RemoteSystems::RemoteSystemSessionAddedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RemoteSystemSessionAddedEventArgs[] = {
        { "_from", reinterpret_cast<PyCFunction>(_from_RemoteSystemSessionAddedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RemoteSystemSessionAddedEventArgs[] = {
        { "session_info", reinterpret_cast<getter>(RemoteSystemSessionAddedEventArgs_get_SessionInfo), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_RemoteSystemSessionAddedEventArgs[] = 
    {
        { Py_tp_new, _new_RemoteSystemSessionAddedEventArgs },
        { Py_tp_dealloc, _dealloc_RemoteSystemSessionAddedEventArgs },
        { Py_tp_methods, _methods_RemoteSystemSessionAddedEventArgs },
        { Py_tp_getset, _getset_RemoteSystemSessionAddedEventArgs },
        { },
    };

    static PyType_Spec _type_spec_RemoteSystemSessionAddedEventArgs =
    {
        "_winsdk_Windows_System_RemoteSystems.RemoteSystemSessionAddedEventArgs",
        sizeof(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionAddedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RemoteSystemSessionAddedEventArgs
    };

    // ----- RemoteSystemSessionController class --------------------
    constexpr const char* const _type_name_RemoteSystemSessionController = "RemoteSystemSessionController";

    static PyObject* _new_RemoteSystemSessionController(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
    {
        if (kwds != nullptr)
        {
            py::set_invalid_kwd_args_error();
            return nullptr;
        }

        Py_ssize_t arg_count = PyTuple_Size(args);
        if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::hstring>(args, 0);

                winrt::Windows::System::RemoteSystems::RemoteSystemSessionController instance{ param0 };
                return py::wrap(instance, type);
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 2)
        {
            try
            {
                auto param0 = py::convert_to<winrt::hstring>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::System::RemoteSystems::RemoteSystemSessionOptions>(args, 1);

                winrt::Windows::System::RemoteSystems::RemoteSystemSessionController instance{ param0, param1 };
                return py::wrap(instance, type);
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static void _dealloc_RemoteSystemSessionController(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionController* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* RemoteSystemSessionController_CreateSessionAsync(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionController* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            try
            {
                return py::convert(self->obj.CreateSessionAsync());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RemoteSystemSessionController_RemoveParticipantAsync(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionController* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::System::RemoteSystems::RemoteSystemSessionParticipant>(args, 0);

                return py::convert(self->obj.RemoveParticipantAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RemoteSystemSessionController_add_JoinRequested(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionController* self, PyObject* arg) noexcept
    {
        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Windows::System::RemoteSystems::RemoteSystemSessionController, winrt::Windows::System::RemoteSystems::RemoteSystemSessionJoinRequestedEventArgs>>(arg);

            return py::convert(self->obj.JoinRequested(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystemSessionController_remove_JoinRequested(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionController* self, PyObject* arg) noexcept
    {
        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.JoinRequested(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_RemoteSystemSessionController(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::System::RemoteSystems::RemoteSystemSessionController>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RemoteSystemSessionController[] = {
        { "create_session_async", reinterpret_cast<PyCFunction>(RemoteSystemSessionController_CreateSessionAsync), METH_VARARGS, nullptr },
        { "remove_participant_async", reinterpret_cast<PyCFunction>(RemoteSystemSessionController_RemoveParticipantAsync), METH_VARARGS, nullptr },
        { "add_join_requested", reinterpret_cast<PyCFunction>(RemoteSystemSessionController_add_JoinRequested), METH_O, nullptr },
        { "remove_join_requested", reinterpret_cast<PyCFunction>(RemoteSystemSessionController_remove_JoinRequested), METH_O, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_RemoteSystemSessionController), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RemoteSystemSessionController[] = {
        { }
    };

    static PyType_Slot _type_slots_RemoteSystemSessionController[] = 
    {
        { Py_tp_new, _new_RemoteSystemSessionController },
        { Py_tp_dealloc, _dealloc_RemoteSystemSessionController },
        { Py_tp_methods, _methods_RemoteSystemSessionController },
        { Py_tp_getset, _getset_RemoteSystemSessionController },
        { },
    };

    static PyType_Spec _type_spec_RemoteSystemSessionController =
    {
        "_winsdk_Windows_System_RemoteSystems.RemoteSystemSessionController",
        sizeof(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionController),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RemoteSystemSessionController
    };

    // ----- RemoteSystemSessionCreationResult class --------------------
    constexpr const char* const _type_name_RemoteSystemSessionCreationResult = "RemoteSystemSessionCreationResult";

    static PyObject* _new_RemoteSystemSessionCreationResult(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
    {
        py::set_invalid_activation_error(_type_name_RemoteSystemSessionCreationResult);
        return nullptr;
    }

    static void _dealloc_RemoteSystemSessionCreationResult(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionCreationResult* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* RemoteSystemSessionCreationResult_get_Session(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionCreationResult* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Session());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystemSessionCreationResult_get_Status(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionCreationResult* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Status());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_RemoteSystemSessionCreationResult(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::System::RemoteSystems::RemoteSystemSessionCreationResult>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RemoteSystemSessionCreationResult[] = {
        { "_from", reinterpret_cast<PyCFunction>(_from_RemoteSystemSessionCreationResult), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RemoteSystemSessionCreationResult[] = {
        { "session", reinterpret_cast<getter>(RemoteSystemSessionCreationResult_get_Session), nullptr, nullptr, nullptr },
        { "status", reinterpret_cast<getter>(RemoteSystemSessionCreationResult_get_Status), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_RemoteSystemSessionCreationResult[] = 
    {
        { Py_tp_new, _new_RemoteSystemSessionCreationResult },
        { Py_tp_dealloc, _dealloc_RemoteSystemSessionCreationResult },
        { Py_tp_methods, _methods_RemoteSystemSessionCreationResult },
        { Py_tp_getset, _getset_RemoteSystemSessionCreationResult },
        { },
    };

    static PyType_Spec _type_spec_RemoteSystemSessionCreationResult =
    {
        "_winsdk_Windows_System_RemoteSystems.RemoteSystemSessionCreationResult",
        sizeof(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionCreationResult),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RemoteSystemSessionCreationResult
    };

    // ----- RemoteSystemSessionDisconnectedEventArgs class --------------------
    constexpr const char* const _type_name_RemoteSystemSessionDisconnectedEventArgs = "RemoteSystemSessionDisconnectedEventArgs";

    static PyObject* _new_RemoteSystemSessionDisconnectedEventArgs(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
    {
        py::set_invalid_activation_error(_type_name_RemoteSystemSessionDisconnectedEventArgs);
        return nullptr;
    }

    static void _dealloc_RemoteSystemSessionDisconnectedEventArgs(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionDisconnectedEventArgs* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* RemoteSystemSessionDisconnectedEventArgs_get_Reason(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionDisconnectedEventArgs* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Reason());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_RemoteSystemSessionDisconnectedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::System::RemoteSystems::RemoteSystemSessionDisconnectedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RemoteSystemSessionDisconnectedEventArgs[] = {
        { "_from", reinterpret_cast<PyCFunction>(_from_RemoteSystemSessionDisconnectedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RemoteSystemSessionDisconnectedEventArgs[] = {
        { "reason", reinterpret_cast<getter>(RemoteSystemSessionDisconnectedEventArgs_get_Reason), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_RemoteSystemSessionDisconnectedEventArgs[] = 
    {
        { Py_tp_new, _new_RemoteSystemSessionDisconnectedEventArgs },
        { Py_tp_dealloc, _dealloc_RemoteSystemSessionDisconnectedEventArgs },
        { Py_tp_methods, _methods_RemoteSystemSessionDisconnectedEventArgs },
        { Py_tp_getset, _getset_RemoteSystemSessionDisconnectedEventArgs },
        { },
    };

    static PyType_Spec _type_spec_RemoteSystemSessionDisconnectedEventArgs =
    {
        "_winsdk_Windows_System_RemoteSystems.RemoteSystemSessionDisconnectedEventArgs",
        sizeof(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionDisconnectedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RemoteSystemSessionDisconnectedEventArgs
    };

    // ----- RemoteSystemSessionInfo class --------------------
    constexpr const char* const _type_name_RemoteSystemSessionInfo = "RemoteSystemSessionInfo";

    static PyObject* _new_RemoteSystemSessionInfo(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
    {
        py::set_invalid_activation_error(_type_name_RemoteSystemSessionInfo);
        return nullptr;
    }

    static void _dealloc_RemoteSystemSessionInfo(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionInfo* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* RemoteSystemSessionInfo_JoinAsync(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionInfo* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            try
            {
                return py::convert(self->obj.JoinAsync());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RemoteSystemSessionInfo_get_ControllerDisplayName(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionInfo* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ControllerDisplayName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystemSessionInfo_get_DisplayName(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionInfo* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.DisplayName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_RemoteSystemSessionInfo(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::System::RemoteSystems::RemoteSystemSessionInfo>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RemoteSystemSessionInfo[] = {
        { "join_async", reinterpret_cast<PyCFunction>(RemoteSystemSessionInfo_JoinAsync), METH_VARARGS, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_RemoteSystemSessionInfo), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RemoteSystemSessionInfo[] = {
        { "controller_display_name", reinterpret_cast<getter>(RemoteSystemSessionInfo_get_ControllerDisplayName), nullptr, nullptr, nullptr },
        { "display_name", reinterpret_cast<getter>(RemoteSystemSessionInfo_get_DisplayName), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_RemoteSystemSessionInfo[] = 
    {
        { Py_tp_new, _new_RemoteSystemSessionInfo },
        { Py_tp_dealloc, _dealloc_RemoteSystemSessionInfo },
        { Py_tp_methods, _methods_RemoteSystemSessionInfo },
        { Py_tp_getset, _getset_RemoteSystemSessionInfo },
        { },
    };

    static PyType_Spec _type_spec_RemoteSystemSessionInfo =
    {
        "_winsdk_Windows_System_RemoteSystems.RemoteSystemSessionInfo",
        sizeof(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionInfo),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RemoteSystemSessionInfo
    };

    // ----- RemoteSystemSessionInvitation class --------------------
    constexpr const char* const _type_name_RemoteSystemSessionInvitation = "RemoteSystemSessionInvitation";

    static PyObject* _new_RemoteSystemSessionInvitation(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
    {
        py::set_invalid_activation_error(_type_name_RemoteSystemSessionInvitation);
        return nullptr;
    }

    static void _dealloc_RemoteSystemSessionInvitation(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionInvitation* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* RemoteSystemSessionInvitation_get_Sender(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionInvitation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Sender());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystemSessionInvitation_get_SessionInfo(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionInvitation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.SessionInfo());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_RemoteSystemSessionInvitation(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::System::RemoteSystems::RemoteSystemSessionInvitation>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RemoteSystemSessionInvitation[] = {
        { "_from", reinterpret_cast<PyCFunction>(_from_RemoteSystemSessionInvitation), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RemoteSystemSessionInvitation[] = {
        { "sender", reinterpret_cast<getter>(RemoteSystemSessionInvitation_get_Sender), nullptr, nullptr, nullptr },
        { "session_info", reinterpret_cast<getter>(RemoteSystemSessionInvitation_get_SessionInfo), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_RemoteSystemSessionInvitation[] = 
    {
        { Py_tp_new, _new_RemoteSystemSessionInvitation },
        { Py_tp_dealloc, _dealloc_RemoteSystemSessionInvitation },
        { Py_tp_methods, _methods_RemoteSystemSessionInvitation },
        { Py_tp_getset, _getset_RemoteSystemSessionInvitation },
        { },
    };

    static PyType_Spec _type_spec_RemoteSystemSessionInvitation =
    {
        "_winsdk_Windows_System_RemoteSystems.RemoteSystemSessionInvitation",
        sizeof(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionInvitation),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RemoteSystemSessionInvitation
    };

    // ----- RemoteSystemSessionInvitationListener class --------------------
    constexpr const char* const _type_name_RemoteSystemSessionInvitationListener = "RemoteSystemSessionInvitationListener";

    static PyObject* _new_RemoteSystemSessionInvitationListener(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
    {
        if (kwds != nullptr)
        {
            py::set_invalid_kwd_args_error();
            return nullptr;
        }

        Py_ssize_t arg_count = PyTuple_Size(args);
        if (arg_count == 0)
        {
            try
            {
                winrt::Windows::System::RemoteSystems::RemoteSystemSessionInvitationListener instance{  };
                return py::wrap(instance, type);
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static void _dealloc_RemoteSystemSessionInvitationListener(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionInvitationListener* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* RemoteSystemSessionInvitationListener_add_InvitationReceived(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionInvitationListener* self, PyObject* arg) noexcept
    {
        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Windows::System::RemoteSystems::RemoteSystemSessionInvitationListener, winrt::Windows::System::RemoteSystems::RemoteSystemSessionInvitationReceivedEventArgs>>(arg);

            return py::convert(self->obj.InvitationReceived(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystemSessionInvitationListener_remove_InvitationReceived(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionInvitationListener* self, PyObject* arg) noexcept
    {
        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.InvitationReceived(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_RemoteSystemSessionInvitationListener(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::System::RemoteSystems::RemoteSystemSessionInvitationListener>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RemoteSystemSessionInvitationListener[] = {
        { "add_invitation_received", reinterpret_cast<PyCFunction>(RemoteSystemSessionInvitationListener_add_InvitationReceived), METH_O, nullptr },
        { "remove_invitation_received", reinterpret_cast<PyCFunction>(RemoteSystemSessionInvitationListener_remove_InvitationReceived), METH_O, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_RemoteSystemSessionInvitationListener), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RemoteSystemSessionInvitationListener[] = {
        { }
    };

    static PyType_Slot _type_slots_RemoteSystemSessionInvitationListener[] = 
    {
        { Py_tp_new, _new_RemoteSystemSessionInvitationListener },
        { Py_tp_dealloc, _dealloc_RemoteSystemSessionInvitationListener },
        { Py_tp_methods, _methods_RemoteSystemSessionInvitationListener },
        { Py_tp_getset, _getset_RemoteSystemSessionInvitationListener },
        { },
    };

    static PyType_Spec _type_spec_RemoteSystemSessionInvitationListener =
    {
        "_winsdk_Windows_System_RemoteSystems.RemoteSystemSessionInvitationListener",
        sizeof(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionInvitationListener),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RemoteSystemSessionInvitationListener
    };

    // ----- RemoteSystemSessionInvitationReceivedEventArgs class --------------------
    constexpr const char* const _type_name_RemoteSystemSessionInvitationReceivedEventArgs = "RemoteSystemSessionInvitationReceivedEventArgs";

    static PyObject* _new_RemoteSystemSessionInvitationReceivedEventArgs(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
    {
        py::set_invalid_activation_error(_type_name_RemoteSystemSessionInvitationReceivedEventArgs);
        return nullptr;
    }

    static void _dealloc_RemoteSystemSessionInvitationReceivedEventArgs(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionInvitationReceivedEventArgs* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* RemoteSystemSessionInvitationReceivedEventArgs_get_Invitation(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionInvitationReceivedEventArgs* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Invitation());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_RemoteSystemSessionInvitationReceivedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::System::RemoteSystems::RemoteSystemSessionInvitationReceivedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RemoteSystemSessionInvitationReceivedEventArgs[] = {
        { "_from", reinterpret_cast<PyCFunction>(_from_RemoteSystemSessionInvitationReceivedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RemoteSystemSessionInvitationReceivedEventArgs[] = {
        { "invitation", reinterpret_cast<getter>(RemoteSystemSessionInvitationReceivedEventArgs_get_Invitation), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_RemoteSystemSessionInvitationReceivedEventArgs[] = 
    {
        { Py_tp_new, _new_RemoteSystemSessionInvitationReceivedEventArgs },
        { Py_tp_dealloc, _dealloc_RemoteSystemSessionInvitationReceivedEventArgs },
        { Py_tp_methods, _methods_RemoteSystemSessionInvitationReceivedEventArgs },
        { Py_tp_getset, _getset_RemoteSystemSessionInvitationReceivedEventArgs },
        { },
    };

    static PyType_Spec _type_spec_RemoteSystemSessionInvitationReceivedEventArgs =
    {
        "_winsdk_Windows_System_RemoteSystems.RemoteSystemSessionInvitationReceivedEventArgs",
        sizeof(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionInvitationReceivedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RemoteSystemSessionInvitationReceivedEventArgs
    };

    // ----- RemoteSystemSessionJoinRequest class --------------------
    constexpr const char* const _type_name_RemoteSystemSessionJoinRequest = "RemoteSystemSessionJoinRequest";

    static PyObject* _new_RemoteSystemSessionJoinRequest(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
    {
        py::set_invalid_activation_error(_type_name_RemoteSystemSessionJoinRequest);
        return nullptr;
    }

    static void _dealloc_RemoteSystemSessionJoinRequest(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionJoinRequest* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* RemoteSystemSessionJoinRequest_Accept(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionJoinRequest* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            try
            {
                self->obj.Accept();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RemoteSystemSessionJoinRequest_get_Participant(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionJoinRequest* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Participant());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_RemoteSystemSessionJoinRequest(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::System::RemoteSystems::RemoteSystemSessionJoinRequest>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RemoteSystemSessionJoinRequest[] = {
        { "accept", reinterpret_cast<PyCFunction>(RemoteSystemSessionJoinRequest_Accept), METH_VARARGS, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_RemoteSystemSessionJoinRequest), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RemoteSystemSessionJoinRequest[] = {
        { "participant", reinterpret_cast<getter>(RemoteSystemSessionJoinRequest_get_Participant), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_RemoteSystemSessionJoinRequest[] = 
    {
        { Py_tp_new, _new_RemoteSystemSessionJoinRequest },
        { Py_tp_dealloc, _dealloc_RemoteSystemSessionJoinRequest },
        { Py_tp_methods, _methods_RemoteSystemSessionJoinRequest },
        { Py_tp_getset, _getset_RemoteSystemSessionJoinRequest },
        { },
    };

    static PyType_Spec _type_spec_RemoteSystemSessionJoinRequest =
    {
        "_winsdk_Windows_System_RemoteSystems.RemoteSystemSessionJoinRequest",
        sizeof(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionJoinRequest),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RemoteSystemSessionJoinRequest
    };

    // ----- RemoteSystemSessionJoinRequestedEventArgs class --------------------
    constexpr const char* const _type_name_RemoteSystemSessionJoinRequestedEventArgs = "RemoteSystemSessionJoinRequestedEventArgs";

    static PyObject* _new_RemoteSystemSessionJoinRequestedEventArgs(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
    {
        py::set_invalid_activation_error(_type_name_RemoteSystemSessionJoinRequestedEventArgs);
        return nullptr;
    }

    static void _dealloc_RemoteSystemSessionJoinRequestedEventArgs(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionJoinRequestedEventArgs* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* RemoteSystemSessionJoinRequestedEventArgs_GetDeferral(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionJoinRequestedEventArgs* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            try
            {
                return py::convert(self->obj.GetDeferral());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RemoteSystemSessionJoinRequestedEventArgs_get_JoinRequest(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionJoinRequestedEventArgs* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.JoinRequest());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_RemoteSystemSessionJoinRequestedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::System::RemoteSystems::RemoteSystemSessionJoinRequestedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RemoteSystemSessionJoinRequestedEventArgs[] = {
        { "get_deferral", reinterpret_cast<PyCFunction>(RemoteSystemSessionJoinRequestedEventArgs_GetDeferral), METH_VARARGS, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_RemoteSystemSessionJoinRequestedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RemoteSystemSessionJoinRequestedEventArgs[] = {
        { "join_request", reinterpret_cast<getter>(RemoteSystemSessionJoinRequestedEventArgs_get_JoinRequest), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_RemoteSystemSessionJoinRequestedEventArgs[] = 
    {
        { Py_tp_new, _new_RemoteSystemSessionJoinRequestedEventArgs },
        { Py_tp_dealloc, _dealloc_RemoteSystemSessionJoinRequestedEventArgs },
        { Py_tp_methods, _methods_RemoteSystemSessionJoinRequestedEventArgs },
        { Py_tp_getset, _getset_RemoteSystemSessionJoinRequestedEventArgs },
        { },
    };

    static PyType_Spec _type_spec_RemoteSystemSessionJoinRequestedEventArgs =
    {
        "_winsdk_Windows_System_RemoteSystems.RemoteSystemSessionJoinRequestedEventArgs",
        sizeof(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionJoinRequestedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RemoteSystemSessionJoinRequestedEventArgs
    };

    // ----- RemoteSystemSessionJoinResult class --------------------
    constexpr const char* const _type_name_RemoteSystemSessionJoinResult = "RemoteSystemSessionJoinResult";

    static PyObject* _new_RemoteSystemSessionJoinResult(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
    {
        py::set_invalid_activation_error(_type_name_RemoteSystemSessionJoinResult);
        return nullptr;
    }

    static void _dealloc_RemoteSystemSessionJoinResult(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionJoinResult* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* RemoteSystemSessionJoinResult_get_Session(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionJoinResult* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Session());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystemSessionJoinResult_get_Status(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionJoinResult* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Status());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_RemoteSystemSessionJoinResult(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::System::RemoteSystems::RemoteSystemSessionJoinResult>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RemoteSystemSessionJoinResult[] = {
        { "_from", reinterpret_cast<PyCFunction>(_from_RemoteSystemSessionJoinResult), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RemoteSystemSessionJoinResult[] = {
        { "session", reinterpret_cast<getter>(RemoteSystemSessionJoinResult_get_Session), nullptr, nullptr, nullptr },
        { "status", reinterpret_cast<getter>(RemoteSystemSessionJoinResult_get_Status), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_RemoteSystemSessionJoinResult[] = 
    {
        { Py_tp_new, _new_RemoteSystemSessionJoinResult },
        { Py_tp_dealloc, _dealloc_RemoteSystemSessionJoinResult },
        { Py_tp_methods, _methods_RemoteSystemSessionJoinResult },
        { Py_tp_getset, _getset_RemoteSystemSessionJoinResult },
        { },
    };

    static PyType_Spec _type_spec_RemoteSystemSessionJoinResult =
    {
        "_winsdk_Windows_System_RemoteSystems.RemoteSystemSessionJoinResult",
        sizeof(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionJoinResult),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RemoteSystemSessionJoinResult
    };

    // ----- RemoteSystemSessionMessageChannel class --------------------
    constexpr const char* const _type_name_RemoteSystemSessionMessageChannel = "RemoteSystemSessionMessageChannel";

    static PyObject* _new_RemoteSystemSessionMessageChannel(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
    {
        if (kwds != nullptr)
        {
            py::set_invalid_kwd_args_error();
            return nullptr;
        }

        Py_ssize_t arg_count = PyTuple_Size(args);
        if (arg_count == 2)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::System::RemoteSystems::RemoteSystemSession>(args, 0);
                auto param1 = py::convert_to<winrt::hstring>(args, 1);

                winrt::Windows::System::RemoteSystems::RemoteSystemSessionMessageChannel instance{ param0, param1 };
                return py::wrap(instance, type);
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 3)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::System::RemoteSystems::RemoteSystemSession>(args, 0);
                auto param1 = py::convert_to<winrt::hstring>(args, 1);
                auto param2 = py::convert_to<winrt::Windows::System::RemoteSystems::RemoteSystemSessionMessageChannelReliability>(args, 2);

                winrt::Windows::System::RemoteSystems::RemoteSystemSessionMessageChannel instance{ param0, param1, param2 };
                return py::wrap(instance, type);
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static void _dealloc_RemoteSystemSessionMessageChannel(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionMessageChannel* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* RemoteSystemSessionMessageChannel_BroadcastValueSetAsync(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionMessageChannel* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Foundation::Collections::ValueSet>(args, 0);

                return py::convert(self->obj.BroadcastValueSetAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RemoteSystemSessionMessageChannel_SendValueSetAsync(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionMessageChannel* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Foundation::Collections::ValueSet>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::System::RemoteSystems::RemoteSystemSessionParticipant>(args, 1);

                return py::convert(self->obj.SendValueSetAsync(param0, param1));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RemoteSystemSessionMessageChannel_SendValueSetToParticipantsAsync(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionMessageChannel* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Foundation::Collections::ValueSet>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Foundation::Collections::IIterable<winrt::Windows::System::RemoteSystems::RemoteSystemSessionParticipant>>(args, 1);

                return py::convert(self->obj.SendValueSetToParticipantsAsync(param0, param1));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RemoteSystemSessionMessageChannel_get_Session(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionMessageChannel* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Session());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystemSessionMessageChannel_add_ValueSetReceived(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionMessageChannel* self, PyObject* arg) noexcept
    {
        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Windows::System::RemoteSystems::RemoteSystemSessionMessageChannel, winrt::Windows::System::RemoteSystems::RemoteSystemSessionValueSetReceivedEventArgs>>(arg);

            return py::convert(self->obj.ValueSetReceived(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystemSessionMessageChannel_remove_ValueSetReceived(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionMessageChannel* self, PyObject* arg) noexcept
    {
        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.ValueSetReceived(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_RemoteSystemSessionMessageChannel(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::System::RemoteSystems::RemoteSystemSessionMessageChannel>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RemoteSystemSessionMessageChannel[] = {
        { "broadcast_value_set_async", reinterpret_cast<PyCFunction>(RemoteSystemSessionMessageChannel_BroadcastValueSetAsync), METH_VARARGS, nullptr },
        { "send_value_set_async", reinterpret_cast<PyCFunction>(RemoteSystemSessionMessageChannel_SendValueSetAsync), METH_VARARGS, nullptr },
        { "send_value_set_to_participants_async", reinterpret_cast<PyCFunction>(RemoteSystemSessionMessageChannel_SendValueSetToParticipantsAsync), METH_VARARGS, nullptr },
        { "add_value_set_received", reinterpret_cast<PyCFunction>(RemoteSystemSessionMessageChannel_add_ValueSetReceived), METH_O, nullptr },
        { "remove_value_set_received", reinterpret_cast<PyCFunction>(RemoteSystemSessionMessageChannel_remove_ValueSetReceived), METH_O, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_RemoteSystemSessionMessageChannel), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RemoteSystemSessionMessageChannel[] = {
        { "session", reinterpret_cast<getter>(RemoteSystemSessionMessageChannel_get_Session), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_RemoteSystemSessionMessageChannel[] = 
    {
        { Py_tp_new, _new_RemoteSystemSessionMessageChannel },
        { Py_tp_dealloc, _dealloc_RemoteSystemSessionMessageChannel },
        { Py_tp_methods, _methods_RemoteSystemSessionMessageChannel },
        { Py_tp_getset, _getset_RemoteSystemSessionMessageChannel },
        { },
    };

    static PyType_Spec _type_spec_RemoteSystemSessionMessageChannel =
    {
        "_winsdk_Windows_System_RemoteSystems.RemoteSystemSessionMessageChannel",
        sizeof(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionMessageChannel),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RemoteSystemSessionMessageChannel
    };

    // ----- RemoteSystemSessionOptions class --------------------
    constexpr const char* const _type_name_RemoteSystemSessionOptions = "RemoteSystemSessionOptions";

    static PyObject* _new_RemoteSystemSessionOptions(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
    {
        if (kwds != nullptr)
        {
            py::set_invalid_kwd_args_error();
            return nullptr;
        }

        Py_ssize_t arg_count = PyTuple_Size(args);
        if (arg_count == 0)
        {
            try
            {
                winrt::Windows::System::RemoteSystems::RemoteSystemSessionOptions instance{  };
                return py::wrap(instance, type);
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static void _dealloc_RemoteSystemSessionOptions(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionOptions* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* RemoteSystemSessionOptions_get_IsInviteOnly(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionOptions* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.IsInviteOnly());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int RemoteSystemSessionOptions_put_IsInviteOnly(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionOptions* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_TypeError, "property delete not supported");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<bool>(arg);

            self->obj.IsInviteOnly(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* _from_RemoteSystemSessionOptions(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::System::RemoteSystems::RemoteSystemSessionOptions>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RemoteSystemSessionOptions[] = {
        { "_from", reinterpret_cast<PyCFunction>(_from_RemoteSystemSessionOptions), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RemoteSystemSessionOptions[] = {
        { "is_invite_only", reinterpret_cast<getter>(RemoteSystemSessionOptions_get_IsInviteOnly), reinterpret_cast<setter>(RemoteSystemSessionOptions_put_IsInviteOnly), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_RemoteSystemSessionOptions[] = 
    {
        { Py_tp_new, _new_RemoteSystemSessionOptions },
        { Py_tp_dealloc, _dealloc_RemoteSystemSessionOptions },
        { Py_tp_methods, _methods_RemoteSystemSessionOptions },
        { Py_tp_getset, _getset_RemoteSystemSessionOptions },
        { },
    };

    static PyType_Spec _type_spec_RemoteSystemSessionOptions =
    {
        "_winsdk_Windows_System_RemoteSystems.RemoteSystemSessionOptions",
        sizeof(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionOptions),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RemoteSystemSessionOptions
    };

    // ----- RemoteSystemSessionParticipant class --------------------
    constexpr const char* const _type_name_RemoteSystemSessionParticipant = "RemoteSystemSessionParticipant";

    static PyObject* _new_RemoteSystemSessionParticipant(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
    {
        py::set_invalid_activation_error(_type_name_RemoteSystemSessionParticipant);
        return nullptr;
    }

    static void _dealloc_RemoteSystemSessionParticipant(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionParticipant* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* RemoteSystemSessionParticipant_GetHostNames(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionParticipant* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            try
            {
                return py::convert(self->obj.GetHostNames());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RemoteSystemSessionParticipant_get_RemoteSystem(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionParticipant* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.RemoteSystem());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_RemoteSystemSessionParticipant(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::System::RemoteSystems::RemoteSystemSessionParticipant>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RemoteSystemSessionParticipant[] = {
        { "get_host_names", reinterpret_cast<PyCFunction>(RemoteSystemSessionParticipant_GetHostNames), METH_VARARGS, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_RemoteSystemSessionParticipant), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RemoteSystemSessionParticipant[] = {
        { "remote_system", reinterpret_cast<getter>(RemoteSystemSessionParticipant_get_RemoteSystem), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_RemoteSystemSessionParticipant[] = 
    {
        { Py_tp_new, _new_RemoteSystemSessionParticipant },
        { Py_tp_dealloc, _dealloc_RemoteSystemSessionParticipant },
        { Py_tp_methods, _methods_RemoteSystemSessionParticipant },
        { Py_tp_getset, _getset_RemoteSystemSessionParticipant },
        { },
    };

    static PyType_Spec _type_spec_RemoteSystemSessionParticipant =
    {
        "_winsdk_Windows_System_RemoteSystems.RemoteSystemSessionParticipant",
        sizeof(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionParticipant),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RemoteSystemSessionParticipant
    };

    // ----- RemoteSystemSessionParticipantAddedEventArgs class --------------------
    constexpr const char* const _type_name_RemoteSystemSessionParticipantAddedEventArgs = "RemoteSystemSessionParticipantAddedEventArgs";

    static PyObject* _new_RemoteSystemSessionParticipantAddedEventArgs(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
    {
        py::set_invalid_activation_error(_type_name_RemoteSystemSessionParticipantAddedEventArgs);
        return nullptr;
    }

    static void _dealloc_RemoteSystemSessionParticipantAddedEventArgs(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionParticipantAddedEventArgs* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* RemoteSystemSessionParticipantAddedEventArgs_get_Participant(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionParticipantAddedEventArgs* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Participant());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_RemoteSystemSessionParticipantAddedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::System::RemoteSystems::RemoteSystemSessionParticipantAddedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RemoteSystemSessionParticipantAddedEventArgs[] = {
        { "_from", reinterpret_cast<PyCFunction>(_from_RemoteSystemSessionParticipantAddedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RemoteSystemSessionParticipantAddedEventArgs[] = {
        { "participant", reinterpret_cast<getter>(RemoteSystemSessionParticipantAddedEventArgs_get_Participant), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_RemoteSystemSessionParticipantAddedEventArgs[] = 
    {
        { Py_tp_new, _new_RemoteSystemSessionParticipantAddedEventArgs },
        { Py_tp_dealloc, _dealloc_RemoteSystemSessionParticipantAddedEventArgs },
        { Py_tp_methods, _methods_RemoteSystemSessionParticipantAddedEventArgs },
        { Py_tp_getset, _getset_RemoteSystemSessionParticipantAddedEventArgs },
        { },
    };

    static PyType_Spec _type_spec_RemoteSystemSessionParticipantAddedEventArgs =
    {
        "_winsdk_Windows_System_RemoteSystems.RemoteSystemSessionParticipantAddedEventArgs",
        sizeof(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionParticipantAddedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RemoteSystemSessionParticipantAddedEventArgs
    };

    // ----- RemoteSystemSessionParticipantRemovedEventArgs class --------------------
    constexpr const char* const _type_name_RemoteSystemSessionParticipantRemovedEventArgs = "RemoteSystemSessionParticipantRemovedEventArgs";

    static PyObject* _new_RemoteSystemSessionParticipantRemovedEventArgs(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
    {
        py::set_invalid_activation_error(_type_name_RemoteSystemSessionParticipantRemovedEventArgs);
        return nullptr;
    }

    static void _dealloc_RemoteSystemSessionParticipantRemovedEventArgs(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionParticipantRemovedEventArgs* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* RemoteSystemSessionParticipantRemovedEventArgs_get_Participant(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionParticipantRemovedEventArgs* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Participant());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_RemoteSystemSessionParticipantRemovedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::System::RemoteSystems::RemoteSystemSessionParticipantRemovedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RemoteSystemSessionParticipantRemovedEventArgs[] = {
        { "_from", reinterpret_cast<PyCFunction>(_from_RemoteSystemSessionParticipantRemovedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RemoteSystemSessionParticipantRemovedEventArgs[] = {
        { "participant", reinterpret_cast<getter>(RemoteSystemSessionParticipantRemovedEventArgs_get_Participant), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_RemoteSystemSessionParticipantRemovedEventArgs[] = 
    {
        { Py_tp_new, _new_RemoteSystemSessionParticipantRemovedEventArgs },
        { Py_tp_dealloc, _dealloc_RemoteSystemSessionParticipantRemovedEventArgs },
        { Py_tp_methods, _methods_RemoteSystemSessionParticipantRemovedEventArgs },
        { Py_tp_getset, _getset_RemoteSystemSessionParticipantRemovedEventArgs },
        { },
    };

    static PyType_Spec _type_spec_RemoteSystemSessionParticipantRemovedEventArgs =
    {
        "_winsdk_Windows_System_RemoteSystems.RemoteSystemSessionParticipantRemovedEventArgs",
        sizeof(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionParticipantRemovedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RemoteSystemSessionParticipantRemovedEventArgs
    };

    // ----- RemoteSystemSessionParticipantWatcher class --------------------
    constexpr const char* const _type_name_RemoteSystemSessionParticipantWatcher = "RemoteSystemSessionParticipantWatcher";

    static PyObject* _new_RemoteSystemSessionParticipantWatcher(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
    {
        py::set_invalid_activation_error(_type_name_RemoteSystemSessionParticipantWatcher);
        return nullptr;
    }

    static void _dealloc_RemoteSystemSessionParticipantWatcher(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionParticipantWatcher* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* RemoteSystemSessionParticipantWatcher_Start(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionParticipantWatcher* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            try
            {
                self->obj.Start();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RemoteSystemSessionParticipantWatcher_Stop(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionParticipantWatcher* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            try
            {
                self->obj.Stop();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RemoteSystemSessionParticipantWatcher_get_Status(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionParticipantWatcher* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Status());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystemSessionParticipantWatcher_add_Added(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionParticipantWatcher* self, PyObject* arg) noexcept
    {
        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Windows::System::RemoteSystems::RemoteSystemSessionParticipantWatcher, winrt::Windows::System::RemoteSystems::RemoteSystemSessionParticipantAddedEventArgs>>(arg);

            return py::convert(self->obj.Added(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystemSessionParticipantWatcher_remove_Added(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionParticipantWatcher* self, PyObject* arg) noexcept
    {
        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.Added(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystemSessionParticipantWatcher_add_EnumerationCompleted(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionParticipantWatcher* self, PyObject* arg) noexcept
    {
        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Windows::System::RemoteSystems::RemoteSystemSessionParticipantWatcher, winrt::Windows::Foundation::IInspectable>>(arg);

            return py::convert(self->obj.EnumerationCompleted(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystemSessionParticipantWatcher_remove_EnumerationCompleted(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionParticipantWatcher* self, PyObject* arg) noexcept
    {
        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.EnumerationCompleted(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystemSessionParticipantWatcher_add_Removed(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionParticipantWatcher* self, PyObject* arg) noexcept
    {
        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Windows::System::RemoteSystems::RemoteSystemSessionParticipantWatcher, winrt::Windows::System::RemoteSystems::RemoteSystemSessionParticipantRemovedEventArgs>>(arg);

            return py::convert(self->obj.Removed(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystemSessionParticipantWatcher_remove_Removed(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionParticipantWatcher* self, PyObject* arg) noexcept
    {
        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.Removed(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_RemoteSystemSessionParticipantWatcher(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::System::RemoteSystems::RemoteSystemSessionParticipantWatcher>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RemoteSystemSessionParticipantWatcher[] = {
        { "start", reinterpret_cast<PyCFunction>(RemoteSystemSessionParticipantWatcher_Start), METH_VARARGS, nullptr },
        { "stop", reinterpret_cast<PyCFunction>(RemoteSystemSessionParticipantWatcher_Stop), METH_VARARGS, nullptr },
        { "add_added", reinterpret_cast<PyCFunction>(RemoteSystemSessionParticipantWatcher_add_Added), METH_O, nullptr },
        { "remove_added", reinterpret_cast<PyCFunction>(RemoteSystemSessionParticipantWatcher_remove_Added), METH_O, nullptr },
        { "add_enumeration_completed", reinterpret_cast<PyCFunction>(RemoteSystemSessionParticipantWatcher_add_EnumerationCompleted), METH_O, nullptr },
        { "remove_enumeration_completed", reinterpret_cast<PyCFunction>(RemoteSystemSessionParticipantWatcher_remove_EnumerationCompleted), METH_O, nullptr },
        { "add_removed", reinterpret_cast<PyCFunction>(RemoteSystemSessionParticipantWatcher_add_Removed), METH_O, nullptr },
        { "remove_removed", reinterpret_cast<PyCFunction>(RemoteSystemSessionParticipantWatcher_remove_Removed), METH_O, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_RemoteSystemSessionParticipantWatcher), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RemoteSystemSessionParticipantWatcher[] = {
        { "status", reinterpret_cast<getter>(RemoteSystemSessionParticipantWatcher_get_Status), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_RemoteSystemSessionParticipantWatcher[] = 
    {
        { Py_tp_new, _new_RemoteSystemSessionParticipantWatcher },
        { Py_tp_dealloc, _dealloc_RemoteSystemSessionParticipantWatcher },
        { Py_tp_methods, _methods_RemoteSystemSessionParticipantWatcher },
        { Py_tp_getset, _getset_RemoteSystemSessionParticipantWatcher },
        { },
    };

    static PyType_Spec _type_spec_RemoteSystemSessionParticipantWatcher =
    {
        "_winsdk_Windows_System_RemoteSystems.RemoteSystemSessionParticipantWatcher",
        sizeof(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionParticipantWatcher),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RemoteSystemSessionParticipantWatcher
    };

    // ----- RemoteSystemSessionRemovedEventArgs class --------------------
    constexpr const char* const _type_name_RemoteSystemSessionRemovedEventArgs = "RemoteSystemSessionRemovedEventArgs";

    static PyObject* _new_RemoteSystemSessionRemovedEventArgs(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
    {
        py::set_invalid_activation_error(_type_name_RemoteSystemSessionRemovedEventArgs);
        return nullptr;
    }

    static void _dealloc_RemoteSystemSessionRemovedEventArgs(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionRemovedEventArgs* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* RemoteSystemSessionRemovedEventArgs_get_SessionInfo(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionRemovedEventArgs* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.SessionInfo());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_RemoteSystemSessionRemovedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::System::RemoteSystems::RemoteSystemSessionRemovedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RemoteSystemSessionRemovedEventArgs[] = {
        { "_from", reinterpret_cast<PyCFunction>(_from_RemoteSystemSessionRemovedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RemoteSystemSessionRemovedEventArgs[] = {
        { "session_info", reinterpret_cast<getter>(RemoteSystemSessionRemovedEventArgs_get_SessionInfo), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_RemoteSystemSessionRemovedEventArgs[] = 
    {
        { Py_tp_new, _new_RemoteSystemSessionRemovedEventArgs },
        { Py_tp_dealloc, _dealloc_RemoteSystemSessionRemovedEventArgs },
        { Py_tp_methods, _methods_RemoteSystemSessionRemovedEventArgs },
        { Py_tp_getset, _getset_RemoteSystemSessionRemovedEventArgs },
        { },
    };

    static PyType_Spec _type_spec_RemoteSystemSessionRemovedEventArgs =
    {
        "_winsdk_Windows_System_RemoteSystems.RemoteSystemSessionRemovedEventArgs",
        sizeof(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionRemovedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RemoteSystemSessionRemovedEventArgs
    };

    // ----- RemoteSystemSessionUpdatedEventArgs class --------------------
    constexpr const char* const _type_name_RemoteSystemSessionUpdatedEventArgs = "RemoteSystemSessionUpdatedEventArgs";

    static PyObject* _new_RemoteSystemSessionUpdatedEventArgs(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
    {
        py::set_invalid_activation_error(_type_name_RemoteSystemSessionUpdatedEventArgs);
        return nullptr;
    }

    static void _dealloc_RemoteSystemSessionUpdatedEventArgs(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionUpdatedEventArgs* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* RemoteSystemSessionUpdatedEventArgs_get_SessionInfo(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionUpdatedEventArgs* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.SessionInfo());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_RemoteSystemSessionUpdatedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::System::RemoteSystems::RemoteSystemSessionUpdatedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RemoteSystemSessionUpdatedEventArgs[] = {
        { "_from", reinterpret_cast<PyCFunction>(_from_RemoteSystemSessionUpdatedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RemoteSystemSessionUpdatedEventArgs[] = {
        { "session_info", reinterpret_cast<getter>(RemoteSystemSessionUpdatedEventArgs_get_SessionInfo), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_RemoteSystemSessionUpdatedEventArgs[] = 
    {
        { Py_tp_new, _new_RemoteSystemSessionUpdatedEventArgs },
        { Py_tp_dealloc, _dealloc_RemoteSystemSessionUpdatedEventArgs },
        { Py_tp_methods, _methods_RemoteSystemSessionUpdatedEventArgs },
        { Py_tp_getset, _getset_RemoteSystemSessionUpdatedEventArgs },
        { },
    };

    static PyType_Spec _type_spec_RemoteSystemSessionUpdatedEventArgs =
    {
        "_winsdk_Windows_System_RemoteSystems.RemoteSystemSessionUpdatedEventArgs",
        sizeof(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionUpdatedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RemoteSystemSessionUpdatedEventArgs
    };

    // ----- RemoteSystemSessionValueSetReceivedEventArgs class --------------------
    constexpr const char* const _type_name_RemoteSystemSessionValueSetReceivedEventArgs = "RemoteSystemSessionValueSetReceivedEventArgs";

    static PyObject* _new_RemoteSystemSessionValueSetReceivedEventArgs(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
    {
        py::set_invalid_activation_error(_type_name_RemoteSystemSessionValueSetReceivedEventArgs);
        return nullptr;
    }

    static void _dealloc_RemoteSystemSessionValueSetReceivedEventArgs(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionValueSetReceivedEventArgs* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* RemoteSystemSessionValueSetReceivedEventArgs_get_Message(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionValueSetReceivedEventArgs* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Message());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystemSessionValueSetReceivedEventArgs_get_Sender(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionValueSetReceivedEventArgs* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Sender());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_RemoteSystemSessionValueSetReceivedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::System::RemoteSystems::RemoteSystemSessionValueSetReceivedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RemoteSystemSessionValueSetReceivedEventArgs[] = {
        { "_from", reinterpret_cast<PyCFunction>(_from_RemoteSystemSessionValueSetReceivedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RemoteSystemSessionValueSetReceivedEventArgs[] = {
        { "message", reinterpret_cast<getter>(RemoteSystemSessionValueSetReceivedEventArgs_get_Message), nullptr, nullptr, nullptr },
        { "sender", reinterpret_cast<getter>(RemoteSystemSessionValueSetReceivedEventArgs_get_Sender), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_RemoteSystemSessionValueSetReceivedEventArgs[] = 
    {
        { Py_tp_new, _new_RemoteSystemSessionValueSetReceivedEventArgs },
        { Py_tp_dealloc, _dealloc_RemoteSystemSessionValueSetReceivedEventArgs },
        { Py_tp_methods, _methods_RemoteSystemSessionValueSetReceivedEventArgs },
        { Py_tp_getset, _getset_RemoteSystemSessionValueSetReceivedEventArgs },
        { },
    };

    static PyType_Spec _type_spec_RemoteSystemSessionValueSetReceivedEventArgs =
    {
        "_winsdk_Windows_System_RemoteSystems.RemoteSystemSessionValueSetReceivedEventArgs",
        sizeof(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionValueSetReceivedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RemoteSystemSessionValueSetReceivedEventArgs
    };

    // ----- RemoteSystemSessionWatcher class --------------------
    constexpr const char* const _type_name_RemoteSystemSessionWatcher = "RemoteSystemSessionWatcher";

    static PyObject* _new_RemoteSystemSessionWatcher(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
    {
        py::set_invalid_activation_error(_type_name_RemoteSystemSessionWatcher);
        return nullptr;
    }

    static void _dealloc_RemoteSystemSessionWatcher(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionWatcher* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* RemoteSystemSessionWatcher_Start(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionWatcher* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            try
            {
                self->obj.Start();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RemoteSystemSessionWatcher_Stop(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionWatcher* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            try
            {
                self->obj.Stop();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RemoteSystemSessionWatcher_get_Status(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionWatcher* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Status());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystemSessionWatcher_add_Added(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionWatcher* self, PyObject* arg) noexcept
    {
        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Windows::System::RemoteSystems::RemoteSystemSessionWatcher, winrt::Windows::System::RemoteSystems::RemoteSystemSessionAddedEventArgs>>(arg);

            return py::convert(self->obj.Added(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystemSessionWatcher_remove_Added(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionWatcher* self, PyObject* arg) noexcept
    {
        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.Added(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystemSessionWatcher_add_Removed(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionWatcher* self, PyObject* arg) noexcept
    {
        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Windows::System::RemoteSystems::RemoteSystemSessionWatcher, winrt::Windows::System::RemoteSystems::RemoteSystemSessionRemovedEventArgs>>(arg);

            return py::convert(self->obj.Removed(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystemSessionWatcher_remove_Removed(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionWatcher* self, PyObject* arg) noexcept
    {
        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.Removed(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystemSessionWatcher_add_Updated(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionWatcher* self, PyObject* arg) noexcept
    {
        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Windows::System::RemoteSystems::RemoteSystemSessionWatcher, winrt::Windows::System::RemoteSystems::RemoteSystemSessionUpdatedEventArgs>>(arg);

            return py::convert(self->obj.Updated(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystemSessionWatcher_remove_Updated(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionWatcher* self, PyObject* arg) noexcept
    {
        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.Updated(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_RemoteSystemSessionWatcher(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::System::RemoteSystems::RemoteSystemSessionWatcher>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RemoteSystemSessionWatcher[] = {
        { "start", reinterpret_cast<PyCFunction>(RemoteSystemSessionWatcher_Start), METH_VARARGS, nullptr },
        { "stop", reinterpret_cast<PyCFunction>(RemoteSystemSessionWatcher_Stop), METH_VARARGS, nullptr },
        { "add_added", reinterpret_cast<PyCFunction>(RemoteSystemSessionWatcher_add_Added), METH_O, nullptr },
        { "remove_added", reinterpret_cast<PyCFunction>(RemoteSystemSessionWatcher_remove_Added), METH_O, nullptr },
        { "add_removed", reinterpret_cast<PyCFunction>(RemoteSystemSessionWatcher_add_Removed), METH_O, nullptr },
        { "remove_removed", reinterpret_cast<PyCFunction>(RemoteSystemSessionWatcher_remove_Removed), METH_O, nullptr },
        { "add_updated", reinterpret_cast<PyCFunction>(RemoteSystemSessionWatcher_add_Updated), METH_O, nullptr },
        { "remove_updated", reinterpret_cast<PyCFunction>(RemoteSystemSessionWatcher_remove_Updated), METH_O, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_RemoteSystemSessionWatcher), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RemoteSystemSessionWatcher[] = {
        { "status", reinterpret_cast<getter>(RemoteSystemSessionWatcher_get_Status), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_RemoteSystemSessionWatcher[] = 
    {
        { Py_tp_new, _new_RemoteSystemSessionWatcher },
        { Py_tp_dealloc, _dealloc_RemoteSystemSessionWatcher },
        { Py_tp_methods, _methods_RemoteSystemSessionWatcher },
        { Py_tp_getset, _getset_RemoteSystemSessionWatcher },
        { },
    };

    static PyType_Spec _type_spec_RemoteSystemSessionWatcher =
    {
        "_winsdk_Windows_System_RemoteSystems.RemoteSystemSessionWatcher",
        sizeof(py::wrapper::Windows::System::RemoteSystems::RemoteSystemSessionWatcher),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RemoteSystemSessionWatcher
    };

    // ----- RemoteSystemStatusTypeFilter class --------------------
    constexpr const char* const _type_name_RemoteSystemStatusTypeFilter = "RemoteSystemStatusTypeFilter";

    static PyObject* _new_RemoteSystemStatusTypeFilter(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
    {
        if (kwds != nullptr)
        {
            py::set_invalid_kwd_args_error();
            return nullptr;
        }

        Py_ssize_t arg_count = PyTuple_Size(args);
        if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::System::RemoteSystems::RemoteSystemStatusType>(args, 0);

                winrt::Windows::System::RemoteSystems::RemoteSystemStatusTypeFilter instance{ param0 };
                return py::wrap(instance, type);
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static void _dealloc_RemoteSystemStatusTypeFilter(py::wrapper::Windows::System::RemoteSystems::RemoteSystemStatusTypeFilter* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* RemoteSystemStatusTypeFilter_get_RemoteSystemStatusType(py::wrapper::Windows::System::RemoteSystems::RemoteSystemStatusTypeFilter* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.RemoteSystemStatusType());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_RemoteSystemStatusTypeFilter(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::System::RemoteSystems::RemoteSystemStatusTypeFilter>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RemoteSystemStatusTypeFilter[] = {
        { "_from", reinterpret_cast<PyCFunction>(_from_RemoteSystemStatusTypeFilter), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RemoteSystemStatusTypeFilter[] = {
        { "remote_system_status_type", reinterpret_cast<getter>(RemoteSystemStatusTypeFilter_get_RemoteSystemStatusType), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_RemoteSystemStatusTypeFilter[] = 
    {
        { Py_tp_new, _new_RemoteSystemStatusTypeFilter },
        { Py_tp_dealloc, _dealloc_RemoteSystemStatusTypeFilter },
        { Py_tp_methods, _methods_RemoteSystemStatusTypeFilter },
        { Py_tp_getset, _getset_RemoteSystemStatusTypeFilter },
        { },
    };

    static PyType_Spec _type_spec_RemoteSystemStatusTypeFilter =
    {
        "_winsdk_Windows_System_RemoteSystems.RemoteSystemStatusTypeFilter",
        sizeof(py::wrapper::Windows::System::RemoteSystems::RemoteSystemStatusTypeFilter),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RemoteSystemStatusTypeFilter
    };

    // ----- RemoteSystemUpdatedEventArgs class --------------------
    constexpr const char* const _type_name_RemoteSystemUpdatedEventArgs = "RemoteSystemUpdatedEventArgs";

    static PyObject* _new_RemoteSystemUpdatedEventArgs(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
    {
        py::set_invalid_activation_error(_type_name_RemoteSystemUpdatedEventArgs);
        return nullptr;
    }

    static void _dealloc_RemoteSystemUpdatedEventArgs(py::wrapper::Windows::System::RemoteSystems::RemoteSystemUpdatedEventArgs* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* RemoteSystemUpdatedEventArgs_get_RemoteSystem(py::wrapper::Windows::System::RemoteSystems::RemoteSystemUpdatedEventArgs* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.RemoteSystem());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_RemoteSystemUpdatedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::System::RemoteSystems::RemoteSystemUpdatedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RemoteSystemUpdatedEventArgs[] = {
        { "_from", reinterpret_cast<PyCFunction>(_from_RemoteSystemUpdatedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RemoteSystemUpdatedEventArgs[] = {
        { "remote_system", reinterpret_cast<getter>(RemoteSystemUpdatedEventArgs_get_RemoteSystem), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_RemoteSystemUpdatedEventArgs[] = 
    {
        { Py_tp_new, _new_RemoteSystemUpdatedEventArgs },
        { Py_tp_dealloc, _dealloc_RemoteSystemUpdatedEventArgs },
        { Py_tp_methods, _methods_RemoteSystemUpdatedEventArgs },
        { Py_tp_getset, _getset_RemoteSystemUpdatedEventArgs },
        { },
    };

    static PyType_Spec _type_spec_RemoteSystemUpdatedEventArgs =
    {
        "_winsdk_Windows_System_RemoteSystems.RemoteSystemUpdatedEventArgs",
        sizeof(py::wrapper::Windows::System::RemoteSystems::RemoteSystemUpdatedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RemoteSystemUpdatedEventArgs
    };

    // ----- RemoteSystemWatcher class --------------------
    constexpr const char* const _type_name_RemoteSystemWatcher = "RemoteSystemWatcher";

    static PyObject* _new_RemoteSystemWatcher(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
    {
        py::set_invalid_activation_error(_type_name_RemoteSystemWatcher);
        return nullptr;
    }

    static void _dealloc_RemoteSystemWatcher(py::wrapper::Windows::System::RemoteSystems::RemoteSystemWatcher* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* RemoteSystemWatcher_Start(py::wrapper::Windows::System::RemoteSystems::RemoteSystemWatcher* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            try
            {
                self->obj.Start();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RemoteSystemWatcher_Stop(py::wrapper::Windows::System::RemoteSystems::RemoteSystemWatcher* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            try
            {
                self->obj.Stop();
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* RemoteSystemWatcher_get_User(py::wrapper::Windows::System::RemoteSystems::RemoteSystemWatcher* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.User());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystemWatcher_add_RemoteSystemAdded(py::wrapper::Windows::System::RemoteSystems::RemoteSystemWatcher* self, PyObject* arg) noexcept
    {
        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Windows::System::RemoteSystems::RemoteSystemWatcher, winrt::Windows::System::RemoteSystems::RemoteSystemAddedEventArgs>>(arg);

            return py::convert(self->obj.RemoteSystemAdded(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystemWatcher_remove_RemoteSystemAdded(py::wrapper::Windows::System::RemoteSystems::RemoteSystemWatcher* self, PyObject* arg) noexcept
    {
        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.RemoteSystemAdded(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystemWatcher_add_RemoteSystemRemoved(py::wrapper::Windows::System::RemoteSystems::RemoteSystemWatcher* self, PyObject* arg) noexcept
    {
        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Windows::System::RemoteSystems::RemoteSystemWatcher, winrt::Windows::System::RemoteSystems::RemoteSystemRemovedEventArgs>>(arg);

            return py::convert(self->obj.RemoteSystemRemoved(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystemWatcher_remove_RemoteSystemRemoved(py::wrapper::Windows::System::RemoteSystems::RemoteSystemWatcher* self, PyObject* arg) noexcept
    {
        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.RemoteSystemRemoved(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystemWatcher_add_RemoteSystemUpdated(py::wrapper::Windows::System::RemoteSystems::RemoteSystemWatcher* self, PyObject* arg) noexcept
    {
        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Windows::System::RemoteSystems::RemoteSystemWatcher, winrt::Windows::System::RemoteSystems::RemoteSystemUpdatedEventArgs>>(arg);

            return py::convert(self->obj.RemoteSystemUpdated(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystemWatcher_remove_RemoteSystemUpdated(py::wrapper::Windows::System::RemoteSystems::RemoteSystemWatcher* self, PyObject* arg) noexcept
    {
        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.RemoteSystemUpdated(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystemWatcher_add_EnumerationCompleted(py::wrapper::Windows::System::RemoteSystems::RemoteSystemWatcher* self, PyObject* arg) noexcept
    {
        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Windows::System::RemoteSystems::RemoteSystemWatcher, winrt::Windows::System::RemoteSystems::RemoteSystemEnumerationCompletedEventArgs>>(arg);

            return py::convert(self->obj.EnumerationCompleted(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystemWatcher_remove_EnumerationCompleted(py::wrapper::Windows::System::RemoteSystems::RemoteSystemWatcher* self, PyObject* arg) noexcept
    {
        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.EnumerationCompleted(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystemWatcher_add_ErrorOccurred(py::wrapper::Windows::System::RemoteSystems::RemoteSystemWatcher* self, PyObject* arg) noexcept
    {
        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Windows::System::RemoteSystems::RemoteSystemWatcher, winrt::Windows::System::RemoteSystems::RemoteSystemWatcherErrorOccurredEventArgs>>(arg);

            return py::convert(self->obj.ErrorOccurred(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RemoteSystemWatcher_remove_ErrorOccurred(py::wrapper::Windows::System::RemoteSystems::RemoteSystemWatcher* self, PyObject* arg) noexcept
    {
        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            self->obj.ErrorOccurred(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_RemoteSystemWatcher(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::System::RemoteSystems::RemoteSystemWatcher>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RemoteSystemWatcher[] = {
        { "start", reinterpret_cast<PyCFunction>(RemoteSystemWatcher_Start), METH_VARARGS, nullptr },
        { "stop", reinterpret_cast<PyCFunction>(RemoteSystemWatcher_Stop), METH_VARARGS, nullptr },
        { "add_remote_system_added", reinterpret_cast<PyCFunction>(RemoteSystemWatcher_add_RemoteSystemAdded), METH_O, nullptr },
        { "remove_remote_system_added", reinterpret_cast<PyCFunction>(RemoteSystemWatcher_remove_RemoteSystemAdded), METH_O, nullptr },
        { "add_remote_system_removed", reinterpret_cast<PyCFunction>(RemoteSystemWatcher_add_RemoteSystemRemoved), METH_O, nullptr },
        { "remove_remote_system_removed", reinterpret_cast<PyCFunction>(RemoteSystemWatcher_remove_RemoteSystemRemoved), METH_O, nullptr },
        { "add_remote_system_updated", reinterpret_cast<PyCFunction>(RemoteSystemWatcher_add_RemoteSystemUpdated), METH_O, nullptr },
        { "remove_remote_system_updated", reinterpret_cast<PyCFunction>(RemoteSystemWatcher_remove_RemoteSystemUpdated), METH_O, nullptr },
        { "add_enumeration_completed", reinterpret_cast<PyCFunction>(RemoteSystemWatcher_add_EnumerationCompleted), METH_O, nullptr },
        { "remove_enumeration_completed", reinterpret_cast<PyCFunction>(RemoteSystemWatcher_remove_EnumerationCompleted), METH_O, nullptr },
        { "add_error_occurred", reinterpret_cast<PyCFunction>(RemoteSystemWatcher_add_ErrorOccurred), METH_O, nullptr },
        { "remove_error_occurred", reinterpret_cast<PyCFunction>(RemoteSystemWatcher_remove_ErrorOccurred), METH_O, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_RemoteSystemWatcher), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RemoteSystemWatcher[] = {
        { "user", reinterpret_cast<getter>(RemoteSystemWatcher_get_User), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_RemoteSystemWatcher[] = 
    {
        { Py_tp_new, _new_RemoteSystemWatcher },
        { Py_tp_dealloc, _dealloc_RemoteSystemWatcher },
        { Py_tp_methods, _methods_RemoteSystemWatcher },
        { Py_tp_getset, _getset_RemoteSystemWatcher },
        { },
    };

    static PyType_Spec _type_spec_RemoteSystemWatcher =
    {
        "_winsdk_Windows_System_RemoteSystems.RemoteSystemWatcher",
        sizeof(py::wrapper::Windows::System::RemoteSystems::RemoteSystemWatcher),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RemoteSystemWatcher
    };

    // ----- RemoteSystemWatcherErrorOccurredEventArgs class --------------------
    constexpr const char* const _type_name_RemoteSystemWatcherErrorOccurredEventArgs = "RemoteSystemWatcherErrorOccurredEventArgs";

    static PyObject* _new_RemoteSystemWatcherErrorOccurredEventArgs(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
    {
        py::set_invalid_activation_error(_type_name_RemoteSystemWatcherErrorOccurredEventArgs);
        return nullptr;
    }

    static void _dealloc_RemoteSystemWatcherErrorOccurredEventArgs(py::wrapper::Windows::System::RemoteSystems::RemoteSystemWatcherErrorOccurredEventArgs* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* RemoteSystemWatcherErrorOccurredEventArgs_get_Error(py::wrapper::Windows::System::RemoteSystems::RemoteSystemWatcherErrorOccurredEventArgs* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Error());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_RemoteSystemWatcherErrorOccurredEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::System::RemoteSystems::RemoteSystemWatcherErrorOccurredEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RemoteSystemWatcherErrorOccurredEventArgs[] = {
        { "_from", reinterpret_cast<PyCFunction>(_from_RemoteSystemWatcherErrorOccurredEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RemoteSystemWatcherErrorOccurredEventArgs[] = {
        { "error", reinterpret_cast<getter>(RemoteSystemWatcherErrorOccurredEventArgs_get_Error), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_RemoteSystemWatcherErrorOccurredEventArgs[] = 
    {
        { Py_tp_new, _new_RemoteSystemWatcherErrorOccurredEventArgs },
        { Py_tp_dealloc, _dealloc_RemoteSystemWatcherErrorOccurredEventArgs },
        { Py_tp_methods, _methods_RemoteSystemWatcherErrorOccurredEventArgs },
        { Py_tp_getset, _getset_RemoteSystemWatcherErrorOccurredEventArgs },
        { },
    };

    static PyType_Spec _type_spec_RemoteSystemWatcherErrorOccurredEventArgs =
    {
        "_winsdk_Windows_System_RemoteSystems.RemoteSystemWatcherErrorOccurredEventArgs",
        sizeof(py::wrapper::Windows::System::RemoteSystems::RemoteSystemWatcherErrorOccurredEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RemoteSystemWatcherErrorOccurredEventArgs
    };

    // ----- RemoteSystemWebAccountFilter class --------------------
    constexpr const char* const _type_name_RemoteSystemWebAccountFilter = "RemoteSystemWebAccountFilter";

    static PyObject* _new_RemoteSystemWebAccountFilter(PyTypeObject* type, PyObject* args, PyObject* kwds) noexcept
    {
        if (kwds != nullptr)
        {
            py::set_invalid_kwd_args_error();
            return nullptr;
        }

        Py_ssize_t arg_count = PyTuple_Size(args);
        if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Security::Credentials::WebAccount>(args, 0);

                winrt::Windows::System::RemoteSystems::RemoteSystemWebAccountFilter instance{ param0 };
                return py::wrap(instance, type);
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static void _dealloc_RemoteSystemWebAccountFilter(py::wrapper::Windows::System::RemoteSystems::RemoteSystemWebAccountFilter* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* RemoteSystemWebAccountFilter_get_Account(py::wrapper::Windows::System::RemoteSystems::RemoteSystemWebAccountFilter* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Account());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_RemoteSystemWebAccountFilter(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::System::RemoteSystems::RemoteSystemWebAccountFilter>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RemoteSystemWebAccountFilter[] = {
        { "_from", reinterpret_cast<PyCFunction>(_from_RemoteSystemWebAccountFilter), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RemoteSystemWebAccountFilter[] = {
        { "account", reinterpret_cast<getter>(RemoteSystemWebAccountFilter_get_Account), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_RemoteSystemWebAccountFilter[] = 
    {
        { Py_tp_new, _new_RemoteSystemWebAccountFilter },
        { Py_tp_dealloc, _dealloc_RemoteSystemWebAccountFilter },
        { Py_tp_methods, _methods_RemoteSystemWebAccountFilter },
        { Py_tp_getset, _getset_RemoteSystemWebAccountFilter },
        { },
    };

    static PyType_Spec _type_spec_RemoteSystemWebAccountFilter =
    {
        "_winsdk_Windows_System_RemoteSystems.RemoteSystemWebAccountFilter",
        sizeof(py::wrapper::Windows::System::RemoteSystems::RemoteSystemWebAccountFilter),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RemoteSystemWebAccountFilter
    };

    // ----- IRemoteSystemFilter interface --------------------
    constexpr const char* const _type_name_IRemoteSystemFilter = "IRemoteSystemFilter";

    static PyObject* _new_IRemoteSystemFilter(PyTypeObject* /* unused */, PyObject* /* unused */, PyObject* /* unused */)
    {
        py::set_invalid_activation_error(_type_name_IRemoteSystemFilter);
        return nullptr;
    }

    static void _dealloc_IRemoteSystemFilter(py::wrapper::Windows::System::RemoteSystems::IRemoteSystemFilter* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* _from_IRemoteSystemFilter(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto return_value = py::convert_to<winrt::Windows::Foundation::IInspectable>(arg);
            return py::convert(return_value.as<winrt::Windows::System::RemoteSystems::IRemoteSystemFilter>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_IRemoteSystemFilter[] = {
        { "_from", reinterpret_cast<PyCFunction>(_from_IRemoteSystemFilter), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_IRemoteSystemFilter[] = {
        { }
    };

    static PyType_Slot _type_slots_IRemoteSystemFilter[] = 
    {
        { Py_tp_new, _new_IRemoteSystemFilter },
        { Py_tp_dealloc, _dealloc_IRemoteSystemFilter },
        { Py_tp_methods, _methods_IRemoteSystemFilter },
        { Py_tp_getset, _getset_IRemoteSystemFilter },
        { },
    };

    static PyType_Spec _type_spec_IRemoteSystemFilter =
    {
        "_winsdk_Windows_System_RemoteSystems.IRemoteSystemFilter",
        sizeof(py::wrapper::Windows::System::RemoteSystems::IRemoteSystemFilter),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_IRemoteSystemFilter
    };

    // ----- Windows.System.RemoteSystems Initialization --------------------
    static int module_exec(PyObject* module) noexcept
    {
        try
        {
            py::pyobj_handle bases { PyTuple_Pack(1, py::winrt_type<py::Object>::python_type) };

            py::winrt_type<winrt::Windows::System::RemoteSystems::KnownRemoteSystemCapabilities>::python_type = py::register_python_type(module, _type_name_KnownRemoteSystemCapabilities, &_type_spec_KnownRemoteSystemCapabilities, nullptr);
            py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystem>::python_type = py::register_python_type(module, _type_name_RemoteSystem, &_type_spec_RemoteSystem, bases.get());
            py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemAddedEventArgs>::python_type = py::register_python_type(module, _type_name_RemoteSystemAddedEventArgs, &_type_spec_RemoteSystemAddedEventArgs, bases.get());
            py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemApp>::python_type = py::register_python_type(module, _type_name_RemoteSystemApp, &_type_spec_RemoteSystemApp, bases.get());
            py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemAppRegistration>::python_type = py::register_python_type(module, _type_name_RemoteSystemAppRegistration, &_type_spec_RemoteSystemAppRegistration, bases.get());
            py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemAuthorizationKindFilter>::python_type = py::register_python_type(module, _type_name_RemoteSystemAuthorizationKindFilter, &_type_spec_RemoteSystemAuthorizationKindFilter, bases.get());
            py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemConnectionInfo>::python_type = py::register_python_type(module, _type_name_RemoteSystemConnectionInfo, &_type_spec_RemoteSystemConnectionInfo, bases.get());
            py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemConnectionRequest>::python_type = py::register_python_type(module, _type_name_RemoteSystemConnectionRequest, &_type_spec_RemoteSystemConnectionRequest, bases.get());
            py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemDiscoveryTypeFilter>::python_type = py::register_python_type(module, _type_name_RemoteSystemDiscoveryTypeFilter, &_type_spec_RemoteSystemDiscoveryTypeFilter, bases.get());
            py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemEnumerationCompletedEventArgs>::python_type = py::register_python_type(module, _type_name_RemoteSystemEnumerationCompletedEventArgs, &_type_spec_RemoteSystemEnumerationCompletedEventArgs, bases.get());
            py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemKindFilter>::python_type = py::register_python_type(module, _type_name_RemoteSystemKindFilter, &_type_spec_RemoteSystemKindFilter, bases.get());
            py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemKinds>::python_type = py::register_python_type(module, _type_name_RemoteSystemKinds, &_type_spec_RemoteSystemKinds, nullptr);
            py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemRemovedEventArgs>::python_type = py::register_python_type(module, _type_name_RemoteSystemRemovedEventArgs, &_type_spec_RemoteSystemRemovedEventArgs, bases.get());
            py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemSession>::python_type = py::register_python_type(module, _type_name_RemoteSystemSession, &_type_spec_RemoteSystemSession, bases.get());
            py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemSessionAddedEventArgs>::python_type = py::register_python_type(module, _type_name_RemoteSystemSessionAddedEventArgs, &_type_spec_RemoteSystemSessionAddedEventArgs, bases.get());
            py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemSessionController>::python_type = py::register_python_type(module, _type_name_RemoteSystemSessionController, &_type_spec_RemoteSystemSessionController, bases.get());
            py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemSessionCreationResult>::python_type = py::register_python_type(module, _type_name_RemoteSystemSessionCreationResult, &_type_spec_RemoteSystemSessionCreationResult, bases.get());
            py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemSessionDisconnectedEventArgs>::python_type = py::register_python_type(module, _type_name_RemoteSystemSessionDisconnectedEventArgs, &_type_spec_RemoteSystemSessionDisconnectedEventArgs, bases.get());
            py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemSessionInfo>::python_type = py::register_python_type(module, _type_name_RemoteSystemSessionInfo, &_type_spec_RemoteSystemSessionInfo, bases.get());
            py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemSessionInvitation>::python_type = py::register_python_type(module, _type_name_RemoteSystemSessionInvitation, &_type_spec_RemoteSystemSessionInvitation, bases.get());
            py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemSessionInvitationListener>::python_type = py::register_python_type(module, _type_name_RemoteSystemSessionInvitationListener, &_type_spec_RemoteSystemSessionInvitationListener, bases.get());
            py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemSessionInvitationReceivedEventArgs>::python_type = py::register_python_type(module, _type_name_RemoteSystemSessionInvitationReceivedEventArgs, &_type_spec_RemoteSystemSessionInvitationReceivedEventArgs, bases.get());
            py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemSessionJoinRequest>::python_type = py::register_python_type(module, _type_name_RemoteSystemSessionJoinRequest, &_type_spec_RemoteSystemSessionJoinRequest, bases.get());
            py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemSessionJoinRequestedEventArgs>::python_type = py::register_python_type(module, _type_name_RemoteSystemSessionJoinRequestedEventArgs, &_type_spec_RemoteSystemSessionJoinRequestedEventArgs, bases.get());
            py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemSessionJoinResult>::python_type = py::register_python_type(module, _type_name_RemoteSystemSessionJoinResult, &_type_spec_RemoteSystemSessionJoinResult, bases.get());
            py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemSessionMessageChannel>::python_type = py::register_python_type(module, _type_name_RemoteSystemSessionMessageChannel, &_type_spec_RemoteSystemSessionMessageChannel, bases.get());
            py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemSessionOptions>::python_type = py::register_python_type(module, _type_name_RemoteSystemSessionOptions, &_type_spec_RemoteSystemSessionOptions, bases.get());
            py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemSessionParticipant>::python_type = py::register_python_type(module, _type_name_RemoteSystemSessionParticipant, &_type_spec_RemoteSystemSessionParticipant, bases.get());
            py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemSessionParticipantAddedEventArgs>::python_type = py::register_python_type(module, _type_name_RemoteSystemSessionParticipantAddedEventArgs, &_type_spec_RemoteSystemSessionParticipantAddedEventArgs, bases.get());
            py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemSessionParticipantRemovedEventArgs>::python_type = py::register_python_type(module, _type_name_RemoteSystemSessionParticipantRemovedEventArgs, &_type_spec_RemoteSystemSessionParticipantRemovedEventArgs, bases.get());
            py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemSessionParticipantWatcher>::python_type = py::register_python_type(module, _type_name_RemoteSystemSessionParticipantWatcher, &_type_spec_RemoteSystemSessionParticipantWatcher, bases.get());
            py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemSessionRemovedEventArgs>::python_type = py::register_python_type(module, _type_name_RemoteSystemSessionRemovedEventArgs, &_type_spec_RemoteSystemSessionRemovedEventArgs, bases.get());
            py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemSessionUpdatedEventArgs>::python_type = py::register_python_type(module, _type_name_RemoteSystemSessionUpdatedEventArgs, &_type_spec_RemoteSystemSessionUpdatedEventArgs, bases.get());
            py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemSessionValueSetReceivedEventArgs>::python_type = py::register_python_type(module, _type_name_RemoteSystemSessionValueSetReceivedEventArgs, &_type_spec_RemoteSystemSessionValueSetReceivedEventArgs, bases.get());
            py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemSessionWatcher>::python_type = py::register_python_type(module, _type_name_RemoteSystemSessionWatcher, &_type_spec_RemoteSystemSessionWatcher, bases.get());
            py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemStatusTypeFilter>::python_type = py::register_python_type(module, _type_name_RemoteSystemStatusTypeFilter, &_type_spec_RemoteSystemStatusTypeFilter, bases.get());
            py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemUpdatedEventArgs>::python_type = py::register_python_type(module, _type_name_RemoteSystemUpdatedEventArgs, &_type_spec_RemoteSystemUpdatedEventArgs, bases.get());
            py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemWatcher>::python_type = py::register_python_type(module, _type_name_RemoteSystemWatcher, &_type_spec_RemoteSystemWatcher, bases.get());
            py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemWatcherErrorOccurredEventArgs>::python_type = py::register_python_type(module, _type_name_RemoteSystemWatcherErrorOccurredEventArgs, &_type_spec_RemoteSystemWatcherErrorOccurredEventArgs, bases.get());
            py::winrt_type<winrt::Windows::System::RemoteSystems::RemoteSystemWebAccountFilter>::python_type = py::register_python_type(module, _type_name_RemoteSystemWebAccountFilter, &_type_spec_RemoteSystemWebAccountFilter, bases.get());
            py::winrt_type<winrt::Windows::System::RemoteSystems::IRemoteSystemFilter>::python_type = py::register_python_type(module, _type_name_IRemoteSystemFilter, &_type_spec_IRemoteSystemFilter, bases.get());

            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyModuleDef_Slot module_slots[] = {{Py_mod_exec, module_exec}, {}};

    PyDoc_STRVAR(module_doc, "Windows.System.RemoteSystems");

    static PyModuleDef module_def
        = {PyModuleDef_HEAD_INIT,
           "_winsdk_Windows_System_RemoteSystems",
           module_doc,
           0,
           nullptr,
           module_slots,
           nullptr,
           nullptr,
           nullptr};
} // py::cpp::Windows::System::RemoteSystems

PyMODINIT_FUNC
PyInit__winsdk_Windows_System_RemoteSystems (void) noexcept
{
    return PyModuleDef_Init(&py::cpp::Windows::System::RemoteSystems::module_def);
}
