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

#include "pybase.h"
#include "py.Windows.Security.Isolation.h"

PyTypeObject* py::winrt_type<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironment>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentCreateResult>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentFile>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentHost>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentLaunchFileResult>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentOptions>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentOwnerRegistration>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentOwnerRegistrationData>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentOwnerRegistrationResult>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentPostMessageResult>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentProcess>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentShareFileRequestOptions>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentShareFileResult>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentShareFolderRequestOptions>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentShareFolderResult>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentStartProcessResult>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentTelemetryParameters>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentUserInfo>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Security::Isolation::IsolatedWindowsHostMessenger>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentCreateProgress>::python_type;

PyObject* py::converter<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentCreateProgress>::convert(winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentCreateProgress instance) noexcept
{
    return py::wrap_struct(instance, py::get_python_type<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentCreateProgress>());
}
winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentCreateProgress py::converter<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentCreateProgress>::convert_to(PyObject* obj)
{
    throw_if_pyobj_null(obj);

    if (Py_TYPE(obj) == py::get_python_type<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentCreateProgress>())
    {
        return reinterpret_cast<py::winrt_struct_wrapper<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentCreateProgress>*>(obj)->obj;
    }

    if (!PyDict_Check(obj))
    {
        throw winrt::hresult_invalid_argument();
    }

    winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentCreateProgress return_value{};

    PyObject* py_State = PyDict_GetItemString(obj, "state");
    if (!py_State) { throw winrt::hresult_invalid_argument(); }
    return_value.State = converter<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentProgressState>::convert_to(py_State);

    PyObject* py_PercentComplete = PyDict_GetItemString(obj, "percent_complete");
    if (!py_PercentComplete) { throw winrt::hresult_invalid_argument(); }
    return_value.PercentComplete = converter<uint32_t>::convert_to(py_PercentComplete);

    return return_value;
}

namespace py::cpp::Windows::Security::Isolation
{
    // ----- IsolatedWindowsEnvironment class --------------------
    constexpr const char* const _type_name_IsolatedWindowsEnvironment = "IsolatedWindowsEnvironment";

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

