// 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.Profile.h"

PyTypeObject* py::winrt_type<winrt::Windows::System::Profile::AnalyticsInfo>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::System::Profile::AnalyticsVersionInfo>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::System::Profile::AppApplicability>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::System::Profile::EducationSettings>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::System::Profile::HardwareIdentification>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::System::Profile::HardwareToken>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::System::Profile::KnownRetailInfoProperties>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::System::Profile::PlatformDiagnosticsAndUsageDataSettings>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::System::Profile::RetailInfo>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::System::Profile::SharedModeSettings>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::System::Profile::SystemIdentification>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::System::Profile::SystemIdentificationInfo>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::System::Profile::SystemSetupInfo>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::System::Profile::UnsupportedAppRequirement>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::System::Profile::WindowsIntegrityPolicy>::python_type;

namespace py::cpp::Windows::System::Profile
{
    // ----- AnalyticsInfo class --------------------
    constexpr const char* const _type_name_AnalyticsInfo = "AnalyticsInfo";

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

    static PyObject* AnalyticsInfo_GetSystemPropertiesAsync(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::Foundation::Collections::IIterable<winrt::hstring>>(args, 0);

                return py::convert(winrt::Windows::System::Profile::AnalyticsInfo::GetSystemPropertiesAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* AnalyticsInfo_get_DeviceForm(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(winrt::Windows::System::Profile::AnalyticsInfo::DeviceForm());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* AnalyticsInfo_get_VersionInfo(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(winrt::Windows::System::Profile::AnalyticsInfo::VersionInfo());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_AnalyticsInfo[] = {
        { "get_system_properties_async", reinterpret_cast<PyCFunction>(AnalyticsInfo_GetSystemPropertiesAsync), METH_VARARGS | METH_STATIC, nullptr },
        { "get_device_form", reinterpret_cast<PyCFunction>(AnalyticsInfo_get_DeviceForm), METH_NOARGS | METH_STATIC, nullptr },
        { "get_version_info", reinterpret_cast<PyCFunction>(AnalyticsInfo_get_VersionInfo), METH_NOARGS | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_AnalyticsInfo[] = {
        { }
    };

    static PyType_Slot _type_slots_AnalyticsInfo[] = 
    {
        { Py_tp_new, _new_AnalyticsInfo },
        { Py_tp_methods, _methods_AnalyticsInfo },
        { Py_tp_getset, _getset_AnalyticsInfo },
        { },
    };

    static PyType_Spec _type_spec_AnalyticsInfo =
    {
        "_winsdk_Windows_System_Profile.AnalyticsInfo",
        0,
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_AnalyticsInfo
    };

    // ----- AnalyticsVersionInfo class --------------------
    constexpr const char* const _type_name_AnalyticsVersionInfo = "AnalyticsVersionInfo";

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

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

    static PyObject* AnalyticsVersionInfo_get_DeviceFamily(py::wrapper::Windows::System::Profile::AnalyticsVersionInfo* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.DeviceFamily());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* AnalyticsVersionInfo_get_DeviceFamilyVersion(py::wrapper::Windows::System::Profile::AnalyticsVersionInfo* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.DeviceFamilyVersion());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* AnalyticsVersionInfo_get_ProductName(py::wrapper::Windows::System::Profile::AnalyticsVersionInfo* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ProductName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_AnalyticsVersionInfo(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::Profile::AnalyticsVersionInfo>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

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

    static PyGetSetDef _getset_AnalyticsVersionInfo[] = {
        { "device_family", reinterpret_cast<getter>(AnalyticsVersionInfo_get_DeviceFamily), nullptr, nullptr, nullptr },
        { "device_family_version", reinterpret_cast<getter>(AnalyticsVersionInfo_get_DeviceFamilyVersion), nullptr, nullptr, nullptr },
        { "product_name", reinterpret_cast<getter>(AnalyticsVersionInfo_get_ProductName), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_AnalyticsVersionInfo[] = 
    {
        { Py_tp_new, _new_AnalyticsVersionInfo },
        { Py_tp_dealloc, _dealloc_AnalyticsVersionInfo },
        { Py_tp_methods, _methods_AnalyticsVersionInfo },
        { Py_tp_getset, _getset_AnalyticsVersionInfo },
        { },
    };

    static PyType_Spec _type_spec_AnalyticsVersionInfo =
    {
        "_winsdk_Windows_System_Profile.AnalyticsVersionInfo",
        sizeof(py::wrapper::Windows::System::Profile::AnalyticsVersionInfo),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_AnalyticsVersionInfo
    };

    // ----- AppApplicability class --------------------
    constexpr const char* const _type_name_AppApplicability = "AppApplicability";

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

    static PyObject* AppApplicability_GetUnsupportedAppRequirements(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::Foundation::Collections::IIterable<winrt::hstring>>(args, 0);

                return py::convert(winrt::Windows::System::Profile::AppApplicability::GetUnsupportedAppRequirements(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyMethodDef _methods_AppApplicability[] = {
        { "get_unsupported_app_requirements", reinterpret_cast<PyCFunction>(AppApplicability_GetUnsupportedAppRequirements), METH_VARARGS | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_AppApplicability[] = {
        { }
    };

    static PyType_Slot _type_slots_AppApplicability[] = 
    {
        { Py_tp_new, _new_AppApplicability },
        { Py_tp_methods, _methods_AppApplicability },
        { Py_tp_getset, _getset_AppApplicability },
        { },
    };

    static PyType_Spec _type_spec_AppApplicability =
    {
        "_winsdk_Windows_System_Profile.AppApplicability",
        0,
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_AppApplicability
    };

    // ----- EducationSettings class --------------------
    constexpr const char* const _type_name_EducationSettings = "EducationSettings";

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

    static PyObject* EducationSettings_get_IsEducationEnvironment(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(winrt::Windows::System::Profile::EducationSettings::IsEducationEnvironment());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_EducationSettings[] = {
        { "get_is_education_environment", reinterpret_cast<PyCFunction>(EducationSettings_get_IsEducationEnvironment), METH_NOARGS | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_EducationSettings[] = {
        { }
    };

    static PyType_Slot _type_slots_EducationSettings[] = 
    {
        { Py_tp_new, _new_EducationSettings },
        { Py_tp_methods, _methods_EducationSettings },
        { Py_tp_getset, _getset_EducationSettings },
        { },
    };

    static PyType_Spec _type_spec_EducationSettings =
    {
        "_winsdk_Windows_System_Profile.EducationSettings",
        0,
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_EducationSettings
    };

    // ----- HardwareIdentification class --------------------
    constexpr const char* const _type_name_HardwareIdentification = "HardwareIdentification";

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

    static PyObject* HardwareIdentification_GetPackageSpecificToken(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::Storage::Streams::IBuffer>(args, 0);

                return py::convert(winrt::Windows::System::Profile::HardwareIdentification::GetPackageSpecificToken(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyMethodDef _methods_HardwareIdentification[] = {
        { "get_package_specific_token", reinterpret_cast<PyCFunction>(HardwareIdentification_GetPackageSpecificToken), METH_VARARGS | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_HardwareIdentification[] = {
        { }
    };

    static PyType_Slot _type_slots_HardwareIdentification[] = 
    {
        { Py_tp_new, _new_HardwareIdentification },
        { Py_tp_methods, _methods_HardwareIdentification },
        { Py_tp_getset, _getset_HardwareIdentification },
        { },
    };

    static PyType_Spec _type_spec_HardwareIdentification =
    {
        "_winsdk_Windows_System_Profile.HardwareIdentification",
        0,
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_HardwareIdentification
    };

    // ----- HardwareToken class --------------------
    constexpr const char* const _type_name_HardwareToken = "HardwareToken";

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

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

    static PyObject* HardwareToken_get_Certificate(py::wrapper::Windows::System::Profile::HardwareToken* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Certificate());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

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

    static PyObject* HardwareToken_get_Signature(py::wrapper::Windows::System::Profile::HardwareToken* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Signature());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_HardwareToken(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::Profile::HardwareToken>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

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

    static PyGetSetDef _getset_HardwareToken[] = {
        { "certificate", reinterpret_cast<getter>(HardwareToken_get_Certificate), nullptr, nullptr, nullptr },
        { "id", reinterpret_cast<getter>(HardwareToken_get_Id), nullptr, nullptr, nullptr },
        { "signature", reinterpret_cast<getter>(HardwareToken_get_Signature), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_HardwareToken[] = 
    {
        { Py_tp_new, _new_HardwareToken },
        { Py_tp_dealloc, _dealloc_HardwareToken },
        { Py_tp_methods, _methods_HardwareToken },
        { Py_tp_getset, _getset_HardwareToken },
        { },
    };

    static PyType_Spec _type_spec_HardwareToken =
    {
        "_winsdk_Windows_System_Profile.HardwareToken",
        sizeof(py::wrapper::Windows::System::Profile::HardwareToken),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_HardwareToken
    };

    // ----- KnownRetailInfoProperties class --------------------
    constexpr const char* const _type_name_KnownRetailInfoProperties = "KnownRetailInfoProperties";

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

    static PyObject* KnownRetailInfoProperties_get_BatteryLifeDescription(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(winrt::Windows::System::Profile::KnownRetailInfoProperties::BatteryLifeDescription());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* KnownRetailInfoProperties_get_DisplayDescription(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(winrt::Windows::System::Profile::KnownRetailInfoProperties::DisplayDescription());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* KnownRetailInfoProperties_get_DisplayModelName(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(winrt::Windows::System::Profile::KnownRetailInfoProperties::DisplayModelName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* KnownRetailInfoProperties_get_FormFactor(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(winrt::Windows::System::Profile::KnownRetailInfoProperties::FormFactor());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* KnownRetailInfoProperties_get_FrontCameraDescription(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(winrt::Windows::System::Profile::KnownRetailInfoProperties::FrontCameraDescription());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* KnownRetailInfoProperties_get_GraphicsDescription(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(winrt::Windows::System::Profile::KnownRetailInfoProperties::GraphicsDescription());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* KnownRetailInfoProperties_get_HasNfc(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(winrt::Windows::System::Profile::KnownRetailInfoProperties::HasNfc());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* KnownRetailInfoProperties_get_HasOpticalDrive(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(winrt::Windows::System::Profile::KnownRetailInfoProperties::HasOpticalDrive());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* KnownRetailInfoProperties_get_HasSdSlot(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(winrt::Windows::System::Profile::KnownRetailInfoProperties::HasSdSlot());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* KnownRetailInfoProperties_get_IsFeatured(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(winrt::Windows::System::Profile::KnownRetailInfoProperties::IsFeatured());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* KnownRetailInfoProperties_get_IsOfficeInstalled(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(winrt::Windows::System::Profile::KnownRetailInfoProperties::IsOfficeInstalled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* KnownRetailInfoProperties_get_ManufacturerName(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(winrt::Windows::System::Profile::KnownRetailInfoProperties::ManufacturerName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* KnownRetailInfoProperties_get_Memory(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(winrt::Windows::System::Profile::KnownRetailInfoProperties::Memory());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* KnownRetailInfoProperties_get_ModelName(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(winrt::Windows::System::Profile::KnownRetailInfoProperties::ModelName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* KnownRetailInfoProperties_get_Price(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(winrt::Windows::System::Profile::KnownRetailInfoProperties::Price());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* KnownRetailInfoProperties_get_ProcessorDescription(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(winrt::Windows::System::Profile::KnownRetailInfoProperties::ProcessorDescription());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* KnownRetailInfoProperties_get_RearCameraDescription(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(winrt::Windows::System::Profile::KnownRetailInfoProperties::RearCameraDescription());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* KnownRetailInfoProperties_get_RetailAccessCode(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(winrt::Windows::System::Profile::KnownRetailInfoProperties::RetailAccessCode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* KnownRetailInfoProperties_get_ScreenSize(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(winrt::Windows::System::Profile::KnownRetailInfoProperties::ScreenSize());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* KnownRetailInfoProperties_get_StorageDescription(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(winrt::Windows::System::Profile::KnownRetailInfoProperties::StorageDescription());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* KnownRetailInfoProperties_get_Weight(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(winrt::Windows::System::Profile::KnownRetailInfoProperties::Weight());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* KnownRetailInfoProperties_get_WindowsEdition(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(winrt::Windows::System::Profile::KnownRetailInfoProperties::WindowsEdition());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_KnownRetailInfoProperties[] = {
        { "get_battery_life_description", reinterpret_cast<PyCFunction>(KnownRetailInfoProperties_get_BatteryLifeDescription), METH_NOARGS | METH_STATIC, nullptr },
        { "get_display_description", reinterpret_cast<PyCFunction>(KnownRetailInfoProperties_get_DisplayDescription), METH_NOARGS | METH_STATIC, nullptr },
        { "get_display_model_name", reinterpret_cast<PyCFunction>(KnownRetailInfoProperties_get_DisplayModelName), METH_NOARGS | METH_STATIC, nullptr },
        { "get_form_factor", reinterpret_cast<PyCFunction>(KnownRetailInfoProperties_get_FormFactor), METH_NOARGS | METH_STATIC, nullptr },
        { "get_front_camera_description", reinterpret_cast<PyCFunction>(KnownRetailInfoProperties_get_FrontCameraDescription), METH_NOARGS | METH_STATIC, nullptr },
        { "get_graphics_description", reinterpret_cast<PyCFunction>(KnownRetailInfoProperties_get_GraphicsDescription), METH_NOARGS | METH_STATIC, nullptr },
        { "get_has_nfc", reinterpret_cast<PyCFunction>(KnownRetailInfoProperties_get_HasNfc), METH_NOARGS | METH_STATIC, nullptr },
        { "get_has_optical_drive", reinterpret_cast<PyCFunction>(KnownRetailInfoProperties_get_HasOpticalDrive), METH_NOARGS | METH_STATIC, nullptr },
        { "get_has_sd_slot", reinterpret_cast<PyCFunction>(KnownRetailInfoProperties_get_HasSdSlot), METH_NOARGS | METH_STATIC, nullptr },
        { "get_is_featured", reinterpret_cast<PyCFunction>(KnownRetailInfoProperties_get_IsFeatured), METH_NOARGS | METH_STATIC, nullptr },
        { "get_is_office_installed", reinterpret_cast<PyCFunction>(KnownRetailInfoProperties_get_IsOfficeInstalled), METH_NOARGS | METH_STATIC, nullptr },
        { "get_manufacturer_name", reinterpret_cast<PyCFunction>(KnownRetailInfoProperties_get_ManufacturerName), METH_NOARGS | METH_STATIC, nullptr },
        { "get_memory", reinterpret_cast<PyCFunction>(KnownRetailInfoProperties_get_Memory), METH_NOARGS | METH_STATIC, nullptr },
        { "get_model_name", reinterpret_cast<PyCFunction>(KnownRetailInfoProperties_get_ModelName), METH_NOARGS | METH_STATIC, nullptr },
        { "get_price", reinterpret_cast<PyCFunction>(KnownRetailInfoProperties_get_Price), METH_NOARGS | METH_STATIC, nullptr },
        { "get_processor_description", reinterpret_cast<PyCFunction>(KnownRetailInfoProperties_get_ProcessorDescription), METH_NOARGS | METH_STATIC, nullptr },
        { "get_rear_camera_description", reinterpret_cast<PyCFunction>(KnownRetailInfoProperties_get_RearCameraDescription), METH_NOARGS | METH_STATIC, nullptr },
        { "get_retail_access_code", reinterpret_cast<PyCFunction>(KnownRetailInfoProperties_get_RetailAccessCode), METH_NOARGS | METH_STATIC, nullptr },
        { "get_screen_size", reinterpret_cast<PyCFunction>(KnownRetailInfoProperties_get_ScreenSize), METH_NOARGS | METH_STATIC, nullptr },
        { "get_storage_description", reinterpret_cast<PyCFunction>(KnownRetailInfoProperties_get_StorageDescription), METH_NOARGS | METH_STATIC, nullptr },
        { "get_weight", reinterpret_cast<PyCFunction>(KnownRetailInfoProperties_get_Weight), METH_NOARGS | METH_STATIC, nullptr },
        { "get_windows_edition", reinterpret_cast<PyCFunction>(KnownRetailInfoProperties_get_WindowsEdition), METH_NOARGS | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_KnownRetailInfoProperties[] = {
        { }
    };

    static PyType_Slot _type_slots_KnownRetailInfoProperties[] = 
    {
        { Py_tp_new, _new_KnownRetailInfoProperties },
        { Py_tp_methods, _methods_KnownRetailInfoProperties },
        { Py_tp_getset, _getset_KnownRetailInfoProperties },
        { },
    };

    static PyType_Spec _type_spec_KnownRetailInfoProperties =
    {
        "_winsdk_Windows_System_Profile.KnownRetailInfoProperties",
        0,
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_KnownRetailInfoProperties
    };

    // ----- PlatformDiagnosticsAndUsageDataSettings class --------------------
    constexpr const char* const _type_name_PlatformDiagnosticsAndUsageDataSettings = "PlatformDiagnosticsAndUsageDataSettings";

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

    static PyObject* PlatformDiagnosticsAndUsageDataSettings_CanCollectDiagnostics(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::Profile::PlatformDataCollectionLevel>(args, 0);

                return py::convert(winrt::Windows::System::Profile::PlatformDiagnosticsAndUsageDataSettings::CanCollectDiagnostics(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* PlatformDiagnosticsAndUsageDataSettings_get_CollectionLevel(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(winrt::Windows::System::Profile::PlatformDiagnosticsAndUsageDataSettings::CollectionLevel());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PlatformDiagnosticsAndUsageDataSettings_add_CollectionLevelChanged(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::EventHandler<winrt::Windows::Foundation::IInspectable>>(arg);

            return py::convert(winrt::Windows::System::Profile::PlatformDiagnosticsAndUsageDataSettings::CollectionLevelChanged(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PlatformDiagnosticsAndUsageDataSettings_remove_CollectionLevelChanged(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            winrt::Windows::System::Profile::PlatformDiagnosticsAndUsageDataSettings::CollectionLevelChanged(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_PlatformDiagnosticsAndUsageDataSettings[] = {
        { "can_collect_diagnostics", reinterpret_cast<PyCFunction>(PlatformDiagnosticsAndUsageDataSettings_CanCollectDiagnostics), METH_VARARGS | METH_STATIC, nullptr },
        { "get_collection_level", reinterpret_cast<PyCFunction>(PlatformDiagnosticsAndUsageDataSettings_get_CollectionLevel), METH_NOARGS | METH_STATIC, nullptr },
        { "add_collection_level_changed", reinterpret_cast<PyCFunction>(PlatformDiagnosticsAndUsageDataSettings_add_CollectionLevelChanged), METH_O | METH_STATIC, nullptr },
        { "remove_collection_level_changed", reinterpret_cast<PyCFunction>(PlatformDiagnosticsAndUsageDataSettings_remove_CollectionLevelChanged), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_PlatformDiagnosticsAndUsageDataSettings[] = {
        { }
    };

    static PyType_Slot _type_slots_PlatformDiagnosticsAndUsageDataSettings[] = 
    {
        { Py_tp_new, _new_PlatformDiagnosticsAndUsageDataSettings },
        { Py_tp_methods, _methods_PlatformDiagnosticsAndUsageDataSettings },
        { Py_tp_getset, _getset_PlatformDiagnosticsAndUsageDataSettings },
        { },
    };

    static PyType_Spec _type_spec_PlatformDiagnosticsAndUsageDataSettings =
    {
        "_winsdk_Windows_System_Profile.PlatformDiagnosticsAndUsageDataSettings",
        0,
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_PlatformDiagnosticsAndUsageDataSettings
    };

    // ----- RetailInfo class --------------------
    constexpr const char* const _type_name_RetailInfo = "RetailInfo";

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

    static PyObject* RetailInfo_get_IsDemoModeEnabled(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(winrt::Windows::System::Profile::RetailInfo::IsDemoModeEnabled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* RetailInfo_get_Properties(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(winrt::Windows::System::Profile::RetailInfo::Properties());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_RetailInfo[] = {
        { "get_is_demo_mode_enabled", reinterpret_cast<PyCFunction>(RetailInfo_get_IsDemoModeEnabled), METH_NOARGS | METH_STATIC, nullptr },
        { "get_properties", reinterpret_cast<PyCFunction>(RetailInfo_get_Properties), METH_NOARGS | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_RetailInfo[] = {
        { }
    };

    static PyType_Slot _type_slots_RetailInfo[] = 
    {
        { Py_tp_new, _new_RetailInfo },
        { Py_tp_methods, _methods_RetailInfo },
        { Py_tp_getset, _getset_RetailInfo },
        { },
    };

    static PyType_Spec _type_spec_RetailInfo =
    {
        "_winsdk_Windows_System_Profile.RetailInfo",
        0,
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_RetailInfo
    };

    // ----- SharedModeSettings class --------------------
    constexpr const char* const _type_name_SharedModeSettings = "SharedModeSettings";

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

    static PyObject* SharedModeSettings_get_IsEnabled(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(winrt::Windows::System::Profile::SharedModeSettings::IsEnabled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SharedModeSettings_get_ShouldAvoidLocalStorage(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(winrt::Windows::System::Profile::SharedModeSettings::ShouldAvoidLocalStorage());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_SharedModeSettings[] = {
        { "get_is_enabled", reinterpret_cast<PyCFunction>(SharedModeSettings_get_IsEnabled), METH_NOARGS | METH_STATIC, nullptr },
        { "get_should_avoid_local_storage", reinterpret_cast<PyCFunction>(SharedModeSettings_get_ShouldAvoidLocalStorage), METH_NOARGS | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_SharedModeSettings[] = {
        { }
    };

    static PyType_Slot _type_slots_SharedModeSettings[] = 
    {
        { Py_tp_new, _new_SharedModeSettings },
        { Py_tp_methods, _methods_SharedModeSettings },
        { Py_tp_getset, _getset_SharedModeSettings },
        { },
    };

    static PyType_Spec _type_spec_SharedModeSettings =
    {
        "_winsdk_Windows_System_Profile.SharedModeSettings",
        0,
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_SharedModeSettings
    };

    // ----- SystemIdentification class --------------------
    constexpr const char* const _type_name_SystemIdentification = "SystemIdentification";

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

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

        if (arg_count == 0)
        {
            try
            {
                return py::convert(winrt::Windows::System::Profile::SystemIdentification::GetSystemIdForPublisher());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* SystemIdentification_GetSystemIdForUser(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::Profile::SystemIdentification::GetSystemIdForUser(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyMethodDef _methods_SystemIdentification[] = {
        { "get_system_id_for_publisher", reinterpret_cast<PyCFunction>(SystemIdentification_GetSystemIdForPublisher), METH_VARARGS | METH_STATIC, nullptr },
        { "get_system_id_for_user", reinterpret_cast<PyCFunction>(SystemIdentification_GetSystemIdForUser), METH_VARARGS | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_SystemIdentification[] = {
        { }
    };

    static PyType_Slot _type_slots_SystemIdentification[] = 
    {
        { Py_tp_new, _new_SystemIdentification },
        { Py_tp_methods, _methods_SystemIdentification },
        { Py_tp_getset, _getset_SystemIdentification },
        { },
    };

    static PyType_Spec _type_spec_SystemIdentification =
    {
        "_winsdk_Windows_System_Profile.SystemIdentification",
        0,
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_SystemIdentification
    };

    // ----- SystemIdentificationInfo class --------------------
    constexpr const char* const _type_name_SystemIdentificationInfo = "SystemIdentificationInfo";

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

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

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

    static PyObject* SystemIdentificationInfo_get_Source(py::wrapper::Windows::System::Profile::SystemIdentificationInfo* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Source());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_SystemIdentificationInfo(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::Profile::SystemIdentificationInfo>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

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

    static PyGetSetDef _getset_SystemIdentificationInfo[] = {
        { "id", reinterpret_cast<getter>(SystemIdentificationInfo_get_Id), nullptr, nullptr, nullptr },
        { "source", reinterpret_cast<getter>(SystemIdentificationInfo_get_Source), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_SystemIdentificationInfo[] = 
    {
        { Py_tp_new, _new_SystemIdentificationInfo },
        { Py_tp_dealloc, _dealloc_SystemIdentificationInfo },
        { Py_tp_methods, _methods_SystemIdentificationInfo },
        { Py_tp_getset, _getset_SystemIdentificationInfo },
        { },
    };

    static PyType_Spec _type_spec_SystemIdentificationInfo =
    {
        "_winsdk_Windows_System_Profile.SystemIdentificationInfo",
        sizeof(py::wrapper::Windows::System::Profile::SystemIdentificationInfo),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_SystemIdentificationInfo
    };

    // ----- SystemSetupInfo class --------------------
    constexpr const char* const _type_name_SystemSetupInfo = "SystemSetupInfo";

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

    static PyObject* SystemSetupInfo_get_OutOfBoxExperienceState(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(winrt::Windows::System::Profile::SystemSetupInfo::OutOfBoxExperienceState());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SystemSetupInfo_add_OutOfBoxExperienceStateChanged(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::EventHandler<winrt::Windows::Foundation::IInspectable>>(arg);

            return py::convert(winrt::Windows::System::Profile::SystemSetupInfo::OutOfBoxExperienceStateChanged(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* SystemSetupInfo_remove_OutOfBoxExperienceStateChanged(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            winrt::Windows::System::Profile::SystemSetupInfo::OutOfBoxExperienceStateChanged(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_SystemSetupInfo[] = {
        { "get_out_of_box_experience_state", reinterpret_cast<PyCFunction>(SystemSetupInfo_get_OutOfBoxExperienceState), METH_NOARGS | METH_STATIC, nullptr },
        { "add_out_of_box_experience_state_changed", reinterpret_cast<PyCFunction>(SystemSetupInfo_add_OutOfBoxExperienceStateChanged), METH_O | METH_STATIC, nullptr },
        { "remove_out_of_box_experience_state_changed", reinterpret_cast<PyCFunction>(SystemSetupInfo_remove_OutOfBoxExperienceStateChanged), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_SystemSetupInfo[] = {
        { }
    };

    static PyType_Slot _type_slots_SystemSetupInfo[] = 
    {
        { Py_tp_new, _new_SystemSetupInfo },
        { Py_tp_methods, _methods_SystemSetupInfo },
        { Py_tp_getset, _getset_SystemSetupInfo },
        { },
    };

    static PyType_Spec _type_spec_SystemSetupInfo =
    {
        "_winsdk_Windows_System_Profile.SystemSetupInfo",
        0,
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_SystemSetupInfo
    };

    // ----- UnsupportedAppRequirement class --------------------
    constexpr const char* const _type_name_UnsupportedAppRequirement = "UnsupportedAppRequirement";

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

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

    static PyObject* UnsupportedAppRequirement_get_Reasons(py::wrapper::Windows::System::Profile::UnsupportedAppRequirement* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Reasons());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* UnsupportedAppRequirement_get_Requirement(py::wrapper::Windows::System::Profile::UnsupportedAppRequirement* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Requirement());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_UnsupportedAppRequirement(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::Profile::UnsupportedAppRequirement>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

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

    static PyGetSetDef _getset_UnsupportedAppRequirement[] = {
        { "reasons", reinterpret_cast<getter>(UnsupportedAppRequirement_get_Reasons), nullptr, nullptr, nullptr },
        { "requirement", reinterpret_cast<getter>(UnsupportedAppRequirement_get_Requirement), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_UnsupportedAppRequirement[] = 
    {
        { Py_tp_new, _new_UnsupportedAppRequirement },
        { Py_tp_dealloc, _dealloc_UnsupportedAppRequirement },
        { Py_tp_methods, _methods_UnsupportedAppRequirement },
        { Py_tp_getset, _getset_UnsupportedAppRequirement },
        { },
    };

    static PyType_Spec _type_spec_UnsupportedAppRequirement =
    {
        "_winsdk_Windows_System_Profile.UnsupportedAppRequirement",
        sizeof(py::wrapper::Windows::System::Profile::UnsupportedAppRequirement),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_UnsupportedAppRequirement
    };

    // ----- WindowsIntegrityPolicy class --------------------
    constexpr const char* const _type_name_WindowsIntegrityPolicy = "WindowsIntegrityPolicy";

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

    static PyObject* WindowsIntegrityPolicy_get_CanDisable(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(winrt::Windows::System::Profile::WindowsIntegrityPolicy::CanDisable());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* WindowsIntegrityPolicy_get_IsDisableSupported(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(winrt::Windows::System::Profile::WindowsIntegrityPolicy::IsDisableSupported());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* WindowsIntegrityPolicy_get_IsEnabled(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(winrt::Windows::System::Profile::WindowsIntegrityPolicy::IsEnabled());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* WindowsIntegrityPolicy_get_IsEnabledForTrial(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(winrt::Windows::System::Profile::WindowsIntegrityPolicy::IsEnabledForTrial());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* WindowsIntegrityPolicy_add_PolicyChanged(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::EventHandler<winrt::Windows::Foundation::IInspectable>>(arg);

            return py::convert(winrt::Windows::System::Profile::WindowsIntegrityPolicy::PolicyChanged(param0));
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* WindowsIntegrityPolicy_remove_PolicyChanged(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

            winrt::Windows::System::Profile::WindowsIntegrityPolicy::PolicyChanged(param0);
            Py_RETURN_NONE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_WindowsIntegrityPolicy[] = {
        { "get_can_disable", reinterpret_cast<PyCFunction>(WindowsIntegrityPolicy_get_CanDisable), METH_NOARGS | METH_STATIC, nullptr },
        { "get_is_disable_supported", reinterpret_cast<PyCFunction>(WindowsIntegrityPolicy_get_IsDisableSupported), METH_NOARGS | METH_STATIC, nullptr },
        { "get_is_enabled", reinterpret_cast<PyCFunction>(WindowsIntegrityPolicy_get_IsEnabled), METH_NOARGS | METH_STATIC, nullptr },
        { "get_is_enabled_for_trial", reinterpret_cast<PyCFunction>(WindowsIntegrityPolicy_get_IsEnabledForTrial), METH_NOARGS | METH_STATIC, nullptr },
        { "add_policy_changed", reinterpret_cast<PyCFunction>(WindowsIntegrityPolicy_add_PolicyChanged), METH_O | METH_STATIC, nullptr },
        { "remove_policy_changed", reinterpret_cast<PyCFunction>(WindowsIntegrityPolicy_remove_PolicyChanged), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_WindowsIntegrityPolicy[] = {
        { }
    };

    static PyType_Slot _type_slots_WindowsIntegrityPolicy[] = 
    {
        { Py_tp_new, _new_WindowsIntegrityPolicy },
        { Py_tp_methods, _methods_WindowsIntegrityPolicy },
        { Py_tp_getset, _getset_WindowsIntegrityPolicy },
        { },
    };

    static PyType_Spec _type_spec_WindowsIntegrityPolicy =
    {
        "_winsdk_Windows_System_Profile.WindowsIntegrityPolicy",
        0,
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_WindowsIntegrityPolicy
    };

    // ----- Windows.System.Profile 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::Profile::AnalyticsInfo>::python_type = py::register_python_type(module, _type_name_AnalyticsInfo, &_type_spec_AnalyticsInfo, nullptr);
            py::winrt_type<winrt::Windows::System::Profile::AnalyticsVersionInfo>::python_type = py::register_python_type(module, _type_name_AnalyticsVersionInfo, &_type_spec_AnalyticsVersionInfo, bases.get());
            py::winrt_type<winrt::Windows::System::Profile::AppApplicability>::python_type = py::register_python_type(module, _type_name_AppApplicability, &_type_spec_AppApplicability, nullptr);
            py::winrt_type<winrt::Windows::System::Profile::EducationSettings>::python_type = py::register_python_type(module, _type_name_EducationSettings, &_type_spec_EducationSettings, nullptr);
            py::winrt_type<winrt::Windows::System::Profile::HardwareIdentification>::python_type = py::register_python_type(module, _type_name_HardwareIdentification, &_type_spec_HardwareIdentification, nullptr);
            py::winrt_type<winrt::Windows::System::Profile::HardwareToken>::python_type = py::register_python_type(module, _type_name_HardwareToken, &_type_spec_HardwareToken, bases.get());
            py::winrt_type<winrt::Windows::System::Profile::KnownRetailInfoProperties>::python_type = py::register_python_type(module, _type_name_KnownRetailInfoProperties, &_type_spec_KnownRetailInfoProperties, nullptr);
            py::winrt_type<winrt::Windows::System::Profile::PlatformDiagnosticsAndUsageDataSettings>::python_type = py::register_python_type(module, _type_name_PlatformDiagnosticsAndUsageDataSettings, &_type_spec_PlatformDiagnosticsAndUsageDataSettings, nullptr);
            py::winrt_type<winrt::Windows::System::Profile::RetailInfo>::python_type = py::register_python_type(module, _type_name_RetailInfo, &_type_spec_RetailInfo, nullptr);
            py::winrt_type<winrt::Windows::System::Profile::SharedModeSettings>::python_type = py::register_python_type(module, _type_name_SharedModeSettings, &_type_spec_SharedModeSettings, nullptr);
            py::winrt_type<winrt::Windows::System::Profile::SystemIdentification>::python_type = py::register_python_type(module, _type_name_SystemIdentification, &_type_spec_SystemIdentification, nullptr);
            py::winrt_type<winrt::Windows::System::Profile::SystemIdentificationInfo>::python_type = py::register_python_type(module, _type_name_SystemIdentificationInfo, &_type_spec_SystemIdentificationInfo, bases.get());
            py::winrt_type<winrt::Windows::System::Profile::SystemSetupInfo>::python_type = py::register_python_type(module, _type_name_SystemSetupInfo, &_type_spec_SystemSetupInfo, nullptr);
            py::winrt_type<winrt::Windows::System::Profile::UnsupportedAppRequirement>::python_type = py::register_python_type(module, _type_name_UnsupportedAppRequirement, &_type_spec_UnsupportedAppRequirement, bases.get());
            py::winrt_type<winrt::Windows::System::Profile::WindowsIntegrityPolicy>::python_type = py::register_python_type(module, _type_name_WindowsIntegrityPolicy, &_type_spec_WindowsIntegrityPolicy, nullptr);

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

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

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

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

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