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

#include "pybase.h"
#include "py.Windows.Graphics.Printing.PrintSupport.h"


namespace py::cpp::Windows::Graphics::Printing::PrintSupport
{
    struct module_state
    {
        PyObject* type_SettingsLaunchKind;
        PyObject* type_WorkflowPrintTicketValidationStatus;
        PyTypeObject* type_PrintSupportExtensionSession;
        PyTypeObject* type_PrintSupportExtensionTriggerDetails;
        PyTypeObject* type_PrintSupportPrintDeviceCapabilitiesChangedEventArgs;
        PyTypeObject* type_PrintSupportPrintDeviceCapabilitiesUpdatePolicy;
        PyTypeObject* type_PrintSupportPrintTicketElement;
        PyTypeObject* type_PrintSupportPrintTicketValidationRequestedEventArgs;
        PyTypeObject* type_PrintSupportPrinterSelectedEventArgs;
        PyTypeObject* type_PrintSupportSessionInfo;
        PyTypeObject* type_PrintSupportSettingsActivatedEventArgs;
        PyTypeObject* type_PrintSupportSettingsUISession;
    };

    static PyObject* register_SettingsLaunchKind(PyObject* module, PyObject* type) noexcept
    {
        auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
        assert(state);

        if (state->type_SettingsLaunchKind)
        {
            PyErr_SetString(PyExc_RuntimeError, "type has already been registered");
            return nullptr;
        }

        if (!PyType_Check(type))
        {
            PyErr_SetString(PyExc_TypeError, "argument is not a type");
            return nullptr;
        }

        state->type_SettingsLaunchKind = type;
        Py_INCREF(state->type_SettingsLaunchKind);


        Py_RETURN_NONE;
    }

    static PyObject* register_WorkflowPrintTicketValidationStatus(PyObject* module, PyObject* type) noexcept
    {
        auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
        assert(state);

        if (state->type_WorkflowPrintTicketValidationStatus)
        {
            PyErr_SetString(PyExc_RuntimeError, "type has already been registered");
            return nullptr;
        }

        if (!PyType_Check(type))
        {
            PyErr_SetString(PyExc_TypeError, "argument is not a type");
            return nullptr;
        }

        state->type_WorkflowPrintTicketValidationStatus = type;
        Py_INCREF(state->type_WorkflowPrintTicketValidationStatus);


        Py_RETURN_NONE;
    }

    // ----- PrintSupportExtensionSession class --------------------
    static constexpr const char* const type_name_PrintSupportExtensionSession = "PrintSupportExtensionSession";

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