    static void _dealloc_IsolatedWindowsEnvironment(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironment* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* IsolatedWindowsEnvironment_CreateAsync(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::Security::Isolation::IsolatedWindowsEnvironmentOptions>(args, 0);

                return py::convert(winrt::Windows::Security::Isolation::IsolatedWindowsEnvironment::CreateAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 2)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentOptions>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentTelemetryParameters>(args, 1);

                return py::convert(winrt::Windows::Security::Isolation::IsolatedWindowsEnvironment::CreateAsync(param0, param1));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* IsolatedWindowsEnvironment_FindByOwnerId(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::Security::Isolation::IsolatedWindowsEnvironment::FindByOwnerId(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* IsolatedWindowsEnvironment_GetById(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::Security::Isolation::IsolatedWindowsEnvironment::GetById(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* IsolatedWindowsEnvironment_GetUserInfo(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironment* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

    static PyObject* IsolatedWindowsEnvironment_LaunchFileWithUIAsync(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironment* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

                return py::convert(self->obj.LaunchFileWithUIAsync(param0, param1, param2));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 4)
        {
            try
            {
                auto param0 = py::convert_to<winrt::hstring>(args, 0);
                auto param1 = py::convert_to<winrt::hstring>(args, 1);
                auto param2 = py::convert_to<winrt::hstring>(args, 2);
                auto param3 = py::convert_to<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentTelemetryParameters>(args, 3);

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

    static PyObject* IsolatedWindowsEnvironment_PostMessageToReceiverAsync(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironment* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

                return py::convert(self->obj.PostMessageToReceiverAsync(param0, param1));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 3)
        {
            try
            {
                auto param0 = py::convert_to<winrt::guid>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Foundation::Collections::IIterable<winrt::Windows::Foundation::IInspectable>>(args, 1);
                auto param2 = py::convert_to<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentTelemetryParameters>(args, 2);

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

    static PyObject* IsolatedWindowsEnvironment_RegisterMessageReceiver(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironment* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 2)
        {
            try
            {
                auto param0 = py::convert_to<winrt::guid>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Security::Isolation::MessageReceivedCallback>(args, 1);

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

    static PyObject* IsolatedWindowsEnvironment_ShareFileAsync(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironment* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

                return py::convert(self->obj.ShareFileAsync(param0, param1));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 3)
        {
            try
            {
                auto param0 = py::convert_to<winrt::hstring>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentShareFileRequestOptions>(args, 1);
                auto param2 = py::convert_to<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentTelemetryParameters>(args, 2);

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

    static PyObject* IsolatedWindowsEnvironment_ShareFolderAsync(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironment* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

                return py::convert(self->obj.ShareFolderAsync(param0, param1));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 3)
        {
            try
            {
                auto param0 = py::convert_to<winrt::hstring>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentShareFolderRequestOptions>(args, 1);
                auto param2 = py::convert_to<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentTelemetryParameters>(args, 2);

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

    static PyObject* IsolatedWindowsEnvironment_StartProcessSilentlyAsync(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironment* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 3)
        {
            try
            {
                auto param0 = py::convert_to<winrt::hstring>(args, 0);
                auto param1 = py::convert_to<winrt::hstring>(args, 1);
                auto param2 = py::convert_to<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentActivator>(args, 2);

                return py::convert(self->obj.StartProcessSilentlyAsync(param0, param1, param2));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 4)
        {
            try
            {
                auto param0 = py::convert_to<winrt::hstring>(args, 0);
                auto param1 = py::convert_to<winrt::hstring>(args, 1);
                auto param2 = py::convert_to<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentActivator>(args, 2);
                auto param3 = py::convert_to<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentTelemetryParameters>(args, 3);

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

    static PyObject* IsolatedWindowsEnvironment_TerminateAsync(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironment* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            try
            {
                return py::convert(self->obj.TerminateAsync());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentTelemetryParameters>(args, 0);

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

    static PyObject* IsolatedWindowsEnvironment_UnregisterMessageReceiver(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironment* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* IsolatedWindowsEnvironment_get_Id(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironment* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Id());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_IsolatedWindowsEnvironment(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::Security::Isolation::IsolatedWindowsEnvironment>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_IsolatedWindowsEnvironment[] = {
        { "create_async", reinterpret_cast<PyCFunction>(IsolatedWindowsEnvironment_CreateAsync), METH_VARARGS | METH_STATIC, nullptr },
        { "find_by_owner_id", reinterpret_cast<PyCFunction>(IsolatedWindowsEnvironment_FindByOwnerId), METH_VARARGS | METH_STATIC, nullptr },
        { "get_by_id", reinterpret_cast<PyCFunction>(IsolatedWindowsEnvironment_GetById), METH_VARARGS | METH_STATIC, nullptr },
        { "get_user_info", reinterpret_cast<PyCFunction>(IsolatedWindowsEnvironment_GetUserInfo), METH_VARARGS, nullptr },
        { "launch_file_with_u_i_async", reinterpret_cast<PyCFunction>(IsolatedWindowsEnvironment_LaunchFileWithUIAsync), METH_VARARGS, nullptr },
        { "post_message_to_receiver_async", reinterpret_cast<PyCFunction>(IsolatedWindowsEnvironment_PostMessageToReceiverAsync), METH_VARARGS, nullptr },
        { "register_message_receiver", reinterpret_cast<PyCFunction>(IsolatedWindowsEnvironment_RegisterMessageReceiver), METH_VARARGS, nullptr },
        { "share_file_async", reinterpret_cast<PyCFunction>(IsolatedWindowsEnvironment_ShareFileAsync), METH_VARARGS, nullptr },
        { "share_folder_async", reinterpret_cast<PyCFunction>(IsolatedWindowsEnvironment_ShareFolderAsync), METH_VARARGS, nullptr },
        { "start_process_silently_async", reinterpret_cast<PyCFunction>(IsolatedWindowsEnvironment_StartProcessSilentlyAsync), METH_VARARGS, nullptr },
        { "terminate_async", reinterpret_cast<PyCFunction>(IsolatedWindowsEnvironment_TerminateAsync), METH_VARARGS, nullptr },
        { "unregister_message_receiver", reinterpret_cast<PyCFunction>(IsolatedWindowsEnvironment_UnregisterMessageReceiver), METH_VARARGS, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_IsolatedWindowsEnvironment), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_IsolatedWindowsEnvironment[] = {
        { "id", reinterpret_cast<getter>(IsolatedWindowsEnvironment_get_Id), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_IsolatedWindowsEnvironment[] = 
    {
        { Py_tp_new, _new_IsolatedWindowsEnvironment },
        { Py_tp_dealloc, _dealloc_IsolatedWindowsEnvironment },
        { Py_tp_methods, _methods_IsolatedWindowsEnvironment },
        { Py_tp_getset, _getset_IsolatedWindowsEnvironment },
        { },
    };

    static PyType_Spec _type_spec_IsolatedWindowsEnvironment =
    {
        "_winsdk_Windows_Security_Isolation.IsolatedWindowsEnvironment",
        sizeof(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironment),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_IsolatedWindowsEnvironment
    };

    // ----- IsolatedWindowsEnvironmentCreateResult class --------------------
    constexpr const char* const _type_name_IsolatedWindowsEnvironmentCreateResult = "IsolatedWindowsEnvironmentCreateResult";

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

    static void _dealloc_IsolatedWindowsEnvironmentCreateResult(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentCreateResult* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* IsolatedWindowsEnvironmentCreateResult_get_Environment(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentCreateResult* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Environment());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IsolatedWindowsEnvironmentCreateResult_get_ExtendedError(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentCreateResult* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ExtendedError());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IsolatedWindowsEnvironmentCreateResult_get_Status(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentCreateResult* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Status());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_IsolatedWindowsEnvironmentCreateResult(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::Security::Isolation::IsolatedWindowsEnvironmentCreateResult>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

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

    static PyGetSetDef _getset_IsolatedWindowsEnvironmentCreateResult[] = {
        { "environment", reinterpret_cast<getter>(IsolatedWindowsEnvironmentCreateResult_get_Environment), nullptr, nullptr, nullptr },
        { "extended_error", reinterpret_cast<getter>(IsolatedWindowsEnvironmentCreateResult_get_ExtendedError), nullptr, nullptr, nullptr },
        { "status", reinterpret_cast<getter>(IsolatedWindowsEnvironmentCreateResult_get_Status), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_IsolatedWindowsEnvironmentCreateResult[] = 
    {
        { Py_tp_new, _new_IsolatedWindowsEnvironmentCreateResult },
        { Py_tp_dealloc, _dealloc_IsolatedWindowsEnvironmentCreateResult },
        { Py_tp_methods, _methods_IsolatedWindowsEnvironmentCreateResult },
        { Py_tp_getset, _getset_IsolatedWindowsEnvironmentCreateResult },
        { },
    };

    static PyType_Spec _type_spec_IsolatedWindowsEnvironmentCreateResult =
    {
        "_winsdk_Windows_Security_Isolation.IsolatedWindowsEnvironmentCreateResult",
        sizeof(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentCreateResult),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_IsolatedWindowsEnvironmentCreateResult
    };

    // ----- IsolatedWindowsEnvironmentFile class --------------------
    constexpr const char* const _type_name_IsolatedWindowsEnvironmentFile = "IsolatedWindowsEnvironmentFile";

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

    static void _dealloc_IsolatedWindowsEnvironmentFile(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentFile* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* IsolatedWindowsEnvironmentFile_Close(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentFile* 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* IsolatedWindowsEnvironmentFile_get_HostPath(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentFile* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.HostPath());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IsolatedWindowsEnvironmentFile_get_Id(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentFile* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Id());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IsolatedWindowsEnvironmentFile_get_GuestPath(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentFile* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.GuestPath());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IsolatedWindowsEnvironmentFile_get_IsReadOnly(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentFile* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.IsReadOnly());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_IsolatedWindowsEnvironmentFile(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::Security::Isolation::IsolatedWindowsEnvironmentFile>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_IsolatedWindowsEnvironmentFile[] = {
        { "close", reinterpret_cast<PyCFunction>(IsolatedWindowsEnvironmentFile_Close), METH_VARARGS, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_IsolatedWindowsEnvironmentFile), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_IsolatedWindowsEnvironmentFile[] = {
        { "host_path", reinterpret_cast<getter>(IsolatedWindowsEnvironmentFile_get_HostPath), nullptr, nullptr, nullptr },
        { "id", reinterpret_cast<getter>(IsolatedWindowsEnvironmentFile_get_Id), nullptr, nullptr, nullptr },
        { "guest_path", reinterpret_cast<getter>(IsolatedWindowsEnvironmentFile_get_GuestPath), nullptr, nullptr, nullptr },
        { "is_read_only", reinterpret_cast<getter>(IsolatedWindowsEnvironmentFile_get_IsReadOnly), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_IsolatedWindowsEnvironmentFile[] = 
    {
        { Py_tp_new, _new_IsolatedWindowsEnvironmentFile },
        { Py_tp_dealloc, _dealloc_IsolatedWindowsEnvironmentFile },
        { Py_tp_methods, _methods_IsolatedWindowsEnvironmentFile },
        { Py_tp_getset, _getset_IsolatedWindowsEnvironmentFile },
        { },
    };

    static PyType_Spec _type_spec_IsolatedWindowsEnvironmentFile =
    {
        "_winsdk_Windows_Security_Isolation.IsolatedWindowsEnvironmentFile",
        sizeof(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentFile),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_IsolatedWindowsEnvironmentFile
    };

    // ----- IsolatedWindowsEnvironmentHost class --------------------
    constexpr const char* const _type_name_IsolatedWindowsEnvironmentHost = "IsolatedWindowsEnvironmentHost";

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

    static PyObject* IsolatedWindowsEnvironmentHost_get_HostErrors(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentHost::HostErrors());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IsolatedWindowsEnvironmentHost_get_IsReady(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentHost::IsReady());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_IsolatedWindowsEnvironmentHost[] = {
        { "get_host_errors", reinterpret_cast<PyCFunction>(IsolatedWindowsEnvironmentHost_get_HostErrors), METH_NOARGS | METH_STATIC, nullptr },
        { "get_is_ready", reinterpret_cast<PyCFunction>(IsolatedWindowsEnvironmentHost_get_IsReady), METH_NOARGS | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_IsolatedWindowsEnvironmentHost[] = {
        { }
    };

    static PyType_Slot _type_slots_IsolatedWindowsEnvironmentHost[] = 
    {
        { Py_tp_new, _new_IsolatedWindowsEnvironmentHost },
        { Py_tp_methods, _methods_IsolatedWindowsEnvironmentHost },
        { Py_tp_getset, _getset_IsolatedWindowsEnvironmentHost },
        { },
    };

    static PyType_Spec _type_spec_IsolatedWindowsEnvironmentHost =
    {
        "_winsdk_Windows_Security_Isolation.IsolatedWindowsEnvironmentHost",
        0,
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_IsolatedWindowsEnvironmentHost
    };

    // ----- IsolatedWindowsEnvironmentLaunchFileResult class --------------------
    constexpr const char* const _type_name_IsolatedWindowsEnvironmentLaunchFileResult = "IsolatedWindowsEnvironmentLaunchFileResult";

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

    static void _dealloc_IsolatedWindowsEnvironmentLaunchFileResult(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentLaunchFileResult* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* IsolatedWindowsEnvironmentLaunchFileResult_get_ExtendedError(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentLaunchFileResult* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ExtendedError());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IsolatedWindowsEnvironmentLaunchFileResult_get_File(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentLaunchFileResult* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.File());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IsolatedWindowsEnvironmentLaunchFileResult_get_Status(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentLaunchFileResult* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Status());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_IsolatedWindowsEnvironmentLaunchFileResult(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::Security::Isolation::IsolatedWindowsEnvironmentLaunchFileResult>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

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

    static PyGetSetDef _getset_IsolatedWindowsEnvironmentLaunchFileResult[] = {
        { "extended_error", reinterpret_cast<getter>(IsolatedWindowsEnvironmentLaunchFileResult_get_ExtendedError), nullptr, nullptr, nullptr },
        { "file", reinterpret_cast<getter>(IsolatedWindowsEnvironmentLaunchFileResult_get_File), nullptr, nullptr, nullptr },
        { "status", reinterpret_cast<getter>(IsolatedWindowsEnvironmentLaunchFileResult_get_Status), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_IsolatedWindowsEnvironmentLaunchFileResult[] = 
    {
        { Py_tp_new, _new_IsolatedWindowsEnvironmentLaunchFileResult },
        { Py_tp_dealloc, _dealloc_IsolatedWindowsEnvironmentLaunchFileResult },
        { Py_tp_methods, _methods_IsolatedWindowsEnvironmentLaunchFileResult },
        { Py_tp_getset, _getset_IsolatedWindowsEnvironmentLaunchFileResult },
        { },
    };

    static PyType_Spec _type_spec_IsolatedWindowsEnvironmentLaunchFileResult =
    {
        "_winsdk_Windows_Security_Isolation.IsolatedWindowsEnvironmentLaunchFileResult",
        sizeof(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentLaunchFileResult),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_IsolatedWindowsEnvironmentLaunchFileResult
    };

    // ----- IsolatedWindowsEnvironmentOptions class --------------------
    constexpr const char* const _type_name_IsolatedWindowsEnvironmentOptions = "IsolatedWindowsEnvironmentOptions";

    static PyObject* _new_IsolatedWindowsEnvironmentOptions(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::Security::Isolation::IsolatedWindowsEnvironmentOptions 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_IsolatedWindowsEnvironmentOptions(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentOptions* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* IsolatedWindowsEnvironmentOptions_ShareHostFolderForUntrustedItems(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentOptions* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* IsolatedWindowsEnvironmentOptions_get_PersistUserProfile(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentOptions* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.PersistUserProfile());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int IsolatedWindowsEnvironmentOptions_put_PersistUserProfile(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentOptions* 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.PersistUserProfile(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* IsolatedWindowsEnvironmentOptions_get_EnvironmentOwnerId(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentOptions* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.EnvironmentOwnerId());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int IsolatedWindowsEnvironmentOptions_put_EnvironmentOwnerId(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentOptions* 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<winrt::hstring>(arg);

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

    static PyObject* IsolatedWindowsEnvironmentOptions_get_ClipboardCopyPasteDirections(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentOptions* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ClipboardCopyPasteDirections());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int IsolatedWindowsEnvironmentOptions_put_ClipboardCopyPasteDirections(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentOptions* 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<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentClipboardCopyPasteDirections>(arg);

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

    static PyObject* IsolatedWindowsEnvironmentOptions_get_AvailablePrinters(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentOptions* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.AvailablePrinters());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int IsolatedWindowsEnvironmentOptions_put_AvailablePrinters(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentOptions* 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<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentAvailablePrinters>(arg);

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

    static PyObject* IsolatedWindowsEnvironmentOptions_get_AllowedClipboardFormats(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentOptions* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.AllowedClipboardFormats());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int IsolatedWindowsEnvironmentOptions_put_AllowedClipboardFormats(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentOptions* 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<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentAllowedClipboardFormats>(arg);

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

    static PyObject* IsolatedWindowsEnvironmentOptions_get_AllowGraphicsHardwareAcceleration(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentOptions* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.AllowGraphicsHardwareAcceleration());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int IsolatedWindowsEnvironmentOptions_put_AllowGraphicsHardwareAcceleration(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentOptions* 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.AllowGraphicsHardwareAcceleration(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* IsolatedWindowsEnvironmentOptions_get_AllowCameraAndMicrophoneAccess(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentOptions* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.AllowCameraAndMicrophoneAccess());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int IsolatedWindowsEnvironmentOptions_put_AllowCameraAndMicrophoneAccess(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentOptions* 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.AllowCameraAndMicrophoneAccess(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* IsolatedWindowsEnvironmentOptions_get_SharedFolderNameInEnvironment(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentOptions* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.SharedFolderNameInEnvironment());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IsolatedWindowsEnvironmentOptions_get_SharedHostFolderPath(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentOptions* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.SharedHostFolderPath());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IsolatedWindowsEnvironmentOptions_get_WindowAnnotationOverride(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentOptions* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.WindowAnnotationOverride());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int IsolatedWindowsEnvironmentOptions_put_WindowAnnotationOverride(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentOptions* 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<winrt::hstring>(arg);

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

    static PyObject* _from_IsolatedWindowsEnvironmentOptions(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::Security::Isolation::IsolatedWindowsEnvironmentOptions>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_IsolatedWindowsEnvironmentOptions[] = {
        { "share_host_folder_for_untrusted_items", reinterpret_cast<PyCFunction>(IsolatedWindowsEnvironmentOptions_ShareHostFolderForUntrustedItems), METH_VARARGS, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_IsolatedWindowsEnvironmentOptions), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_IsolatedWindowsEnvironmentOptions[] = {
        { "persist_user_profile", reinterpret_cast<getter>(IsolatedWindowsEnvironmentOptions_get_PersistUserProfile), reinterpret_cast<setter>(IsolatedWindowsEnvironmentOptions_put_PersistUserProfile), nullptr, nullptr },
        { "environment_owner_id", reinterpret_cast<getter>(IsolatedWindowsEnvironmentOptions_get_EnvironmentOwnerId), reinterpret_cast<setter>(IsolatedWindowsEnvironmentOptions_put_EnvironmentOwnerId), nullptr, nullptr },
        { "clipboard_copy_paste_directions", reinterpret_cast<getter>(IsolatedWindowsEnvironmentOptions_get_ClipboardCopyPasteDirections), reinterpret_cast<setter>(IsolatedWindowsEnvironmentOptions_put_ClipboardCopyPasteDirections), nullptr, nullptr },
        { "available_printers", reinterpret_cast<getter>(IsolatedWindowsEnvironmentOptions_get_AvailablePrinters), reinterpret_cast<setter>(IsolatedWindowsEnvironmentOptions_put_AvailablePrinters), nullptr, nullptr },
        { "allowed_clipboard_formats", reinterpret_cast<getter>(IsolatedWindowsEnvironmentOptions_get_AllowedClipboardFormats), reinterpret_cast<setter>(IsolatedWindowsEnvironmentOptions_put_AllowedClipboardFormats), nullptr, nullptr },
        { "allow_graphics_hardware_acceleration", reinterpret_cast<getter>(IsolatedWindowsEnvironmentOptions_get_AllowGraphicsHardwareAcceleration), reinterpret_cast<setter>(IsolatedWindowsEnvironmentOptions_put_AllowGraphicsHardwareAcceleration), nullptr, nullptr },
        { "allow_camera_and_microphone_access", reinterpret_cast<getter>(IsolatedWindowsEnvironmentOptions_get_AllowCameraAndMicrophoneAccess), reinterpret_cast<setter>(IsolatedWindowsEnvironmentOptions_put_AllowCameraAndMicrophoneAccess), nullptr, nullptr },
        { "shared_folder_name_in_environment", reinterpret_cast<getter>(IsolatedWindowsEnvironmentOptions_get_SharedFolderNameInEnvironment), nullptr, nullptr, nullptr },
        { "shared_host_folder_path", reinterpret_cast<getter>(IsolatedWindowsEnvironmentOptions_get_SharedHostFolderPath), nullptr, nullptr, nullptr },
        { "window_annotation_override", reinterpret_cast<getter>(IsolatedWindowsEnvironmentOptions_get_WindowAnnotationOverride), reinterpret_cast<setter>(IsolatedWindowsEnvironmentOptions_put_WindowAnnotationOverride), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_IsolatedWindowsEnvironmentOptions[] = 
    {
        { Py_tp_new, _new_IsolatedWindowsEnvironmentOptions },
        { Py_tp_dealloc, _dealloc_IsolatedWindowsEnvironmentOptions },
        { Py_tp_methods, _methods_IsolatedWindowsEnvironmentOptions },
        { Py_tp_getset, _getset_IsolatedWindowsEnvironmentOptions },
        { },
    };

    static PyType_Spec _type_spec_IsolatedWindowsEnvironmentOptions =
    {
        "_winsdk_Windows_Security_Isolation.IsolatedWindowsEnvironmentOptions",
        sizeof(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentOptions),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_IsolatedWindowsEnvironmentOptions
    };

    // ----- IsolatedWindowsEnvironmentOwnerRegistration class --------------------
    constexpr const char* const _type_name_IsolatedWindowsEnvironmentOwnerRegistration = "IsolatedWindowsEnvironmentOwnerRegistration";

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

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

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

                return py::convert(winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentOwnerRegistration::Register(param0, param1));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* IsolatedWindowsEnvironmentOwnerRegistration_Unregister(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);

                winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentOwnerRegistration::Unregister(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyMethodDef _methods_IsolatedWindowsEnvironmentOwnerRegistration[] = {
        { "register", reinterpret_cast<PyCFunction>(IsolatedWindowsEnvironmentOwnerRegistration_Register), METH_VARARGS | METH_STATIC, nullptr },
        { "unregister", reinterpret_cast<PyCFunction>(IsolatedWindowsEnvironmentOwnerRegistration_Unregister), METH_VARARGS | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_IsolatedWindowsEnvironmentOwnerRegistration[] = {
        { }
    };

    static PyType_Slot _type_slots_IsolatedWindowsEnvironmentOwnerRegistration[] = 
    {
        { Py_tp_new, _new_IsolatedWindowsEnvironmentOwnerRegistration },
        { Py_tp_methods, _methods_IsolatedWindowsEnvironmentOwnerRegistration },
        { Py_tp_getset, _getset_IsolatedWindowsEnvironmentOwnerRegistration },
        { },
    };

    static PyType_Spec _type_spec_IsolatedWindowsEnvironmentOwnerRegistration =
    {
        "_winsdk_Windows_Security_Isolation.IsolatedWindowsEnvironmentOwnerRegistration",
        0,
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_IsolatedWindowsEnvironmentOwnerRegistration
    };

    // ----- IsolatedWindowsEnvironmentOwnerRegistrationData class --------------------
    constexpr const char* const _type_name_IsolatedWindowsEnvironmentOwnerRegistrationData = "IsolatedWindowsEnvironmentOwnerRegistrationData";

    static PyObject* _new_IsolatedWindowsEnvironmentOwnerRegistrationData(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::Security::Isolation::IsolatedWindowsEnvironmentOwnerRegistrationData 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_IsolatedWindowsEnvironmentOwnerRegistrationData(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentOwnerRegistrationData* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* IsolatedWindowsEnvironmentOwnerRegistrationData_get_ActivationFileExtensions(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentOwnerRegistrationData* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ActivationFileExtensions());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IsolatedWindowsEnvironmentOwnerRegistrationData_get_ProcessesRunnableAsSystem(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentOwnerRegistrationData* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ProcessesRunnableAsSystem());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IsolatedWindowsEnvironmentOwnerRegistrationData_get_ProcessesRunnableAsUser(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentOwnerRegistrationData* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ProcessesRunnableAsUser());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IsolatedWindowsEnvironmentOwnerRegistrationData_get_ShareableFolders(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentOwnerRegistrationData* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ShareableFolders());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_IsolatedWindowsEnvironmentOwnerRegistrationData(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::Security::Isolation::IsolatedWindowsEnvironmentOwnerRegistrationData>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

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

    static PyGetSetDef _getset_IsolatedWindowsEnvironmentOwnerRegistrationData[] = {
        { "activation_file_extensions", reinterpret_cast<getter>(IsolatedWindowsEnvironmentOwnerRegistrationData_get_ActivationFileExtensions), nullptr, nullptr, nullptr },
        { "processes_runnable_as_system", reinterpret_cast<getter>(IsolatedWindowsEnvironmentOwnerRegistrationData_get_ProcessesRunnableAsSystem), nullptr, nullptr, nullptr },
        { "processes_runnable_as_user", reinterpret_cast<getter>(IsolatedWindowsEnvironmentOwnerRegistrationData_get_ProcessesRunnableAsUser), nullptr, nullptr, nullptr },
        { "shareable_folders", reinterpret_cast<getter>(IsolatedWindowsEnvironmentOwnerRegistrationData_get_ShareableFolders), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_IsolatedWindowsEnvironmentOwnerRegistrationData[] = 
    {
        { Py_tp_new, _new_IsolatedWindowsEnvironmentOwnerRegistrationData },
        { Py_tp_dealloc, _dealloc_IsolatedWindowsEnvironmentOwnerRegistrationData },
        { Py_tp_methods, _methods_IsolatedWindowsEnvironmentOwnerRegistrationData },
        { Py_tp_getset, _getset_IsolatedWindowsEnvironmentOwnerRegistrationData },
        { },
    };

    static PyType_Spec _type_spec_IsolatedWindowsEnvironmentOwnerRegistrationData =
    {
        "_winsdk_Windows_Security_Isolation.IsolatedWindowsEnvironmentOwnerRegistrationData",
        sizeof(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentOwnerRegistrationData),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_IsolatedWindowsEnvironmentOwnerRegistrationData
    };

    // ----- IsolatedWindowsEnvironmentOwnerRegistrationResult class --------------------
    constexpr const char* const _type_name_IsolatedWindowsEnvironmentOwnerRegistrationResult = "IsolatedWindowsEnvironmentOwnerRegistrationResult";

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

    static void _dealloc_IsolatedWindowsEnvironmentOwnerRegistrationResult(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentOwnerRegistrationResult* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* IsolatedWindowsEnvironmentOwnerRegistrationResult_get_ExtendedError(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentOwnerRegistrationResult* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ExtendedError());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IsolatedWindowsEnvironmentOwnerRegistrationResult_get_Status(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentOwnerRegistrationResult* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Status());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_IsolatedWindowsEnvironmentOwnerRegistrationResult(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::Security::Isolation::IsolatedWindowsEnvironmentOwnerRegistrationResult>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

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

    static PyGetSetDef _getset_IsolatedWindowsEnvironmentOwnerRegistrationResult[] = {
        { "extended_error", reinterpret_cast<getter>(IsolatedWindowsEnvironmentOwnerRegistrationResult_get_ExtendedError), nullptr, nullptr, nullptr },
        { "status", reinterpret_cast<getter>(IsolatedWindowsEnvironmentOwnerRegistrationResult_get_Status), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_IsolatedWindowsEnvironmentOwnerRegistrationResult[] = 
    {
        { Py_tp_new, _new_IsolatedWindowsEnvironmentOwnerRegistrationResult },
        { Py_tp_dealloc, _dealloc_IsolatedWindowsEnvironmentOwnerRegistrationResult },
        { Py_tp_methods, _methods_IsolatedWindowsEnvironmentOwnerRegistrationResult },
        { Py_tp_getset, _getset_IsolatedWindowsEnvironmentOwnerRegistrationResult },
        { },
    };

    static PyType_Spec _type_spec_IsolatedWindowsEnvironmentOwnerRegistrationResult =
    {
        "_winsdk_Windows_Security_Isolation.IsolatedWindowsEnvironmentOwnerRegistrationResult",
        sizeof(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentOwnerRegistrationResult),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_IsolatedWindowsEnvironmentOwnerRegistrationResult
    };

    // ----- IsolatedWindowsEnvironmentPostMessageResult class --------------------
    constexpr const char* const _type_name_IsolatedWindowsEnvironmentPostMessageResult = "IsolatedWindowsEnvironmentPostMessageResult";

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

    static void _dealloc_IsolatedWindowsEnvironmentPostMessageResult(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentPostMessageResult* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* IsolatedWindowsEnvironmentPostMessageResult_get_ExtendedError(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentPostMessageResult* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ExtendedError());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IsolatedWindowsEnvironmentPostMessageResult_get_Status(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentPostMessageResult* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Status());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_IsolatedWindowsEnvironmentPostMessageResult(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::Security::Isolation::IsolatedWindowsEnvironmentPostMessageResult>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

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

    static PyGetSetDef _getset_IsolatedWindowsEnvironmentPostMessageResult[] = {
        { "extended_error", reinterpret_cast<getter>(IsolatedWindowsEnvironmentPostMessageResult_get_ExtendedError), nullptr, nullptr, nullptr },
        { "status", reinterpret_cast<getter>(IsolatedWindowsEnvironmentPostMessageResult_get_Status), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_IsolatedWindowsEnvironmentPostMessageResult[] = 
    {
        { Py_tp_new, _new_IsolatedWindowsEnvironmentPostMessageResult },
        { Py_tp_dealloc, _dealloc_IsolatedWindowsEnvironmentPostMessageResult },
        { Py_tp_methods, _methods_IsolatedWindowsEnvironmentPostMessageResult },
        { Py_tp_getset, _getset_IsolatedWindowsEnvironmentPostMessageResult },
        { },
    };

    static PyType_Spec _type_spec_IsolatedWindowsEnvironmentPostMessageResult =
    {
        "_winsdk_Windows_Security_Isolation.IsolatedWindowsEnvironmentPostMessageResult",
        sizeof(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentPostMessageResult),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_IsolatedWindowsEnvironmentPostMessageResult
    };

    // ----- IsolatedWindowsEnvironmentProcess class --------------------
    constexpr const char* const _type_name_IsolatedWindowsEnvironmentProcess = "IsolatedWindowsEnvironmentProcess";

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

    static void _dealloc_IsolatedWindowsEnvironmentProcess(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentProcess* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* IsolatedWindowsEnvironmentProcess_WaitForExit(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentProcess* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

    static PyObject* IsolatedWindowsEnvironmentProcess_WaitForExitAsync(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentProcess* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

    static PyObject* IsolatedWindowsEnvironmentProcess_WaitForExitWithTimeout(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentProcess* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

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

    static PyObject* IsolatedWindowsEnvironmentProcess_get_ExitCode(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentProcess* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ExitCode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IsolatedWindowsEnvironmentProcess_get_State(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentProcess* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.State());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_IsolatedWindowsEnvironmentProcess(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::Security::Isolation::IsolatedWindowsEnvironmentProcess>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_IsolatedWindowsEnvironmentProcess[] = {
        { "wait_for_exit", reinterpret_cast<PyCFunction>(IsolatedWindowsEnvironmentProcess_WaitForExit), METH_VARARGS, nullptr },
        { "wait_for_exit_async", reinterpret_cast<PyCFunction>(IsolatedWindowsEnvironmentProcess_WaitForExitAsync), METH_VARARGS, nullptr },
        { "wait_for_exit_with_timeout", reinterpret_cast<PyCFunction>(IsolatedWindowsEnvironmentProcess_WaitForExitWithTimeout), METH_VARARGS, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_IsolatedWindowsEnvironmentProcess), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_IsolatedWindowsEnvironmentProcess[] = {
        { "exit_code", reinterpret_cast<getter>(IsolatedWindowsEnvironmentProcess_get_ExitCode), nullptr, nullptr, nullptr },
        { "state", reinterpret_cast<getter>(IsolatedWindowsEnvironmentProcess_get_State), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_IsolatedWindowsEnvironmentProcess[] = 
    {
        { Py_tp_new, _new_IsolatedWindowsEnvironmentProcess },
        { Py_tp_dealloc, _dealloc_IsolatedWindowsEnvironmentProcess },
        { Py_tp_methods, _methods_IsolatedWindowsEnvironmentProcess },
        { Py_tp_getset, _getset_IsolatedWindowsEnvironmentProcess },
        { },
    };

    static PyType_Spec _type_spec_IsolatedWindowsEnvironmentProcess =
    {
        "_winsdk_Windows_Security_Isolation.IsolatedWindowsEnvironmentProcess",
        sizeof(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentProcess),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_IsolatedWindowsEnvironmentProcess
    };

    // ----- IsolatedWindowsEnvironmentShareFileRequestOptions class --------------------
    constexpr const char* const _type_name_IsolatedWindowsEnvironmentShareFileRequestOptions = "IsolatedWindowsEnvironmentShareFileRequestOptions";

    static PyObject* _new_IsolatedWindowsEnvironmentShareFileRequestOptions(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::Security::Isolation::IsolatedWindowsEnvironmentShareFileRequestOptions 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_IsolatedWindowsEnvironmentShareFileRequestOptions(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentShareFileRequestOptions* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* IsolatedWindowsEnvironmentShareFileRequestOptions_get_AllowWrite(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentShareFileRequestOptions* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.AllowWrite());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int IsolatedWindowsEnvironmentShareFileRequestOptions_put_AllowWrite(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentShareFileRequestOptions* 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.AllowWrite(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* _from_IsolatedWindowsEnvironmentShareFileRequestOptions(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::Security::Isolation::IsolatedWindowsEnvironmentShareFileRequestOptions>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

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

    static PyGetSetDef _getset_IsolatedWindowsEnvironmentShareFileRequestOptions[] = {
        { "allow_write", reinterpret_cast<getter>(IsolatedWindowsEnvironmentShareFileRequestOptions_get_AllowWrite), reinterpret_cast<setter>(IsolatedWindowsEnvironmentShareFileRequestOptions_put_AllowWrite), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_IsolatedWindowsEnvironmentShareFileRequestOptions[] = 
    {
        { Py_tp_new, _new_IsolatedWindowsEnvironmentShareFileRequestOptions },
        { Py_tp_dealloc, _dealloc_IsolatedWindowsEnvironmentShareFileRequestOptions },
        { Py_tp_methods, _methods_IsolatedWindowsEnvironmentShareFileRequestOptions },
        { Py_tp_getset, _getset_IsolatedWindowsEnvironmentShareFileRequestOptions },
        { },
    };

    static PyType_Spec _type_spec_IsolatedWindowsEnvironmentShareFileRequestOptions =
    {
        "_winsdk_Windows_Security_Isolation.IsolatedWindowsEnvironmentShareFileRequestOptions",
        sizeof(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentShareFileRequestOptions),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_IsolatedWindowsEnvironmentShareFileRequestOptions
    };

    // ----- IsolatedWindowsEnvironmentShareFileResult class --------------------
    constexpr const char* const _type_name_IsolatedWindowsEnvironmentShareFileResult = "IsolatedWindowsEnvironmentShareFileResult";

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

    static void _dealloc_IsolatedWindowsEnvironmentShareFileResult(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentShareFileResult* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* IsolatedWindowsEnvironmentShareFileResult_get_ExtendedError(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentShareFileResult* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ExtendedError());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IsolatedWindowsEnvironmentShareFileResult_get_File(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentShareFileResult* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.File());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IsolatedWindowsEnvironmentShareFileResult_get_Status(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentShareFileResult* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Status());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_IsolatedWindowsEnvironmentShareFileResult(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::Security::Isolation::IsolatedWindowsEnvironmentShareFileResult>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

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

    static PyGetSetDef _getset_IsolatedWindowsEnvironmentShareFileResult[] = {
        { "extended_error", reinterpret_cast<getter>(IsolatedWindowsEnvironmentShareFileResult_get_ExtendedError), nullptr, nullptr, nullptr },
        { "file", reinterpret_cast<getter>(IsolatedWindowsEnvironmentShareFileResult_get_File), nullptr, nullptr, nullptr },
        { "status", reinterpret_cast<getter>(IsolatedWindowsEnvironmentShareFileResult_get_Status), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_IsolatedWindowsEnvironmentShareFileResult[] = 
    {
        { Py_tp_new, _new_IsolatedWindowsEnvironmentShareFileResult },
        { Py_tp_dealloc, _dealloc_IsolatedWindowsEnvironmentShareFileResult },
        { Py_tp_methods, _methods_IsolatedWindowsEnvironmentShareFileResult },
        { Py_tp_getset, _getset_IsolatedWindowsEnvironmentShareFileResult },
        { },
    };

    static PyType_Spec _type_spec_IsolatedWindowsEnvironmentShareFileResult =
    {
        "_winsdk_Windows_Security_Isolation.IsolatedWindowsEnvironmentShareFileResult",
        sizeof(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentShareFileResult),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_IsolatedWindowsEnvironmentShareFileResult
    };

    // ----- IsolatedWindowsEnvironmentShareFolderRequestOptions class --------------------
    constexpr const char* const _type_name_IsolatedWindowsEnvironmentShareFolderRequestOptions = "IsolatedWindowsEnvironmentShareFolderRequestOptions";

    static PyObject* _new_IsolatedWindowsEnvironmentShareFolderRequestOptions(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::Security::Isolation::IsolatedWindowsEnvironmentShareFolderRequestOptions 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_IsolatedWindowsEnvironmentShareFolderRequestOptions(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentShareFolderRequestOptions* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* IsolatedWindowsEnvironmentShareFolderRequestOptions_get_AllowWrite(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentShareFolderRequestOptions* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.AllowWrite());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int IsolatedWindowsEnvironmentShareFolderRequestOptions_put_AllowWrite(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentShareFolderRequestOptions* 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.AllowWrite(param0);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* _from_IsolatedWindowsEnvironmentShareFolderRequestOptions(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::Security::Isolation::IsolatedWindowsEnvironmentShareFolderRequestOptions>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

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

    static PyGetSetDef _getset_IsolatedWindowsEnvironmentShareFolderRequestOptions[] = {
        { "allow_write", reinterpret_cast<getter>(IsolatedWindowsEnvironmentShareFolderRequestOptions_get_AllowWrite), reinterpret_cast<setter>(IsolatedWindowsEnvironmentShareFolderRequestOptions_put_AllowWrite), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_IsolatedWindowsEnvironmentShareFolderRequestOptions[] = 
    {
        { Py_tp_new, _new_IsolatedWindowsEnvironmentShareFolderRequestOptions },
        { Py_tp_dealloc, _dealloc_IsolatedWindowsEnvironmentShareFolderRequestOptions },
        { Py_tp_methods, _methods_IsolatedWindowsEnvironmentShareFolderRequestOptions },
        { Py_tp_getset, _getset_IsolatedWindowsEnvironmentShareFolderRequestOptions },
        { },
    };

    static PyType_Spec _type_spec_IsolatedWindowsEnvironmentShareFolderRequestOptions =
    {
        "_winsdk_Windows_Security_Isolation.IsolatedWindowsEnvironmentShareFolderRequestOptions",
        sizeof(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentShareFolderRequestOptions),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_IsolatedWindowsEnvironmentShareFolderRequestOptions
    };

    // ----- IsolatedWindowsEnvironmentShareFolderResult class --------------------
    constexpr const char* const _type_name_IsolatedWindowsEnvironmentShareFolderResult = "IsolatedWindowsEnvironmentShareFolderResult";

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

    static void _dealloc_IsolatedWindowsEnvironmentShareFolderResult(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentShareFolderResult* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* IsolatedWindowsEnvironmentShareFolderResult_get_ExtendedError(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentShareFolderResult* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ExtendedError());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IsolatedWindowsEnvironmentShareFolderResult_get_Status(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentShareFolderResult* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Status());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_IsolatedWindowsEnvironmentShareFolderResult(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::Security::Isolation::IsolatedWindowsEnvironmentShareFolderResult>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

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

    static PyGetSetDef _getset_IsolatedWindowsEnvironmentShareFolderResult[] = {
        { "extended_error", reinterpret_cast<getter>(IsolatedWindowsEnvironmentShareFolderResult_get_ExtendedError), nullptr, nullptr, nullptr },
        { "status", reinterpret_cast<getter>(IsolatedWindowsEnvironmentShareFolderResult_get_Status), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_IsolatedWindowsEnvironmentShareFolderResult[] = 
    {
        { Py_tp_new, _new_IsolatedWindowsEnvironmentShareFolderResult },
        { Py_tp_dealloc, _dealloc_IsolatedWindowsEnvironmentShareFolderResult },
        { Py_tp_methods, _methods_IsolatedWindowsEnvironmentShareFolderResult },
        { Py_tp_getset, _getset_IsolatedWindowsEnvironmentShareFolderResult },
        { },
    };

    static PyType_Spec _type_spec_IsolatedWindowsEnvironmentShareFolderResult =
    {
        "_winsdk_Windows_Security_Isolation.IsolatedWindowsEnvironmentShareFolderResult",
        sizeof(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentShareFolderResult),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_IsolatedWindowsEnvironmentShareFolderResult
    };

    // ----- IsolatedWindowsEnvironmentStartProcessResult class --------------------
    constexpr const char* const _type_name_IsolatedWindowsEnvironmentStartProcessResult = "IsolatedWindowsEnvironmentStartProcessResult";

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

    static void _dealloc_IsolatedWindowsEnvironmentStartProcessResult(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentStartProcessResult* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* IsolatedWindowsEnvironmentStartProcessResult_get_ExtendedError(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentStartProcessResult* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ExtendedError());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IsolatedWindowsEnvironmentStartProcessResult_get_Process(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentStartProcessResult* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Process());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IsolatedWindowsEnvironmentStartProcessResult_get_Status(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentStartProcessResult* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Status());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_IsolatedWindowsEnvironmentStartProcessResult(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::Security::Isolation::IsolatedWindowsEnvironmentStartProcessResult>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

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

    static PyGetSetDef _getset_IsolatedWindowsEnvironmentStartProcessResult[] = {
        { "extended_error", reinterpret_cast<getter>(IsolatedWindowsEnvironmentStartProcessResult_get_ExtendedError), nullptr, nullptr, nullptr },
        { "process", reinterpret_cast<getter>(IsolatedWindowsEnvironmentStartProcessResult_get_Process), nullptr, nullptr, nullptr },
        { "status", reinterpret_cast<getter>(IsolatedWindowsEnvironmentStartProcessResult_get_Status), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_IsolatedWindowsEnvironmentStartProcessResult[] = 
    {
        { Py_tp_new, _new_IsolatedWindowsEnvironmentStartProcessResult },
        { Py_tp_dealloc, _dealloc_IsolatedWindowsEnvironmentStartProcessResult },
        { Py_tp_methods, _methods_IsolatedWindowsEnvironmentStartProcessResult },
        { Py_tp_getset, _getset_IsolatedWindowsEnvironmentStartProcessResult },
        { },
    };

    static PyType_Spec _type_spec_IsolatedWindowsEnvironmentStartProcessResult =
    {
        "_winsdk_Windows_Security_Isolation.IsolatedWindowsEnvironmentStartProcessResult",
        sizeof(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentStartProcessResult),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_IsolatedWindowsEnvironmentStartProcessResult
    };

    // ----- IsolatedWindowsEnvironmentTelemetryParameters class --------------------
    constexpr const char* const _type_name_IsolatedWindowsEnvironmentTelemetryParameters = "IsolatedWindowsEnvironmentTelemetryParameters";

    static PyObject* _new_IsolatedWindowsEnvironmentTelemetryParameters(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::Security::Isolation::IsolatedWindowsEnvironmentTelemetryParameters 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_IsolatedWindowsEnvironmentTelemetryParameters(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentTelemetryParameters* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* IsolatedWindowsEnvironmentTelemetryParameters_get_CorrelationId(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentTelemetryParameters* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.CorrelationId());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static int IsolatedWindowsEnvironmentTelemetryParameters_put_CorrelationId(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentTelemetryParameters* 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<winrt::guid>(arg);

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

    static PyObject* _from_IsolatedWindowsEnvironmentTelemetryParameters(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::Security::Isolation::IsolatedWindowsEnvironmentTelemetryParameters>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

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

    static PyGetSetDef _getset_IsolatedWindowsEnvironmentTelemetryParameters[] = {
        { "correlation_id", reinterpret_cast<getter>(IsolatedWindowsEnvironmentTelemetryParameters_get_CorrelationId), reinterpret_cast<setter>(IsolatedWindowsEnvironmentTelemetryParameters_put_CorrelationId), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_IsolatedWindowsEnvironmentTelemetryParameters[] = 
    {
        { Py_tp_new, _new_IsolatedWindowsEnvironmentTelemetryParameters },
        { Py_tp_dealloc, _dealloc_IsolatedWindowsEnvironmentTelemetryParameters },
        { Py_tp_methods, _methods_IsolatedWindowsEnvironmentTelemetryParameters },
        { Py_tp_getset, _getset_IsolatedWindowsEnvironmentTelemetryParameters },
        { },
    };

    static PyType_Spec _type_spec_IsolatedWindowsEnvironmentTelemetryParameters =
    {
        "_winsdk_Windows_Security_Isolation.IsolatedWindowsEnvironmentTelemetryParameters",
        sizeof(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentTelemetryParameters),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_IsolatedWindowsEnvironmentTelemetryParameters
    };

    // ----- IsolatedWindowsEnvironmentUserInfo class --------------------
    constexpr const char* const _type_name_IsolatedWindowsEnvironmentUserInfo = "IsolatedWindowsEnvironmentUserInfo";

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

    static void _dealloc_IsolatedWindowsEnvironmentUserInfo(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentUserInfo* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* IsolatedWindowsEnvironmentUserInfo_TryWaitForSignInAsync(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentUserInfo* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

    static PyObject* IsolatedWindowsEnvironmentUserInfo_get_EnvironmentUserName(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentUserInfo* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.EnvironmentUserName());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* IsolatedWindowsEnvironmentUserInfo_get_EnvironmentUserSid(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentUserInfo* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.EnvironmentUserSid());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_IsolatedWindowsEnvironmentUserInfo(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::Security::Isolation::IsolatedWindowsEnvironmentUserInfo>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_IsolatedWindowsEnvironmentUserInfo[] = {
        { "try_wait_for_sign_in_async", reinterpret_cast<PyCFunction>(IsolatedWindowsEnvironmentUserInfo_TryWaitForSignInAsync), METH_VARARGS, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_IsolatedWindowsEnvironmentUserInfo), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_IsolatedWindowsEnvironmentUserInfo[] = {
        { "environment_user_name", reinterpret_cast<getter>(IsolatedWindowsEnvironmentUserInfo_get_EnvironmentUserName), nullptr, nullptr, nullptr },
        { "environment_user_sid", reinterpret_cast<getter>(IsolatedWindowsEnvironmentUserInfo_get_EnvironmentUserSid), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_IsolatedWindowsEnvironmentUserInfo[] = 
    {
        { Py_tp_new, _new_IsolatedWindowsEnvironmentUserInfo },
        { Py_tp_dealloc, _dealloc_IsolatedWindowsEnvironmentUserInfo },
        { Py_tp_methods, _methods_IsolatedWindowsEnvironmentUserInfo },
        { Py_tp_getset, _getset_IsolatedWindowsEnvironmentUserInfo },
        { },
    };

    static PyType_Spec _type_spec_IsolatedWindowsEnvironmentUserInfo =
    {
        "_winsdk_Windows_Security_Isolation.IsolatedWindowsEnvironmentUserInfo",
        sizeof(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentUserInfo),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_IsolatedWindowsEnvironmentUserInfo
    };

    // ----- IsolatedWindowsHostMessenger class --------------------
    constexpr const char* const _type_name_IsolatedWindowsHostMessenger = "IsolatedWindowsHostMessenger";

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

    static PyObject* IsolatedWindowsHostMessenger_GetFileId(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::Security::Isolation::IsolatedWindowsHostMessenger::GetFileId(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 2)
        {
            try
            {
                auto param0 = py::convert_to<winrt::guid>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Foundation::Collections::IVectorView<winrt::Windows::Foundation::IInspectable>>(args, 1);

                winrt::Windows::Security::Isolation::IsolatedWindowsHostMessenger::PostMessageToReceiver(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 2)
        {
            try
            {
                auto param0 = py::convert_to<winrt::guid>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Security::Isolation::HostMessageReceivedCallback>(args, 1);

                winrt::Windows::Security::Isolation::IsolatedWindowsHostMessenger::RegisterHostMessageReceiver(param0, param1);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

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

                winrt::Windows::Security::Isolation::IsolatedWindowsHostMessenger::UnregisterHostMessageReceiver(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyMethodDef _methods_IsolatedWindowsHostMessenger[] = {
        { "get_file_id", reinterpret_cast<PyCFunction>(IsolatedWindowsHostMessenger_GetFileId), METH_VARARGS | METH_STATIC, nullptr },
        { "post_message_to_receiver", reinterpret_cast<PyCFunction>(IsolatedWindowsHostMessenger_PostMessageToReceiver), METH_VARARGS | METH_STATIC, nullptr },
        { "register_host_message_receiver", reinterpret_cast<PyCFunction>(IsolatedWindowsHostMessenger_RegisterHostMessageReceiver), METH_VARARGS | METH_STATIC, nullptr },
        { "unregister_host_message_receiver", reinterpret_cast<PyCFunction>(IsolatedWindowsHostMessenger_UnregisterHostMessageReceiver), METH_VARARGS | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_IsolatedWindowsHostMessenger[] = {
        { }
    };

    static PyType_Slot _type_slots_IsolatedWindowsHostMessenger[] = 
    {
        { Py_tp_new, _new_IsolatedWindowsHostMessenger },
        { Py_tp_methods, _methods_IsolatedWindowsHostMessenger },
        { Py_tp_getset, _getset_IsolatedWindowsHostMessenger },
        { },
    };

    static PyType_Spec _type_spec_IsolatedWindowsHostMessenger =
    {
        "_winsdk_Windows_Security_Isolation.IsolatedWindowsHostMessenger",
        0,
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_IsolatedWindowsHostMessenger
    };

    // ----- IsolatedWindowsEnvironmentCreateProgress struct --------------------
    constexpr const char* const _type_name_IsolatedWindowsEnvironmentCreateProgress = "IsolatedWindowsEnvironmentCreateProgress";

    PyObject* _new_IsolatedWindowsEnvironmentCreateProgress(PyTypeObject* type, PyObject* args, PyObject* kwds)
    {
        auto tuple_size = PyTuple_Size(args);

        if ((tuple_size == 0) && (kwds == nullptr))
        {
            try
            {
                winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentCreateProgress return_value{};
                return py::convert(return_value);
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }

        if ((tuple_size == 1) && (kwds == nullptr))
        {
            auto arg = PyTuple_GetItem(args, 0);
            if (PyDict_Check(arg))
            {
                try
                {
                    auto return_value = py::convert_to<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentCreateProgress>(arg);
                    return py::convert(return_value);
                }
                catch (...)
                {
                    py::to_PyErr();
                    return nullptr;
                }
            }
        }

        int32_t _State{};
        uint32_t _PercentComplete{};

        static const char* kwlist[] = {"state", "percent_complete", nullptr};
        if (!PyArg_ParseTupleAndKeywords(args, kwds, "iI", const_cast<char**>(kwlist), &_State, &_PercentComplete))
        {
            return nullptr;
        }

        try
        {
            winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentCreateProgress return_value{ static_cast<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentProgressState>(_State), _PercentComplete };
            return py::convert(return_value);
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static void _dealloc_IsolatedWindowsEnvironmentCreateProgress(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentCreateProgress* self)
    {
    }

    static PyObject* IsolatedWindowsEnvironmentCreateProgress_get_State(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentCreateProgress* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.State);
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

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

        try
        {
            self->obj.State = py::converter<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentProgressState>::convert_to(arg);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyObject* IsolatedWindowsEnvironmentCreateProgress_get_PercentComplete(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentCreateProgress* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.PercentComplete);
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

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

        try
        {
            self->obj.PercentComplete = py::converter<uint32_t>::convert_to(arg);
            return 0;
        }
        catch (...)
        {
            py::to_PyErr();
            return -1;
        }
    }

    static PyGetSetDef _getset_IsolatedWindowsEnvironmentCreateProgress[] = {
        { "state", reinterpret_cast<getter>(IsolatedWindowsEnvironmentCreateProgress_get_State), reinterpret_cast<setter>(IsolatedWindowsEnvironmentCreateProgress_set_State), nullptr, nullptr },
        { "percent_complete", reinterpret_cast<getter>(IsolatedWindowsEnvironmentCreateProgress_get_PercentComplete), reinterpret_cast<setter>(IsolatedWindowsEnvironmentCreateProgress_set_PercentComplete), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_IsolatedWindowsEnvironmentCreateProgress[] = 
    {
        { Py_tp_new, _new_IsolatedWindowsEnvironmentCreateProgress },
        { Py_tp_dealloc, _dealloc_IsolatedWindowsEnvironmentCreateProgress },
        { Py_tp_getset, _getset_IsolatedWindowsEnvironmentCreateProgress },
        { },
    };

    static PyType_Spec _type_spec_IsolatedWindowsEnvironmentCreateProgress =
    {
        "_winsdk_Windows_Security_Isolation.IsolatedWindowsEnvironmentCreateProgress",
        sizeof(py::wrapper::Windows::Security::Isolation::IsolatedWindowsEnvironmentCreateProgress),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_IsolatedWindowsEnvironmentCreateProgress
    };

    // ----- Windows.Security.Isolation 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::Security::Isolation::IsolatedWindowsEnvironment>::python_type = py::register_python_type(module, _type_name_IsolatedWindowsEnvironment, &_type_spec_IsolatedWindowsEnvironment, bases.get());
            py::winrt_type<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentCreateResult>::python_type = py::register_python_type(module, _type_name_IsolatedWindowsEnvironmentCreateResult, &_type_spec_IsolatedWindowsEnvironmentCreateResult, bases.get());
            py::winrt_type<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentFile>::python_type = py::register_python_type(module, _type_name_IsolatedWindowsEnvironmentFile, &_type_spec_IsolatedWindowsEnvironmentFile, bases.get());
            py::winrt_type<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentHost>::python_type = py::register_python_type(module, _type_name_IsolatedWindowsEnvironmentHost, &_type_spec_IsolatedWindowsEnvironmentHost, nullptr);
            py::winrt_type<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentLaunchFileResult>::python_type = py::register_python_type(module, _type_name_IsolatedWindowsEnvironmentLaunchFileResult, &_type_spec_IsolatedWindowsEnvironmentLaunchFileResult, bases.get());
            py::winrt_type<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentOptions>::python_type = py::register_python_type(module, _type_name_IsolatedWindowsEnvironmentOptions, &_type_spec_IsolatedWindowsEnvironmentOptions, bases.get());
            py::winrt_type<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentOwnerRegistration>::python_type = py::register_python_type(module, _type_name_IsolatedWindowsEnvironmentOwnerRegistration, &_type_spec_IsolatedWindowsEnvironmentOwnerRegistration, nullptr);
            py::winrt_type<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentOwnerRegistrationData>::python_type = py::register_python_type(module, _type_name_IsolatedWindowsEnvironmentOwnerRegistrationData, &_type_spec_IsolatedWindowsEnvironmentOwnerRegistrationData, bases.get());
            py::winrt_type<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentOwnerRegistrationResult>::python_type = py::register_python_type(module, _type_name_IsolatedWindowsEnvironmentOwnerRegistrationResult, &_type_spec_IsolatedWindowsEnvironmentOwnerRegistrationResult, bases.get());
            py::winrt_type<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentPostMessageResult>::python_type = py::register_python_type(module, _type_name_IsolatedWindowsEnvironmentPostMessageResult, &_type_spec_IsolatedWindowsEnvironmentPostMessageResult, bases.get());
            py::winrt_type<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentProcess>::python_type = py::register_python_type(module, _type_name_IsolatedWindowsEnvironmentProcess, &_type_spec_IsolatedWindowsEnvironmentProcess, bases.get());
            py::winrt_type<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentShareFileRequestOptions>::python_type = py::register_python_type(module, _type_name_IsolatedWindowsEnvironmentShareFileRequestOptions, &_type_spec_IsolatedWindowsEnvironmentShareFileRequestOptions, bases.get());
            py::winrt_type<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentShareFileResult>::python_type = py::register_python_type(module, _type_name_IsolatedWindowsEnvironmentShareFileResult, &_type_spec_IsolatedWindowsEnvironmentShareFileResult, bases.get());
            py::winrt_type<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentShareFolderRequestOptions>::python_type = py::register_python_type(module, _type_name_IsolatedWindowsEnvironmentShareFolderRequestOptions, &_type_spec_IsolatedWindowsEnvironmentShareFolderRequestOptions, bases.get());
            py::winrt_type<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentShareFolderResult>::python_type = py::register_python_type(module, _type_name_IsolatedWindowsEnvironmentShareFolderResult, &_type_spec_IsolatedWindowsEnvironmentShareFolderResult, bases.get());
            py::winrt_type<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentStartProcessResult>::python_type = py::register_python_type(module, _type_name_IsolatedWindowsEnvironmentStartProcessResult, &_type_spec_IsolatedWindowsEnvironmentStartProcessResult, bases.get());
            py::winrt_type<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentTelemetryParameters>::python_type = py::register_python_type(module, _type_name_IsolatedWindowsEnvironmentTelemetryParameters, &_type_spec_IsolatedWindowsEnvironmentTelemetryParameters, bases.get());
            py::winrt_type<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentUserInfo>::python_type = py::register_python_type(module, _type_name_IsolatedWindowsEnvironmentUserInfo, &_type_spec_IsolatedWindowsEnvironmentUserInfo, bases.get());
            py::winrt_type<winrt::Windows::Security::Isolation::IsolatedWindowsHostMessenger>::python_type = py::register_python_type(module, _type_name_IsolatedWindowsHostMessenger, &_type_spec_IsolatedWindowsHostMessenger, nullptr);
            py::winrt_type<winrt::Windows::Security::Isolation::IsolatedWindowsEnvironmentCreateProgress>::python_type = py::register_python_type(module, _type_name_IsolatedWindowsEnvironmentCreateProgress, &_type_spec_IsolatedWindowsEnvironmentCreateProgress, 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.Security.Isolation");

    static PyModuleDef module_def
        = {PyModuleDef_HEAD_INIT,
           "_winsdk_Windows_Security_Isolation",
           module_doc,
           0,
           nullptr,
           module_slots,
           nullptr,
           nullptr,
           nullptr};
} // py::cpp::Windows::Security::Isolation

PyMODINIT_FUNC
PyInit__winsdk_Windows_Security_Isolation (void) noexcept
{
    return PyModuleDef_Init(&py::cpp::Windows::Security::Isolation::module_def);
}