    static void _dealloc_PrintSupportExtensionSession(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportExtensionSession* self) noexcept
    {
        auto tp = Py_TYPE(self);

        if (PyType_IS_GC(tp))
        {
            PyObject_GC_UnTrack(self);
        }

        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* PrintSupportExtensionSession_Start(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportExtensionSession* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Printing.PrintSupport.PrintSupportExtensionSession", L"Start", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* PrintSupportExtensionSession_get_Printer(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportExtensionSession* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Printing.PrintSupport.PrintSupportExtensionSession", L"Printer"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* PrintSupportExtensionSession_add_PrintDeviceCapabilitiesChanged(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportExtensionSession* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.Graphics.Printing.PrintSupport.PrintSupportExtensionSession", L"PrintDeviceCapabilitiesChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Windows::Graphics::Printing::PrintSupport::PrintSupportExtensionSession, winrt::Windows::Graphics::Printing::PrintSupport::PrintSupportPrintDeviceCapabilitiesChangedEventArgs>>(arg);

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

    static PyObject* PrintSupportExtensionSession_remove_PrintDeviceCapabilitiesChanged(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportExtensionSession* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.Graphics.Printing.PrintSupport.PrintSupportExtensionSession", L"PrintDeviceCapabilitiesChanged"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* PrintSupportExtensionSession_add_PrintTicketValidationRequested(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportExtensionSession* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.Graphics.Printing.PrintSupport.PrintSupportExtensionSession", L"PrintTicketValidationRequested"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Windows::Graphics::Printing::PrintSupport::PrintSupportExtensionSession, winrt::Windows::Graphics::Printing::PrintSupport::PrintSupportPrintTicketValidationRequestedEventArgs>>(arg);

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

    static PyObject* PrintSupportExtensionSession_remove_PrintTicketValidationRequested(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportExtensionSession* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.Graphics.Printing.PrintSupport.PrintSupportExtensionSession", L"PrintTicketValidationRequested"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* PrintSupportExtensionSession_add_PrinterSelected(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportExtensionSession* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.Graphics.Printing.PrintSupport.PrintSupportExtensionSession", L"PrinterSelected"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Windows::Graphics::Printing::PrintSupport::PrintSupportExtensionSession, winrt::Windows::Graphics::Printing::PrintSupport::PrintSupportPrinterSelectedEventArgs>>(arg);

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

    static PyObject* PrintSupportExtensionSession_remove_PrinterSelected(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportExtensionSession* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.Graphics.Printing.PrintSupport.PrintSupportExtensionSession", L"PrinterSelected"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* _assign_array_PrintSupportExtensionSession(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Graphics::Printing::PrintSupport::PrintSupportExtensionSession>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_PrintSupportExtensionSession(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::Graphics::Printing::PrintSupport::PrintSupportExtensionSession>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_PrintSupportExtensionSession[] = {
        { "start", reinterpret_cast<PyCFunction>(PrintSupportExtensionSession_Start), METH_VARARGS, nullptr },
        { "add_print_device_capabilities_changed", reinterpret_cast<PyCFunction>(PrintSupportExtensionSession_add_PrintDeviceCapabilitiesChanged), METH_O, nullptr },
        { "remove_print_device_capabilities_changed", reinterpret_cast<PyCFunction>(PrintSupportExtensionSession_remove_PrintDeviceCapabilitiesChanged), METH_O, nullptr },
        { "add_print_ticket_validation_requested", reinterpret_cast<PyCFunction>(PrintSupportExtensionSession_add_PrintTicketValidationRequested), METH_O, nullptr },
        { "remove_print_ticket_validation_requested", reinterpret_cast<PyCFunction>(PrintSupportExtensionSession_remove_PrintTicketValidationRequested), METH_O, nullptr },
        { "add_printer_selected", reinterpret_cast<PyCFunction>(PrintSupportExtensionSession_add_PrinterSelected), METH_O, nullptr },
        { "remove_printer_selected", reinterpret_cast<PyCFunction>(PrintSupportExtensionSession_remove_PrinterSelected), METH_O, nullptr },
        { "_assign_array_", _assign_array_PrintSupportExtensionSession, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_PrintSupportExtensionSession), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_PrintSupportExtensionSession[] = {
        { "printer", reinterpret_cast<getter>(PrintSupportExtensionSession_get_Printer), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_PrintSupportExtensionSession[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_PrintSupportExtensionSession) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_PrintSupportExtensionSession) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_PrintSupportExtensionSession) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_PrintSupportExtensionSession) },
        { },
    };

    static PyType_Spec type_spec_PrintSupportExtensionSession =
    {
        "_winsdk_Windows_Graphics_Printing_PrintSupport.PrintSupportExtensionSession",
        sizeof(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportExtensionSession),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_PrintSupportExtensionSession
    };

    // ----- PrintSupportExtensionTriggerDetails class --------------------
    static constexpr const char* const type_name_PrintSupportExtensionTriggerDetails = "PrintSupportExtensionTriggerDetails";

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

    static void _dealloc_PrintSupportExtensionTriggerDetails(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportExtensionTriggerDetails* self) noexcept
    {
        auto tp = Py_TYPE(self);

        if (PyType_IS_GC(tp))
        {
            PyObject_GC_UnTrack(self);
        }

        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* PrintSupportExtensionTriggerDetails_get_Session(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportExtensionTriggerDetails* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Printing.PrintSupport.PrintSupportExtensionTriggerDetails", L"Session"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_PrintSupportExtensionTriggerDetails(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Graphics::Printing::PrintSupport::PrintSupportExtensionTriggerDetails>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_PrintSupportExtensionTriggerDetails(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::Graphics::Printing::PrintSupport::PrintSupportExtensionTriggerDetails>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_PrintSupportExtensionTriggerDetails[] = {
        { "_assign_array_", _assign_array_PrintSupportExtensionTriggerDetails, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_PrintSupportExtensionTriggerDetails), METH_O | METH_STATIC, nullptr },
        { }
    };

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

    static PyType_Slot _type_slots_PrintSupportExtensionTriggerDetails[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_PrintSupportExtensionTriggerDetails) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_PrintSupportExtensionTriggerDetails) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_PrintSupportExtensionTriggerDetails) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_PrintSupportExtensionTriggerDetails) },
        { },
    };

    static PyType_Spec type_spec_PrintSupportExtensionTriggerDetails =
    {
        "_winsdk_Windows_Graphics_Printing_PrintSupport.PrintSupportExtensionTriggerDetails",
        sizeof(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportExtensionTriggerDetails),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_PrintSupportExtensionTriggerDetails
    };

    // ----- PrintSupportPrintDeviceCapabilitiesChangedEventArgs class --------------------
    static constexpr const char* const type_name_PrintSupportPrintDeviceCapabilitiesChangedEventArgs = "PrintSupportPrintDeviceCapabilitiesChangedEventArgs";

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

    static void _dealloc_PrintSupportPrintDeviceCapabilitiesChangedEventArgs(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportPrintDeviceCapabilitiesChangedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);

        if (PyType_IS_GC(tp))
        {
            PyObject_GC_UnTrack(self);
        }

        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* PrintSupportPrintDeviceCapabilitiesChangedEventArgs_GetCurrentPrintDeviceCapabilities(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportPrintDeviceCapabilitiesChangedEventArgs* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Printing.PrintSupport.PrintSupportPrintDeviceCapabilitiesChangedEventArgs", L"GetCurrentPrintDeviceCapabilities", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* PrintSupportPrintDeviceCapabilitiesChangedEventArgs_GetCurrentPrintDeviceResources(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportPrintDeviceCapabilitiesChangedEventArgs* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Printing.PrintSupport.PrintSupportPrintDeviceCapabilitiesChangedEventArgs", L"GetCurrentPrintDeviceResources", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* PrintSupportPrintDeviceCapabilitiesChangedEventArgs_GetDeferral(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportPrintDeviceCapabilitiesChangedEventArgs* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Printing.PrintSupport.PrintSupportPrintDeviceCapabilitiesChangedEventArgs", L"GetDeferral", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* PrintSupportPrintDeviceCapabilitiesChangedEventArgs_SetPrintDeviceCapabilitiesUpdatePolicy(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportPrintDeviceCapabilitiesChangedEventArgs* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Printing.PrintSupport.PrintSupportPrintDeviceCapabilitiesChangedEventArgs", L"SetPrintDeviceCapabilitiesUpdatePolicy", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Graphics::Printing::PrintSupport::PrintSupportPrintDeviceCapabilitiesUpdatePolicy>(args, 0);

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

    static PyObject* PrintSupportPrintDeviceCapabilitiesChangedEventArgs_SetSupportedPdlPassthroughContentTypes(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportPrintDeviceCapabilitiesChangedEventArgs* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Printing.PrintSupport.PrintSupportPrintDeviceCapabilitiesChangedEventArgs", L"SetSupportedPdlPassthroughContentTypes", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

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

    static PyObject* PrintSupportPrintDeviceCapabilitiesChangedEventArgs_UpdatePrintDeviceCapabilities(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportPrintDeviceCapabilitiesChangedEventArgs* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Printing.PrintSupport.PrintSupportPrintDeviceCapabilitiesChangedEventArgs", L"UpdatePrintDeviceCapabilities", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Data::Xml::Dom::XmlDocument>(args, 0);

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

    static PyObject* PrintSupportPrintDeviceCapabilitiesChangedEventArgs_UpdatePrintDeviceResources(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportPrintDeviceCapabilitiesChangedEventArgs* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Printing.PrintSupport.PrintSupportPrintDeviceCapabilitiesChangedEventArgs", L"UpdatePrintDeviceResources", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Data::Xml::Dom::XmlDocument>(args, 0);

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

    static PyObject* PrintSupportPrintDeviceCapabilitiesChangedEventArgs_get_ResourceLanguage(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportPrintDeviceCapabilitiesChangedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Printing.PrintSupport.PrintSupportPrintDeviceCapabilitiesChangedEventArgs", L"ResourceLanguage"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_PrintSupportPrintDeviceCapabilitiesChangedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Graphics::Printing::PrintSupport::PrintSupportPrintDeviceCapabilitiesChangedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_PrintSupportPrintDeviceCapabilitiesChangedEventArgs(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::Graphics::Printing::PrintSupport::PrintSupportPrintDeviceCapabilitiesChangedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_PrintSupportPrintDeviceCapabilitiesChangedEventArgs[] = {
        { "get_current_print_device_capabilities", reinterpret_cast<PyCFunction>(PrintSupportPrintDeviceCapabilitiesChangedEventArgs_GetCurrentPrintDeviceCapabilities), METH_VARARGS, nullptr },
        { "get_current_print_device_resources", reinterpret_cast<PyCFunction>(PrintSupportPrintDeviceCapabilitiesChangedEventArgs_GetCurrentPrintDeviceResources), METH_VARARGS, nullptr },
        { "get_deferral", reinterpret_cast<PyCFunction>(PrintSupportPrintDeviceCapabilitiesChangedEventArgs_GetDeferral), METH_VARARGS, nullptr },
        { "set_print_device_capabilities_update_policy", reinterpret_cast<PyCFunction>(PrintSupportPrintDeviceCapabilitiesChangedEventArgs_SetPrintDeviceCapabilitiesUpdatePolicy), METH_VARARGS, nullptr },
        { "set_supported_pdl_passthrough_content_types", reinterpret_cast<PyCFunction>(PrintSupportPrintDeviceCapabilitiesChangedEventArgs_SetSupportedPdlPassthroughContentTypes), METH_VARARGS, nullptr },
        { "update_print_device_capabilities", reinterpret_cast<PyCFunction>(PrintSupportPrintDeviceCapabilitiesChangedEventArgs_UpdatePrintDeviceCapabilities), METH_VARARGS, nullptr },
        { "update_print_device_resources", reinterpret_cast<PyCFunction>(PrintSupportPrintDeviceCapabilitiesChangedEventArgs_UpdatePrintDeviceResources), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_PrintSupportPrintDeviceCapabilitiesChangedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_PrintSupportPrintDeviceCapabilitiesChangedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_PrintSupportPrintDeviceCapabilitiesChangedEventArgs[] = {
        { "resource_language", reinterpret_cast<getter>(PrintSupportPrintDeviceCapabilitiesChangedEventArgs_get_ResourceLanguage), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_PrintSupportPrintDeviceCapabilitiesChangedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_PrintSupportPrintDeviceCapabilitiesChangedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_PrintSupportPrintDeviceCapabilitiesChangedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_PrintSupportPrintDeviceCapabilitiesChangedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_PrintSupportPrintDeviceCapabilitiesChangedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_PrintSupportPrintDeviceCapabilitiesChangedEventArgs =
    {
        "_winsdk_Windows_Graphics_Printing_PrintSupport.PrintSupportPrintDeviceCapabilitiesChangedEventArgs",
        sizeof(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportPrintDeviceCapabilitiesChangedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_PrintSupportPrintDeviceCapabilitiesChangedEventArgs
    };

    // ----- PrintSupportPrintDeviceCapabilitiesUpdatePolicy class --------------------
    static constexpr const char* const type_name_PrintSupportPrintDeviceCapabilitiesUpdatePolicy = "PrintSupportPrintDeviceCapabilitiesUpdatePolicy";

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

    static void _dealloc_PrintSupportPrintDeviceCapabilitiesUpdatePolicy(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportPrintDeviceCapabilitiesUpdatePolicy* self) noexcept
    {
        auto tp = Py_TYPE(self);

        if (PyType_IS_GC(tp))
        {
            PyObject_GC_UnTrack(self);
        }

        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* PrintSupportPrintDeviceCapabilitiesUpdatePolicy_CreatePeriodicRefresh(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Printing.PrintSupport.PrintSupportPrintDeviceCapabilitiesUpdatePolicy", L"CreatePeriodicRefresh", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Foundation::TimeSpan>(args, 0);

                return py::convert(winrt::Windows::Graphics::Printing::PrintSupport::PrintSupportPrintDeviceCapabilitiesUpdatePolicy::CreatePeriodicRefresh(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* PrintSupportPrintDeviceCapabilitiesUpdatePolicy_CreatePrintJobRefresh(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Printing.PrintSupport.PrintSupportPrintDeviceCapabilitiesUpdatePolicy", L"CreatePrintJobRefresh", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

                return py::convert(winrt::Windows::Graphics::Printing::PrintSupport::PrintSupportPrintDeviceCapabilitiesUpdatePolicy::CreatePrintJobRefresh(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* _assign_array_PrintSupportPrintDeviceCapabilitiesUpdatePolicy(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Graphics::Printing::PrintSupport::PrintSupportPrintDeviceCapabilitiesUpdatePolicy>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_PrintSupportPrintDeviceCapabilitiesUpdatePolicy(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::Graphics::Printing::PrintSupport::PrintSupportPrintDeviceCapabilitiesUpdatePolicy>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_PrintSupportPrintDeviceCapabilitiesUpdatePolicy[] = {
        { "create_periodic_refresh", reinterpret_cast<PyCFunction>(PrintSupportPrintDeviceCapabilitiesUpdatePolicy_CreatePeriodicRefresh), METH_VARARGS | METH_STATIC, nullptr },
        { "create_print_job_refresh", reinterpret_cast<PyCFunction>(PrintSupportPrintDeviceCapabilitiesUpdatePolicy_CreatePrintJobRefresh), METH_VARARGS | METH_STATIC, nullptr },
        { "_assign_array_", _assign_array_PrintSupportPrintDeviceCapabilitiesUpdatePolicy, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_PrintSupportPrintDeviceCapabilitiesUpdatePolicy), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_PrintSupportPrintDeviceCapabilitiesUpdatePolicy[] = {
        { }
    };

    static PyType_Slot _type_slots_PrintSupportPrintDeviceCapabilitiesUpdatePolicy[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_PrintSupportPrintDeviceCapabilitiesUpdatePolicy) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_PrintSupportPrintDeviceCapabilitiesUpdatePolicy) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_PrintSupportPrintDeviceCapabilitiesUpdatePolicy) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_PrintSupportPrintDeviceCapabilitiesUpdatePolicy) },
        { },
    };

    static PyType_Spec type_spec_PrintSupportPrintDeviceCapabilitiesUpdatePolicy =
    {
        "_winsdk_Windows_Graphics_Printing_PrintSupport.PrintSupportPrintDeviceCapabilitiesUpdatePolicy",
        sizeof(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportPrintDeviceCapabilitiesUpdatePolicy),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_PrintSupportPrintDeviceCapabilitiesUpdatePolicy
    };

    // ----- PrintSupportPrintTicketElement class --------------------
    static constexpr const char* const type_name_PrintSupportPrintTicketElement = "PrintSupportPrintTicketElement";

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

        auto arg_count = PyTuple_Size(args);
        if (arg_count == 0)
        {
            try
            {
                winrt::Windows::Graphics::Printing::PrintSupport::PrintSupportPrintTicketElement 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_PrintSupportPrintTicketElement(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportPrintTicketElement* self) noexcept
    {
        auto tp = Py_TYPE(self);

        if (PyType_IS_GC(tp))
        {
            PyObject_GC_UnTrack(self);
        }

        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* PrintSupportPrintTicketElement_get_NamespaceUri(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportPrintTicketElement* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Printing.PrintSupport.PrintSupportPrintTicketElement", L"NamespaceUri"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int PrintSupportPrintTicketElement_put_NamespaceUri(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportPrintTicketElement* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Printing.PrintSupport.PrintSupportPrintTicketElement", L"NamespaceUri"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

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

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

    static PyObject* PrintSupportPrintTicketElement_get_LocalName(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportPrintTicketElement* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Printing.PrintSupport.PrintSupportPrintTicketElement", L"LocalName"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int PrintSupportPrintTicketElement_put_LocalName(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportPrintTicketElement* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Printing.PrintSupport.PrintSupportPrintTicketElement", L"LocalName"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

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

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

    static PyObject* _assign_array_PrintSupportPrintTicketElement(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Graphics::Printing::PrintSupport::PrintSupportPrintTicketElement>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_PrintSupportPrintTicketElement(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::Graphics::Printing::PrintSupport::PrintSupportPrintTicketElement>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_PrintSupportPrintTicketElement[] = {
        { "_assign_array_", _assign_array_PrintSupportPrintTicketElement, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_PrintSupportPrintTicketElement), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_PrintSupportPrintTicketElement[] = {
        { "namespace_uri", reinterpret_cast<getter>(PrintSupportPrintTicketElement_get_NamespaceUri), reinterpret_cast<setter>(PrintSupportPrintTicketElement_put_NamespaceUri), nullptr, nullptr },
        { "local_name", reinterpret_cast<getter>(PrintSupportPrintTicketElement_get_LocalName), reinterpret_cast<setter>(PrintSupportPrintTicketElement_put_LocalName), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_PrintSupportPrintTicketElement[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_PrintSupportPrintTicketElement) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_PrintSupportPrintTicketElement) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_PrintSupportPrintTicketElement) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_PrintSupportPrintTicketElement) },
        { },
    };

    static PyType_Spec type_spec_PrintSupportPrintTicketElement =
    {
        "_winsdk_Windows_Graphics_Printing_PrintSupport.PrintSupportPrintTicketElement",
        sizeof(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportPrintTicketElement),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_PrintSupportPrintTicketElement
    };

    // ----- PrintSupportPrintTicketValidationRequestedEventArgs class --------------------
    static constexpr const char* const type_name_PrintSupportPrintTicketValidationRequestedEventArgs = "PrintSupportPrintTicketValidationRequestedEventArgs";

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

    static void _dealloc_PrintSupportPrintTicketValidationRequestedEventArgs(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportPrintTicketValidationRequestedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);

        if (PyType_IS_GC(tp))
        {
            PyObject_GC_UnTrack(self);
        }

        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* PrintSupportPrintTicketValidationRequestedEventArgs_GetDeferral(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportPrintTicketValidationRequestedEventArgs* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Printing.PrintSupport.PrintSupportPrintTicketValidationRequestedEventArgs", L"GetDeferral", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* PrintSupportPrintTicketValidationRequestedEventArgs_SetPrintTicketValidationStatus(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportPrintTicketValidationRequestedEventArgs* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Printing.PrintSupport.PrintSupportPrintTicketValidationRequestedEventArgs", L"SetPrintTicketValidationStatus", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Graphics::Printing::PrintSupport::WorkflowPrintTicketValidationStatus>(args, 0);

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

    static PyObject* PrintSupportPrintTicketValidationRequestedEventArgs_get_PrintTicket(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportPrintTicketValidationRequestedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Printing.PrintSupport.PrintSupportPrintTicketValidationRequestedEventArgs", L"PrintTicket"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_PrintSupportPrintTicketValidationRequestedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Graphics::Printing::PrintSupport::PrintSupportPrintTicketValidationRequestedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_PrintSupportPrintTicketValidationRequestedEventArgs(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::Graphics::Printing::PrintSupport::PrintSupportPrintTicketValidationRequestedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_PrintSupportPrintTicketValidationRequestedEventArgs[] = {
        { "get_deferral", reinterpret_cast<PyCFunction>(PrintSupportPrintTicketValidationRequestedEventArgs_GetDeferral), METH_VARARGS, nullptr },
        { "set_print_ticket_validation_status", reinterpret_cast<PyCFunction>(PrintSupportPrintTicketValidationRequestedEventArgs_SetPrintTicketValidationStatus), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_PrintSupportPrintTicketValidationRequestedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_PrintSupportPrintTicketValidationRequestedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_PrintSupportPrintTicketValidationRequestedEventArgs[] = {
        { "print_ticket", reinterpret_cast<getter>(PrintSupportPrintTicketValidationRequestedEventArgs_get_PrintTicket), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_PrintSupportPrintTicketValidationRequestedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_PrintSupportPrintTicketValidationRequestedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_PrintSupportPrintTicketValidationRequestedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_PrintSupportPrintTicketValidationRequestedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_PrintSupportPrintTicketValidationRequestedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_PrintSupportPrintTicketValidationRequestedEventArgs =
    {
        "_winsdk_Windows_Graphics_Printing_PrintSupport.PrintSupportPrintTicketValidationRequestedEventArgs",
        sizeof(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportPrintTicketValidationRequestedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_PrintSupportPrintTicketValidationRequestedEventArgs
    };

    // ----- PrintSupportPrinterSelectedEventArgs class --------------------
    static constexpr const char* const type_name_PrintSupportPrinterSelectedEventArgs = "PrintSupportPrinterSelectedEventArgs";

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

    static void _dealloc_PrintSupportPrinterSelectedEventArgs(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportPrinterSelectedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);

        if (PyType_IS_GC(tp))
        {
            PyObject_GC_UnTrack(self);
        }

        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* PrintSupportPrinterSelectedEventArgs_GetDeferral(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportPrinterSelectedEventArgs* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Printing.PrintSupport.PrintSupportPrinterSelectedEventArgs", L"GetDeferral", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* PrintSupportPrinterSelectedEventArgs_SetAdaptiveCard(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportPrinterSelectedEventArgs* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Printing.PrintSupport.PrintSupportPrinterSelectedEventArgs", L"SetAdaptiveCard", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::UI::Shell::IAdaptiveCard>(args, 0);

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

    static PyObject* PrintSupportPrinterSelectedEventArgs_SetAdditionalFeatures(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportPrinterSelectedEventArgs* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Printing.PrintSupport.PrintSupportPrinterSelectedEventArgs", L"SetAdditionalFeatures", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Foundation::Collections::IIterable<winrt::Windows::Graphics::Printing::PrintSupport::PrintSupportPrintTicketElement>>(args, 0);

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

    static PyObject* PrintSupportPrinterSelectedEventArgs_SetAdditionalParameters(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportPrinterSelectedEventArgs* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Printing.PrintSupport.PrintSupportPrinterSelectedEventArgs", L"SetAdditionalParameters", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Foundation::Collections::IIterable<winrt::Windows::Graphics::Printing::PrintSupport::PrintSupportPrintTicketElement>>(args, 0);

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

    static PyObject* PrintSupportPrinterSelectedEventArgs_get_PrintTicket(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportPrinterSelectedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Printing.PrintSupport.PrintSupportPrinterSelectedEventArgs", L"PrintTicket"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int PrintSupportPrinterSelectedEventArgs_put_PrintTicket(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportPrinterSelectedEventArgs* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Printing.PrintSupport.PrintSupportPrinterSelectedEventArgs", L"PrintTicket"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

        if (arg == nullptr)
        {
            PyErr_SetString(PyExc_AttributeError, "can't delete attribute");
            return -1;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Graphics::Printing::PrintTicket::WorkflowPrintTicket>(arg);

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

    static PyObject* PrintSupportPrinterSelectedEventArgs_get_AllowedAdditionalFeaturesAndParametersCount(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportPrinterSelectedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Printing.PrintSupport.PrintSupportPrinterSelectedEventArgs", L"AllowedAdditionalFeaturesAndParametersCount"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* PrintSupportPrinterSelectedEventArgs_get_SourceAppInfo(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportPrinterSelectedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Printing.PrintSupport.PrintSupportPrinterSelectedEventArgs", L"SourceAppInfo"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_PrintSupportPrinterSelectedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Graphics::Printing::PrintSupport::PrintSupportPrinterSelectedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_PrintSupportPrinterSelectedEventArgs(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::Graphics::Printing::PrintSupport::PrintSupportPrinterSelectedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_PrintSupportPrinterSelectedEventArgs[] = {
        { "get_deferral", reinterpret_cast<PyCFunction>(PrintSupportPrinterSelectedEventArgs_GetDeferral), METH_VARARGS, nullptr },
        { "set_adaptive_card", reinterpret_cast<PyCFunction>(PrintSupportPrinterSelectedEventArgs_SetAdaptiveCard), METH_VARARGS, nullptr },
        { "set_additional_features", reinterpret_cast<PyCFunction>(PrintSupportPrinterSelectedEventArgs_SetAdditionalFeatures), METH_VARARGS, nullptr },
        { "set_additional_parameters", reinterpret_cast<PyCFunction>(PrintSupportPrinterSelectedEventArgs_SetAdditionalParameters), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_PrintSupportPrinterSelectedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_PrintSupportPrinterSelectedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_PrintSupportPrinterSelectedEventArgs[] = {
        { "print_ticket", reinterpret_cast<getter>(PrintSupportPrinterSelectedEventArgs_get_PrintTicket), reinterpret_cast<setter>(PrintSupportPrinterSelectedEventArgs_put_PrintTicket), nullptr, nullptr },
        { "allowed_additional_features_and_parameters_count", reinterpret_cast<getter>(PrintSupportPrinterSelectedEventArgs_get_AllowedAdditionalFeaturesAndParametersCount), nullptr, nullptr, nullptr },
        { "source_app_info", reinterpret_cast<getter>(PrintSupportPrinterSelectedEventArgs_get_SourceAppInfo), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_PrintSupportPrinterSelectedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_PrintSupportPrinterSelectedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_PrintSupportPrinterSelectedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_PrintSupportPrinterSelectedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_PrintSupportPrinterSelectedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_PrintSupportPrinterSelectedEventArgs =
    {
        "_winsdk_Windows_Graphics_Printing_PrintSupport.PrintSupportPrinterSelectedEventArgs",
        sizeof(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportPrinterSelectedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_PrintSupportPrinterSelectedEventArgs
    };

    // ----- PrintSupportSessionInfo class --------------------
    static constexpr const char* const type_name_PrintSupportSessionInfo = "PrintSupportSessionInfo";

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

    static void _dealloc_PrintSupportSessionInfo(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportSessionInfo* self) noexcept
    {
        auto tp = Py_TYPE(self);

        if (PyType_IS_GC(tp))
        {
            PyObject_GC_UnTrack(self);
        }

        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* PrintSupportSessionInfo_get_Printer(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportSessionInfo* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Printing.PrintSupport.PrintSupportSessionInfo", L"Printer"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* PrintSupportSessionInfo_get_SourceAppInfo(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportSessionInfo* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Printing.PrintSupport.PrintSupportSessionInfo", L"SourceAppInfo"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_PrintSupportSessionInfo(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Graphics::Printing::PrintSupport::PrintSupportSessionInfo>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_PrintSupportSessionInfo(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::Graphics::Printing::PrintSupport::PrintSupportSessionInfo>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_PrintSupportSessionInfo[] = {
        { "_assign_array_", _assign_array_PrintSupportSessionInfo, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_PrintSupportSessionInfo), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_PrintSupportSessionInfo[] = {
        { "printer", reinterpret_cast<getter>(PrintSupportSessionInfo_get_Printer), nullptr, nullptr, nullptr },
        { "source_app_info", reinterpret_cast<getter>(PrintSupportSessionInfo_get_SourceAppInfo), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_PrintSupportSessionInfo[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_PrintSupportSessionInfo) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_PrintSupportSessionInfo) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_PrintSupportSessionInfo) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_PrintSupportSessionInfo) },
        { },
    };

    static PyType_Spec type_spec_PrintSupportSessionInfo =
    {
        "_winsdk_Windows_Graphics_Printing_PrintSupport.PrintSupportSessionInfo",
        sizeof(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportSessionInfo),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_PrintSupportSessionInfo
    };

    // ----- PrintSupportSettingsActivatedEventArgs class --------------------
    static constexpr const char* const type_name_PrintSupportSettingsActivatedEventArgs = "PrintSupportSettingsActivatedEventArgs";

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

    static void _dealloc_PrintSupportSettingsActivatedEventArgs(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportSettingsActivatedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);

        if (PyType_IS_GC(tp))
        {
            PyObject_GC_UnTrack(self);
        }

        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* PrintSupportSettingsActivatedEventArgs_GetDeferral(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportSettingsActivatedEventArgs* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Printing.PrintSupport.PrintSupportSettingsActivatedEventArgs", L"GetDeferral", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* PrintSupportSettingsActivatedEventArgs_get_Kind(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportSettingsActivatedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Printing.PrintSupport.PrintSupportSettingsActivatedEventArgs", L"Kind"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* PrintSupportSettingsActivatedEventArgs_get_PreviousExecutionState(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportSettingsActivatedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Printing.PrintSupport.PrintSupportSettingsActivatedEventArgs", L"PreviousExecutionState"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* PrintSupportSettingsActivatedEventArgs_get_SplashScreen(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportSettingsActivatedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Printing.PrintSupport.PrintSupportSettingsActivatedEventArgs", L"SplashScreen"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* PrintSupportSettingsActivatedEventArgs_get_User(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportSettingsActivatedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Printing.PrintSupport.PrintSupportSettingsActivatedEventArgs", L"User"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* PrintSupportSettingsActivatedEventArgs_get_Session(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportSettingsActivatedEventArgs* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Printing.PrintSupport.PrintSupportSettingsActivatedEventArgs", L"Session"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_PrintSupportSettingsActivatedEventArgs(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Graphics::Printing::PrintSupport::PrintSupportSettingsActivatedEventArgs>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_PrintSupportSettingsActivatedEventArgs(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::Graphics::Printing::PrintSupport::PrintSupportSettingsActivatedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_PrintSupportSettingsActivatedEventArgs[] = {
        { "get_deferral", reinterpret_cast<PyCFunction>(PrintSupportSettingsActivatedEventArgs_GetDeferral), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_PrintSupportSettingsActivatedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_PrintSupportSettingsActivatedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_PrintSupportSettingsActivatedEventArgs[] = {
        { "kind", reinterpret_cast<getter>(PrintSupportSettingsActivatedEventArgs_get_Kind), nullptr, nullptr, nullptr },
        { "previous_execution_state", reinterpret_cast<getter>(PrintSupportSettingsActivatedEventArgs_get_PreviousExecutionState), nullptr, nullptr, nullptr },
        { "splash_screen", reinterpret_cast<getter>(PrintSupportSettingsActivatedEventArgs_get_SplashScreen), nullptr, nullptr, nullptr },
        { "user", reinterpret_cast<getter>(PrintSupportSettingsActivatedEventArgs_get_User), nullptr, nullptr, nullptr },
        { "session", reinterpret_cast<getter>(PrintSupportSettingsActivatedEventArgs_get_Session), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_PrintSupportSettingsActivatedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_PrintSupportSettingsActivatedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_PrintSupportSettingsActivatedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_PrintSupportSettingsActivatedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_PrintSupportSettingsActivatedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_PrintSupportSettingsActivatedEventArgs =
    {
        "_winsdk_Windows_Graphics_Printing_PrintSupport.PrintSupportSettingsActivatedEventArgs",
        sizeof(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportSettingsActivatedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_PrintSupportSettingsActivatedEventArgs
    };

    // ----- PrintSupportSettingsUISession class --------------------
    static constexpr const char* const type_name_PrintSupportSettingsUISession = "PrintSupportSettingsUISession";

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

    static void _dealloc_PrintSupportSettingsUISession(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportSettingsUISession* self) noexcept
    {
        auto tp = Py_TYPE(self);

        if (PyType_IS_GC(tp))
        {
            PyObject_GC_UnTrack(self);
        }

        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* PrintSupportSettingsUISession_UpdatePrintTicket(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportSettingsUISession* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Graphics.Printing.PrintSupport.PrintSupportSettingsUISession", L"UpdatePrintTicket", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Graphics::Printing::PrintTicket::WorkflowPrintTicket>(args, 0);

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

    static PyObject* PrintSupportSettingsUISession_get_DocumentTitle(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportSettingsUISession* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Printing.PrintSupport.PrintSupportSettingsUISession", L"DocumentTitle"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* PrintSupportSettingsUISession_get_LaunchKind(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportSettingsUISession* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Printing.PrintSupport.PrintSupportSettingsUISession", L"LaunchKind"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* PrintSupportSettingsUISession_get_SessionInfo(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportSettingsUISession* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Printing.PrintSupport.PrintSupportSettingsUISession", L"SessionInfo"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* PrintSupportSettingsUISession_get_SessionPrintTicket(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportSettingsUISession* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Graphics.Printing.PrintSupport.PrintSupportSettingsUISession", L"SessionPrintTicket"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_PrintSupportSettingsUISession(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Graphics::Printing::PrintSupport::PrintSupportSettingsUISession>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_PrintSupportSettingsUISession(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::Graphics::Printing::PrintSupport::PrintSupportSettingsUISession>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_PrintSupportSettingsUISession[] = {
        { "update_print_ticket", reinterpret_cast<PyCFunction>(PrintSupportSettingsUISession_UpdatePrintTicket), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_PrintSupportSettingsUISession, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_PrintSupportSettingsUISession), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_PrintSupportSettingsUISession[] = {
        { "document_title", reinterpret_cast<getter>(PrintSupportSettingsUISession_get_DocumentTitle), nullptr, nullptr, nullptr },
        { "launch_kind", reinterpret_cast<getter>(PrintSupportSettingsUISession_get_LaunchKind), nullptr, nullptr, nullptr },
        { "session_info", reinterpret_cast<getter>(PrintSupportSettingsUISession_get_SessionInfo), nullptr, nullptr, nullptr },
        { "session_print_ticket", reinterpret_cast<getter>(PrintSupportSettingsUISession_get_SessionPrintTicket), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_PrintSupportSettingsUISession[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_PrintSupportSettingsUISession) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_PrintSupportSettingsUISession) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_PrintSupportSettingsUISession) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_PrintSupportSettingsUISession) },
        { },
    };

    static PyType_Spec type_spec_PrintSupportSettingsUISession =
    {
        "_winsdk_Windows_Graphics_Printing_PrintSupport.PrintSupportSettingsUISession",
        sizeof(py::wrapper::Windows::Graphics::Printing::PrintSupport::PrintSupportSettingsUISession),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_PrintSupportSettingsUISession
    };

    // ----- Windows.Graphics.Printing.PrintSupport Initialization --------------------
    PyDoc_STRVAR(module_doc, "Windows::Graphics::Printing::PrintSupport");

    static PyMethodDef module_methods[] = {
        {"_register_SettingsLaunchKind", register_SettingsLaunchKind, METH_O, "registers type"},
        {"_register_WorkflowPrintTicketValidationStatus", register_WorkflowPrintTicketValidationStatus, METH_O, "registers type"},
        {}};


    static int module_traverse(PyObject* module, visitproc visit, void* arg) noexcept
    {
        auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));

        if (!state)
        {
            return 0;
        }

        Py_VISIT(state->type_SettingsLaunchKind);
        Py_VISIT(state->type_WorkflowPrintTicketValidationStatus);
        Py_VISIT(state->type_PrintSupportExtensionSession);
        Py_VISIT(state->type_PrintSupportExtensionTriggerDetails);
        Py_VISIT(state->type_PrintSupportPrintDeviceCapabilitiesChangedEventArgs);
        Py_VISIT(state->type_PrintSupportPrintDeviceCapabilitiesUpdatePolicy);
        Py_VISIT(state->type_PrintSupportPrintTicketElement);
        Py_VISIT(state->type_PrintSupportPrintTicketValidationRequestedEventArgs);
        Py_VISIT(state->type_PrintSupportPrinterSelectedEventArgs);
        Py_VISIT(state->type_PrintSupportSessionInfo);
        Py_VISIT(state->type_PrintSupportSettingsActivatedEventArgs);
        Py_VISIT(state->type_PrintSupportSettingsUISession);

        return 0;
    }

    static int module_clear(PyObject* module) noexcept
    {
        auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));

        if (!state)
        {
            return 0;
        }

        Py_CLEAR(state->type_SettingsLaunchKind);
        Py_CLEAR(state->type_WorkflowPrintTicketValidationStatus);
        Py_CLEAR(state->type_PrintSupportExtensionSession);
        Py_CLEAR(state->type_PrintSupportExtensionTriggerDetails);
        Py_CLEAR(state->type_PrintSupportPrintDeviceCapabilitiesChangedEventArgs);
        Py_CLEAR(state->type_PrintSupportPrintDeviceCapabilitiesUpdatePolicy);
        Py_CLEAR(state->type_PrintSupportPrintTicketElement);
        Py_CLEAR(state->type_PrintSupportPrintTicketValidationRequestedEventArgs);
        Py_CLEAR(state->type_PrintSupportPrinterSelectedEventArgs);
        Py_CLEAR(state->type_PrintSupportSessionInfo);
        Py_CLEAR(state->type_PrintSupportSettingsActivatedEventArgs);
        Py_CLEAR(state->type_PrintSupportSettingsUISession);

        return 0;
    }


    static PyModuleDef module_def
        = {PyModuleDef_HEAD_INIT,
           "_winsdk_Windows_Graphics_Printing_PrintSupport",
           module_doc,
           sizeof(module_state),
           module_methods,
           nullptr,
           module_traverse,
           module_clear,
           nullptr};

} // py::cpp::Windows::Graphics::Printing::PrintSupport

PyMODINIT_FUNC PyInit__winsdk_Windows_Graphics_Printing_PrintSupport(void) noexcept
{
    using namespace py::cpp::Windows::Graphics::Printing::PrintSupport;

    py::pyobj_handle module{PyModule_Create(&module_def)};

    if (!module)
    {
        return nullptr;
    }

    auto object_type = py::get_python_type<py::Object>();
    if (!object_type)
    {
        return nullptr;
    }

    py::pyobj_handle bases{PyTuple_Pack(1, object_type)};

    if (!bases)
    {
        return nullptr;
    }

    py::pyobj_handle collections_abc_module{PyImport_ImportModule("collections.abc")};

    if (!collections_abc_module)
    {
        return nullptr;
    }

    py::pyobj_handle sequence_type{PyObject_GetAttrString(collections_abc_module.get(), "Sequence")};

    if (!sequence_type)
    {
        return nullptr;
    }

    py::pyobj_handle sequence_bases{PyTuple_Pack(2, object_type, sequence_type.get())};

    if (!sequence_bases)
    {
        return nullptr;
    }

    py::pyobj_handle mutable_sequence_type{PyObject_GetAttrString(collections_abc_module.get(), "MutableSequence")};

    if (!mutable_sequence_type)
    {
        return nullptr;
    }

    py::pyobj_handle mutable_sequence_bases{PyTuple_Pack(2, object_type, mutable_sequence_type.get())};

    if (!mutable_sequence_bases)
    {
        return nullptr;
    }

    py::pyobj_handle mapping_type{PyObject_GetAttrString(collections_abc_module.get(), "Mapping")};

    if (!mapping_type)
    {
        return nullptr;
    }

    py::pyobj_handle mapping_bases{PyTuple_Pack(2, object_type, mapping_type.get())};

    if (!mapping_bases)
    {
        return nullptr;
    }

    py::pyobj_handle mutable_mapping_type{PyObject_GetAttrString(collections_abc_module.get(), "MutableMapping")};

    if (!mutable_mapping_type)
    {
        return nullptr;
    }

    py::pyobj_handle mutable_mapping_bases{PyTuple_Pack(2, object_type, mutable_mapping_type.get())};

    if (!mutable_mapping_bases)
    {
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module.get()));
    assert(state);

    state->type_PrintSupportExtensionSession = py::register_python_type(module.get(), type_name_PrintSupportExtensionSession, &type_spec_PrintSupportExtensionSession, bases.get(), nullptr);
    if (!state->type_PrintSupportExtensionSession)
    {
        return nullptr;
    }

    state->type_PrintSupportExtensionTriggerDetails = py::register_python_type(module.get(), type_name_PrintSupportExtensionTriggerDetails, &type_spec_PrintSupportExtensionTriggerDetails, bases.get(), nullptr);
    if (!state->type_PrintSupportExtensionTriggerDetails)
    {
        return nullptr;
    }

    state->type_PrintSupportPrintDeviceCapabilitiesChangedEventArgs = py::register_python_type(module.get(), type_name_PrintSupportPrintDeviceCapabilitiesChangedEventArgs, &type_spec_PrintSupportPrintDeviceCapabilitiesChangedEventArgs, bases.get(), nullptr);
    if (!state->type_PrintSupportPrintDeviceCapabilitiesChangedEventArgs)
    {
        return nullptr;
    }

    state->type_PrintSupportPrintDeviceCapabilitiesUpdatePolicy = py::register_python_type(module.get(), type_name_PrintSupportPrintDeviceCapabilitiesUpdatePolicy, &type_spec_PrintSupportPrintDeviceCapabilitiesUpdatePolicy, bases.get(), nullptr);
    if (!state->type_PrintSupportPrintDeviceCapabilitiesUpdatePolicy)
    {
        return nullptr;
    }

    state->type_PrintSupportPrintTicketElement = py::register_python_type(module.get(), type_name_PrintSupportPrintTicketElement, &type_spec_PrintSupportPrintTicketElement, bases.get(), nullptr);
    if (!state->type_PrintSupportPrintTicketElement)
    {
        return nullptr;
    }

    state->type_PrintSupportPrintTicketValidationRequestedEventArgs = py::register_python_type(module.get(), type_name_PrintSupportPrintTicketValidationRequestedEventArgs, &type_spec_PrintSupportPrintTicketValidationRequestedEventArgs, bases.get(), nullptr);
    if (!state->type_PrintSupportPrintTicketValidationRequestedEventArgs)
    {
        return nullptr;
    }

    state->type_PrintSupportPrinterSelectedEventArgs = py::register_python_type(module.get(), type_name_PrintSupportPrinterSelectedEventArgs, &type_spec_PrintSupportPrinterSelectedEventArgs, bases.get(), nullptr);
    if (!state->type_PrintSupportPrinterSelectedEventArgs)
    {
        return nullptr;
    }

    state->type_PrintSupportSessionInfo = py::register_python_type(module.get(), type_name_PrintSupportSessionInfo, &type_spec_PrintSupportSessionInfo, bases.get(), nullptr);
    if (!state->type_PrintSupportSessionInfo)
    {
        return nullptr;
    }

    state->type_PrintSupportSettingsActivatedEventArgs = py::register_python_type(module.get(), type_name_PrintSupportSettingsActivatedEventArgs, &type_spec_PrintSupportSettingsActivatedEventArgs, bases.get(), nullptr);
    if (!state->type_PrintSupportSettingsActivatedEventArgs)
    {
        return nullptr;
    }

    state->type_PrintSupportSettingsUISession = py::register_python_type(module.get(), type_name_PrintSupportSettingsUISession, &type_spec_PrintSupportSettingsUISession, bases.get(), nullptr);
    if (!state->type_PrintSupportSettingsUISession)
    {
        return nullptr;
    }


    return module.detach();
}

PyObject* py::py_type<winrt::Windows::Graphics::Printing::PrintSupport::SettingsLaunchKind>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Graphics::Printing::PrintSupport;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Graphics::Printing::PrintSupport");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_SettingsLaunchKind;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Graphics::Printing::PrintSupport::SettingsLaunchKind is not registered");
        return nullptr;
    }

    return python_type;
}

PyObject* py::py_type<winrt::Windows::Graphics::Printing::PrintSupport::WorkflowPrintTicketValidationStatus>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Graphics::Printing::PrintSupport;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Graphics::Printing::PrintSupport");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_WorkflowPrintTicketValidationStatus;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Graphics::Printing::PrintSupport::WorkflowPrintTicketValidationStatus is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Graphics::Printing::PrintSupport::PrintSupportExtensionSession>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Graphics::Printing::PrintSupport;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Graphics::Printing::PrintSupport");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_PrintSupportExtensionSession;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Graphics::Printing::PrintSupport::PrintSupportExtensionSession is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Graphics::Printing::PrintSupport::PrintSupportExtensionTriggerDetails>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Graphics::Printing::PrintSupport;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Graphics::Printing::PrintSupport");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_PrintSupportExtensionTriggerDetails;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Graphics::Printing::PrintSupport::PrintSupportExtensionTriggerDetails is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Graphics::Printing::PrintSupport::PrintSupportPrintDeviceCapabilitiesChangedEventArgs>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Graphics::Printing::PrintSupport;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Graphics::Printing::PrintSupport");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_PrintSupportPrintDeviceCapabilitiesChangedEventArgs;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Graphics::Printing::PrintSupport::PrintSupportPrintDeviceCapabilitiesChangedEventArgs is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Graphics::Printing::PrintSupport::PrintSupportPrintDeviceCapabilitiesUpdatePolicy>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Graphics::Printing::PrintSupport;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Graphics::Printing::PrintSupport");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_PrintSupportPrintDeviceCapabilitiesUpdatePolicy;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Graphics::Printing::PrintSupport::PrintSupportPrintDeviceCapabilitiesUpdatePolicy is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Graphics::Printing::PrintSupport::PrintSupportPrintTicketElement>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Graphics::Printing::PrintSupport;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Graphics::Printing::PrintSupport");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_PrintSupportPrintTicketElement;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Graphics::Printing::PrintSupport::PrintSupportPrintTicketElement is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Graphics::Printing::PrintSupport::PrintSupportPrintTicketValidationRequestedEventArgs>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Graphics::Printing::PrintSupport;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Graphics::Printing::PrintSupport");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_PrintSupportPrintTicketValidationRequestedEventArgs;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Graphics::Printing::PrintSupport::PrintSupportPrintTicketValidationRequestedEventArgs is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Graphics::Printing::PrintSupport::PrintSupportPrinterSelectedEventArgs>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Graphics::Printing::PrintSupport;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Graphics::Printing::PrintSupport");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_PrintSupportPrinterSelectedEventArgs;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Graphics::Printing::PrintSupport::PrintSupportPrinterSelectedEventArgs is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Graphics::Printing::PrintSupport::PrintSupportSessionInfo>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Graphics::Printing::PrintSupport;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Graphics::Printing::PrintSupport");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_PrintSupportSessionInfo;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Graphics::Printing::PrintSupport::PrintSupportSessionInfo is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Graphics::Printing::PrintSupport::PrintSupportSettingsActivatedEventArgs>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Graphics::Printing::PrintSupport;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Graphics::Printing::PrintSupport");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_PrintSupportSettingsActivatedEventArgs;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Graphics::Printing::PrintSupport::PrintSupportSettingsActivatedEventArgs is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Graphics::Printing::PrintSupport::PrintSupportSettingsUISession>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Graphics::Printing::PrintSupport;

    PyObject* module = PyState_FindModule(&module_def);

    if (!module) {
        PyErr_SetString(PyExc_RuntimeError, "could not find module for Windows::Graphics::Printing::PrintSupport");
        return nullptr;
    }

    auto state = reinterpret_cast<module_state*>(PyModule_GetState(module));
    assert(state);

    auto python_type = state->type_PrintSupportSettingsUISession;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Graphics::Printing::PrintSupport::PrintSupportSettingsUISession is not registered");
        return nullptr;
    }

    return python_type;
}
