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

#include "pybase.h"
#include "py.Windows.Devices.Printers.h"


namespace py::cpp::Windows::Devices::Printers
{
    struct module_state
    {
        PyObject* type_IppAttributeErrorReason;
        PyObject* type_IppAttributeValueKind;
        PyObject* type_IppResolutionUnit;
        PyObject* type_PageConfigurationSource;
        PyTypeObject* type_IppAttributeError;
        PyTypeObject* type_IppAttributeValue;
        PyTypeObject* type_IppIntegerRange;
        PyTypeObject* type_IppPrintDevice;
        PyTypeObject* type_IppResolution;
        PyTypeObject* type_IppSetAttributesResult;
        PyTypeObject* type_IppTextWithLanguage;
        PyTypeObject* type_PageConfigurationSettings;
        PyTypeObject* type_PdlPassthroughProvider;
        PyTypeObject* type_PdlPassthroughTarget;
        PyTypeObject* type_Print3DDevice;
        PyTypeObject* type_PrintSchema;
    };

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

        if (state->type_IppAttributeErrorReason)
        {
            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_IppAttributeErrorReason = type;
        Py_INCREF(state->type_IppAttributeErrorReason);


        Py_RETURN_NONE;
    }

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

        if (state->type_IppAttributeValueKind)
        {
            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_IppAttributeValueKind = type;
        Py_INCREF(state->type_IppAttributeValueKind);


        Py_RETURN_NONE;
    }

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

        if (state->type_IppResolutionUnit)
        {
            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_IppResolutionUnit = type;
        Py_INCREF(state->type_IppResolutionUnit);


        Py_RETURN_NONE;
    }

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

        if (state->type_PageConfigurationSource)
        {
            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_PageConfigurationSource = type;
        Py_INCREF(state->type_PageConfigurationSource);


        Py_RETURN_NONE;
    }

    // ----- IppAttributeError class --------------------
    static constexpr const char* const type_name_IppAttributeError = "IppAttributeError";

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

    static void _dealloc_IppAttributeError(py::wrapper::Windows::Devices::Printers::IppAttributeError* 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* IppAttributeError_GetUnsupportedValues(py::wrapper::Windows::Devices::Printers::IppAttributeError* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeError", L"GetUnsupportedValues", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* IppAttributeError_get_ExtendedError(py::wrapper::Windows::Devices::Printers::IppAttributeError* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.Printers.IppAttributeError", L"ExtendedError"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* IppAttributeError_get_Reason(py::wrapper::Windows::Devices::Printers::IppAttributeError* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.Printers.IppAttributeError", L"Reason"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_IppAttributeError(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Devices::Printers::IppAttributeError>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_IppAttributeError(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::Devices::Printers::IppAttributeError>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_IppAttributeError[] = {
        { "get_unsupported_values", reinterpret_cast<PyCFunction>(IppAttributeError_GetUnsupportedValues), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_IppAttributeError, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_IppAttributeError), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_IppAttributeError[] = {
        { "extended_error", reinterpret_cast<getter>(IppAttributeError_get_ExtendedError), nullptr, nullptr, nullptr },
        { "reason", reinterpret_cast<getter>(IppAttributeError_get_Reason), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_IppAttributeError[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_IppAttributeError) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_IppAttributeError) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_IppAttributeError) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_IppAttributeError) },
        { },
    };

    static PyType_Spec type_spec_IppAttributeError =
    {
        "_winsdk_Windows_Devices_Printers.IppAttributeError",
        sizeof(py::wrapper::Windows::Devices::Printers::IppAttributeError),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_IppAttributeError
    };

    // ----- IppAttributeValue class --------------------
    static constexpr const char* const type_name_IppAttributeValue = "IppAttributeValue";

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

    static void _dealloc_IppAttributeValue(py::wrapper::Windows::Devices::Printers::IppAttributeValue* 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* IppAttributeValue_CreateBoolean(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeValue", L"CreateBoolean", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

                return py::convert(winrt::Windows::Devices::Printers::IppAttributeValue::CreateBoolean(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeValue", L"CreateBooleanArray", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

                return py::convert(winrt::Windows::Devices::Printers::IppAttributeValue::CreateBooleanArray(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeValue", L"CreateCharset", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

                return py::convert(winrt::Windows::Devices::Printers::IppAttributeValue::CreateCharset(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeValue", L"CreateCharsetArray", 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);

                return py::convert(winrt::Windows::Devices::Printers::IppAttributeValue::CreateCharsetArray(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeValue", L"CreateCollection", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

                return py::convert(winrt::Windows::Devices::Printers::IppAttributeValue::CreateCollection(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeValue", L"CreateCollectionArray", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

                return py::convert(winrt::Windows::Devices::Printers::IppAttributeValue::CreateCollectionArray(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeValue", L"CreateDateTime", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

                return py::convert(winrt::Windows::Devices::Printers::IppAttributeValue::CreateDateTime(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeValue", L"CreateDateTimeArray", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

                return py::convert(winrt::Windows::Devices::Printers::IppAttributeValue::CreateDateTimeArray(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeValue", L"CreateEnum", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

                return py::convert(winrt::Windows::Devices::Printers::IppAttributeValue::CreateEnum(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeValue", L"CreateEnumArray", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

                return py::convert(winrt::Windows::Devices::Printers::IppAttributeValue::CreateEnumArray(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeValue", L"CreateInteger", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

                return py::convert(winrt::Windows::Devices::Printers::IppAttributeValue::CreateInteger(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeValue", L"CreateIntegerArray", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

                return py::convert(winrt::Windows::Devices::Printers::IppAttributeValue::CreateIntegerArray(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeValue", L"CreateKeyword", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

                return py::convert(winrt::Windows::Devices::Printers::IppAttributeValue::CreateKeyword(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeValue", L"CreateKeywordArray", 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);

                return py::convert(winrt::Windows::Devices::Printers::IppAttributeValue::CreateKeywordArray(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeValue", L"CreateMimeMedia", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

                return py::convert(winrt::Windows::Devices::Printers::IppAttributeValue::CreateMimeMedia(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeValue", L"CreateMimeMediaArray", 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);

                return py::convert(winrt::Windows::Devices::Printers::IppAttributeValue::CreateMimeMediaArray(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeValue", L"CreateNameWithLanguage", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Devices::Printers::IppTextWithLanguage>(args, 0);

                return py::convert(winrt::Windows::Devices::Printers::IppAttributeValue::CreateNameWithLanguage(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeValue", L"CreateNameWithLanguageArray", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

                return py::convert(winrt::Windows::Devices::Printers::IppAttributeValue::CreateNameWithLanguageArray(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeValue", L"CreateNameWithoutLanguage", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

                return py::convert(winrt::Windows::Devices::Printers::IppAttributeValue::CreateNameWithoutLanguage(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeValue", L"CreateNameWithoutLanguageArray", 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);

                return py::convert(winrt::Windows::Devices::Printers::IppAttributeValue::CreateNameWithoutLanguageArray(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeValue", L"CreateNaturalLanguage", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

                return py::convert(winrt::Windows::Devices::Printers::IppAttributeValue::CreateNaturalLanguage(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeValue", L"CreateNaturalLanguageArray", 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);

                return py::convert(winrt::Windows::Devices::Printers::IppAttributeValue::CreateNaturalLanguageArray(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeValue", L"CreateNoValue", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                return py::convert(winrt::Windows::Devices::Printers::IppAttributeValue::CreateNoValue());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeValue", L"CreateOctetString", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Storage::Streams::IBuffer>(args, 0);

                return py::convert(winrt::Windows::Devices::Printers::IppAttributeValue::CreateOctetString(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeValue", L"CreateOctetStringArray", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

                return py::convert(winrt::Windows::Devices::Printers::IppAttributeValue::CreateOctetStringArray(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeValue", L"CreateRangeOfInteger", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Devices::Printers::IppIntegerRange>(args, 0);

                return py::convert(winrt::Windows::Devices::Printers::IppAttributeValue::CreateRangeOfInteger(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeValue", L"CreateRangeOfIntegerArray", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

                return py::convert(winrt::Windows::Devices::Printers::IppAttributeValue::CreateRangeOfIntegerArray(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeValue", L"CreateResolution", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Devices::Printers::IppResolution>(args, 0);

                return py::convert(winrt::Windows::Devices::Printers::IppAttributeValue::CreateResolution(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeValue", L"CreateResolutionArray", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

                return py::convert(winrt::Windows::Devices::Printers::IppAttributeValue::CreateResolutionArray(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeValue", L"CreateTextWithLanguage", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Devices::Printers::IppTextWithLanguage>(args, 0);

                return py::convert(winrt::Windows::Devices::Printers::IppAttributeValue::CreateTextWithLanguage(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeValue", L"CreateTextWithLanguageArray", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

                return py::convert(winrt::Windows::Devices::Printers::IppAttributeValue::CreateTextWithLanguageArray(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeValue", L"CreateTextWithoutLanguage", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

                return py::convert(winrt::Windows::Devices::Printers::IppAttributeValue::CreateTextWithoutLanguage(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeValue", L"CreateTextWithoutLanguageArray", 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);

                return py::convert(winrt::Windows::Devices::Printers::IppAttributeValue::CreateTextWithoutLanguageArray(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeValue", L"CreateUnknown", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                return py::convert(winrt::Windows::Devices::Printers::IppAttributeValue::CreateUnknown());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeValue", L"CreateUnsupported", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                return py::convert(winrt::Windows::Devices::Printers::IppAttributeValue::CreateUnsupported());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeValue", L"CreateUri", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

                return py::convert(winrt::Windows::Devices::Printers::IppAttributeValue::CreateUri(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeValue", L"CreateUriArray", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

                return py::convert(winrt::Windows::Devices::Printers::IppAttributeValue::CreateUriArray(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeValue", L"CreateUriSchema", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

                return py::convert(winrt::Windows::Devices::Printers::IppAttributeValue::CreateUriSchema(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeValue", L"CreateUriSchemaArray", 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);

                return py::convert(winrt::Windows::Devices::Printers::IppAttributeValue::CreateUriSchemaArray(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* IppAttributeValue_GetBooleanArray(py::wrapper::Windows::Devices::Printers::IppAttributeValue* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeValue", L"GetBooleanArray", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* IppAttributeValue_GetCharsetArray(py::wrapper::Windows::Devices::Printers::IppAttributeValue* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeValue", L"GetCharsetArray", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* IppAttributeValue_GetCollectionArray(py::wrapper::Windows::Devices::Printers::IppAttributeValue* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeValue", L"GetCollectionArray", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* IppAttributeValue_GetDateTimeArray(py::wrapper::Windows::Devices::Printers::IppAttributeValue* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeValue", L"GetDateTimeArray", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* IppAttributeValue_GetEnumArray(py::wrapper::Windows::Devices::Printers::IppAttributeValue* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeValue", L"GetEnumArray", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* IppAttributeValue_GetIntegerArray(py::wrapper::Windows::Devices::Printers::IppAttributeValue* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeValue", L"GetIntegerArray", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* IppAttributeValue_GetKeywordArray(py::wrapper::Windows::Devices::Printers::IppAttributeValue* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeValue", L"GetKeywordArray", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* IppAttributeValue_GetMimeMediaTypeArray(py::wrapper::Windows::Devices::Printers::IppAttributeValue* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeValue", L"GetMimeMediaTypeArray", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* IppAttributeValue_GetNameWithLanguageArray(py::wrapper::Windows::Devices::Printers::IppAttributeValue* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeValue", L"GetNameWithLanguageArray", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* IppAttributeValue_GetNameWithoutLanguageArray(py::wrapper::Windows::Devices::Printers::IppAttributeValue* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeValue", L"GetNameWithoutLanguageArray", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* IppAttributeValue_GetNaturalLanguageArray(py::wrapper::Windows::Devices::Printers::IppAttributeValue* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeValue", L"GetNaturalLanguageArray", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* IppAttributeValue_GetOctetStringArray(py::wrapper::Windows::Devices::Printers::IppAttributeValue* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeValue", L"GetOctetStringArray", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* IppAttributeValue_GetRangeOfIntegerArray(py::wrapper::Windows::Devices::Printers::IppAttributeValue* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeValue", L"GetRangeOfIntegerArray", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* IppAttributeValue_GetResolutionArray(py::wrapper::Windows::Devices::Printers::IppAttributeValue* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeValue", L"GetResolutionArray", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* IppAttributeValue_GetTextWithLanguageArray(py::wrapper::Windows::Devices::Printers::IppAttributeValue* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeValue", L"GetTextWithLanguageArray", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* IppAttributeValue_GetTextWithoutLanguageArray(py::wrapper::Windows::Devices::Printers::IppAttributeValue* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeValue", L"GetTextWithoutLanguageArray", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* IppAttributeValue_GetUriArray(py::wrapper::Windows::Devices::Printers::IppAttributeValue* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeValue", L"GetUriArray", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* IppAttributeValue_GetUriSchemaArray(py::wrapper::Windows::Devices::Printers::IppAttributeValue* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppAttributeValue", L"GetUriSchemaArray", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* IppAttributeValue_get_Kind(py::wrapper::Windows::Devices::Printers::IppAttributeValue* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.Printers.IppAttributeValue", 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* _assign_array_IppAttributeValue(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Devices::Printers::IppAttributeValue>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_IppAttributeValue(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::Devices::Printers::IppAttributeValue>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_IppAttributeValue[] = {
        { "create_boolean", reinterpret_cast<PyCFunction>(IppAttributeValue_CreateBoolean), METH_VARARGS | METH_STATIC, nullptr },
        { "create_boolean_array", reinterpret_cast<PyCFunction>(IppAttributeValue_CreateBooleanArray), METH_VARARGS | METH_STATIC, nullptr },
        { "create_charset", reinterpret_cast<PyCFunction>(IppAttributeValue_CreateCharset), METH_VARARGS | METH_STATIC, nullptr },
        { "create_charset_array", reinterpret_cast<PyCFunction>(IppAttributeValue_CreateCharsetArray), METH_VARARGS | METH_STATIC, nullptr },
        { "create_collection", reinterpret_cast<PyCFunction>(IppAttributeValue_CreateCollection), METH_VARARGS | METH_STATIC, nullptr },
        { "create_collection_array", reinterpret_cast<PyCFunction>(IppAttributeValue_CreateCollectionArray), METH_VARARGS | METH_STATIC, nullptr },
        { "create_date_time", reinterpret_cast<PyCFunction>(IppAttributeValue_CreateDateTime), METH_VARARGS | METH_STATIC, nullptr },
        { "create_date_time_array", reinterpret_cast<PyCFunction>(IppAttributeValue_CreateDateTimeArray), METH_VARARGS | METH_STATIC, nullptr },
        { "create_enum", reinterpret_cast<PyCFunction>(IppAttributeValue_CreateEnum), METH_VARARGS | METH_STATIC, nullptr },
        { "create_enum_array", reinterpret_cast<PyCFunction>(IppAttributeValue_CreateEnumArray), METH_VARARGS | METH_STATIC, nullptr },
        { "create_integer", reinterpret_cast<PyCFunction>(IppAttributeValue_CreateInteger), METH_VARARGS | METH_STATIC, nullptr },
        { "create_integer_array", reinterpret_cast<PyCFunction>(IppAttributeValue_CreateIntegerArray), METH_VARARGS | METH_STATIC, nullptr },
        { "create_keyword", reinterpret_cast<PyCFunction>(IppAttributeValue_CreateKeyword), METH_VARARGS | METH_STATIC, nullptr },
        { "create_keyword_array", reinterpret_cast<PyCFunction>(IppAttributeValue_CreateKeywordArray), METH_VARARGS | METH_STATIC, nullptr },
        { "create_mime_media", reinterpret_cast<PyCFunction>(IppAttributeValue_CreateMimeMedia), METH_VARARGS | METH_STATIC, nullptr },
        { "create_mime_media_array", reinterpret_cast<PyCFunction>(IppAttributeValue_CreateMimeMediaArray), METH_VARARGS | METH_STATIC, nullptr },
        { "create_name_with_language", reinterpret_cast<PyCFunction>(IppAttributeValue_CreateNameWithLanguage), METH_VARARGS | METH_STATIC, nullptr },
        { "create_name_with_language_array", reinterpret_cast<PyCFunction>(IppAttributeValue_CreateNameWithLanguageArray), METH_VARARGS | METH_STATIC, nullptr },
        { "create_name_without_language", reinterpret_cast<PyCFunction>(IppAttributeValue_CreateNameWithoutLanguage), METH_VARARGS | METH_STATIC, nullptr },
        { "create_name_without_language_array", reinterpret_cast<PyCFunction>(IppAttributeValue_CreateNameWithoutLanguageArray), METH_VARARGS | METH_STATIC, nullptr },
        { "create_natural_language", reinterpret_cast<PyCFunction>(IppAttributeValue_CreateNaturalLanguage), METH_VARARGS | METH_STATIC, nullptr },
        { "create_natural_language_array", reinterpret_cast<PyCFunction>(IppAttributeValue_CreateNaturalLanguageArray), METH_VARARGS | METH_STATIC, nullptr },
        { "create_no_value", reinterpret_cast<PyCFunction>(IppAttributeValue_CreateNoValue), METH_VARARGS | METH_STATIC, nullptr },
        { "create_octet_string", reinterpret_cast<PyCFunction>(IppAttributeValue_CreateOctetString), METH_VARARGS | METH_STATIC, nullptr },
        { "create_octet_string_array", reinterpret_cast<PyCFunction>(IppAttributeValue_CreateOctetStringArray), METH_VARARGS | METH_STATIC, nullptr },
        { "create_range_of_integer", reinterpret_cast<PyCFunction>(IppAttributeValue_CreateRangeOfInteger), METH_VARARGS | METH_STATIC, nullptr },
        { "create_range_of_integer_array", reinterpret_cast<PyCFunction>(IppAttributeValue_CreateRangeOfIntegerArray), METH_VARARGS | METH_STATIC, nullptr },
        { "create_resolution", reinterpret_cast<PyCFunction>(IppAttributeValue_CreateResolution), METH_VARARGS | METH_STATIC, nullptr },
        { "create_resolution_array", reinterpret_cast<PyCFunction>(IppAttributeValue_CreateResolutionArray), METH_VARARGS | METH_STATIC, nullptr },
        { "create_text_with_language", reinterpret_cast<PyCFunction>(IppAttributeValue_CreateTextWithLanguage), METH_VARARGS | METH_STATIC, nullptr },
        { "create_text_with_language_array", reinterpret_cast<PyCFunction>(IppAttributeValue_CreateTextWithLanguageArray), METH_VARARGS | METH_STATIC, nullptr },
        { "create_text_without_language", reinterpret_cast<PyCFunction>(IppAttributeValue_CreateTextWithoutLanguage), METH_VARARGS | METH_STATIC, nullptr },
        { "create_text_without_language_array", reinterpret_cast<PyCFunction>(IppAttributeValue_CreateTextWithoutLanguageArray), METH_VARARGS | METH_STATIC, nullptr },
        { "create_unknown", reinterpret_cast<PyCFunction>(IppAttributeValue_CreateUnknown), METH_VARARGS | METH_STATIC, nullptr },
        { "create_unsupported", reinterpret_cast<PyCFunction>(IppAttributeValue_CreateUnsupported), METH_VARARGS | METH_STATIC, nullptr },
        { "create_uri", reinterpret_cast<PyCFunction>(IppAttributeValue_CreateUri), METH_VARARGS | METH_STATIC, nullptr },
        { "create_uri_array", reinterpret_cast<PyCFunction>(IppAttributeValue_CreateUriArray), METH_VARARGS | METH_STATIC, nullptr },
        { "create_uri_schema", reinterpret_cast<PyCFunction>(IppAttributeValue_CreateUriSchema), METH_VARARGS | METH_STATIC, nullptr },
        { "create_uri_schema_array", reinterpret_cast<PyCFunction>(IppAttributeValue_CreateUriSchemaArray), METH_VARARGS | METH_STATIC, nullptr },
        { "get_boolean_array", reinterpret_cast<PyCFunction>(IppAttributeValue_GetBooleanArray), METH_VARARGS, nullptr },
        { "get_charset_array", reinterpret_cast<PyCFunction>(IppAttributeValue_GetCharsetArray), METH_VARARGS, nullptr },
        { "get_collection_array", reinterpret_cast<PyCFunction>(IppAttributeValue_GetCollectionArray), METH_VARARGS, nullptr },
        { "get_date_time_array", reinterpret_cast<PyCFunction>(IppAttributeValue_GetDateTimeArray), METH_VARARGS, nullptr },
        { "get_enum_array", reinterpret_cast<PyCFunction>(IppAttributeValue_GetEnumArray), METH_VARARGS, nullptr },
        { "get_integer_array", reinterpret_cast<PyCFunction>(IppAttributeValue_GetIntegerArray), METH_VARARGS, nullptr },
        { "get_keyword_array", reinterpret_cast<PyCFunction>(IppAttributeValue_GetKeywordArray), METH_VARARGS, nullptr },
        { "get_mime_media_type_array", reinterpret_cast<PyCFunction>(IppAttributeValue_GetMimeMediaTypeArray), METH_VARARGS, nullptr },
        { "get_name_with_language_array", reinterpret_cast<PyCFunction>(IppAttributeValue_GetNameWithLanguageArray), METH_VARARGS, nullptr },
        { "get_name_without_language_array", reinterpret_cast<PyCFunction>(IppAttributeValue_GetNameWithoutLanguageArray), METH_VARARGS, nullptr },
        { "get_natural_language_array", reinterpret_cast<PyCFunction>(IppAttributeValue_GetNaturalLanguageArray), METH_VARARGS, nullptr },
        { "get_octet_string_array", reinterpret_cast<PyCFunction>(IppAttributeValue_GetOctetStringArray), METH_VARARGS, nullptr },
        { "get_range_of_integer_array", reinterpret_cast<PyCFunction>(IppAttributeValue_GetRangeOfIntegerArray), METH_VARARGS, nullptr },
        { "get_resolution_array", reinterpret_cast<PyCFunction>(IppAttributeValue_GetResolutionArray), METH_VARARGS, nullptr },
        { "get_text_with_language_array", reinterpret_cast<PyCFunction>(IppAttributeValue_GetTextWithLanguageArray), METH_VARARGS, nullptr },
        { "get_text_without_language_array", reinterpret_cast<PyCFunction>(IppAttributeValue_GetTextWithoutLanguageArray), METH_VARARGS, nullptr },
        { "get_uri_array", reinterpret_cast<PyCFunction>(IppAttributeValue_GetUriArray), METH_VARARGS, nullptr },
        { "get_uri_schema_array", reinterpret_cast<PyCFunction>(IppAttributeValue_GetUriSchemaArray), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_IppAttributeValue, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_IppAttributeValue), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_IppAttributeValue[] = {
        { "kind", reinterpret_cast<getter>(IppAttributeValue_get_Kind), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_IppAttributeValue[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_IppAttributeValue) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_IppAttributeValue) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_IppAttributeValue) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_IppAttributeValue) },
        { },
    };

    static PyType_Spec type_spec_IppAttributeValue =
    {
        "_winsdk_Windows_Devices_Printers.IppAttributeValue",
        sizeof(py::wrapper::Windows::Devices::Printers::IppAttributeValue),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_IppAttributeValue
    };

    // ----- IppIntegerRange class --------------------
    static constexpr const char* const type_name_IppIntegerRange = "IppIntegerRange";

    static PyObject* _new_IppIntegerRange(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 == 2)
        {
            try
            {
                auto param0 = py::convert_to<int32_t>(args, 0);
                auto param1 = py::convert_to<int32_t>(args, 1);

                winrt::Windows::Devices::Printers::IppIntegerRange instance{ param0, param1 };
                return py::wrap(instance, type);
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static void _dealloc_IppIntegerRange(py::wrapper::Windows::Devices::Printers::IppIntegerRange* 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* IppIntegerRange_get_End(py::wrapper::Windows::Devices::Printers::IppIntegerRange* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.Printers.IppIntegerRange", L"End"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* IppIntegerRange_get_Start(py::wrapper::Windows::Devices::Printers::IppIntegerRange* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.Printers.IppIntegerRange", L"Start"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_IppIntegerRange(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Devices::Printers::IppIntegerRange>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_IppIntegerRange(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::Devices::Printers::IppIntegerRange>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_IppIntegerRange[] = {
        { "_assign_array_", _assign_array_IppIntegerRange, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_IppIntegerRange), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_IppIntegerRange[] = {
        { "end", reinterpret_cast<getter>(IppIntegerRange_get_End), nullptr, nullptr, nullptr },
        { "start", reinterpret_cast<getter>(IppIntegerRange_get_Start), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_IppIntegerRange[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_IppIntegerRange) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_IppIntegerRange) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_IppIntegerRange) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_IppIntegerRange) },
        { },
    };

    static PyType_Spec type_spec_IppIntegerRange =
    {
        "_winsdk_Windows_Devices_Printers.IppIntegerRange",
        sizeof(py::wrapper::Windows::Devices::Printers::IppIntegerRange),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_IppIntegerRange
    };

    // ----- IppPrintDevice class --------------------
    static constexpr const char* const type_name_IppPrintDevice = "IppPrintDevice";

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

    static void _dealloc_IppPrintDevice(py::wrapper::Windows::Devices::Printers::IppPrintDevice* 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* IppPrintDevice_FromId(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppPrintDevice", L"FromId", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

                return py::convert(winrt::Windows::Devices::Printers::IppPrintDevice::FromId(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppPrintDevice", L"FromPrinterName", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

                return py::convert(winrt::Windows::Devices::Printers::IppPrintDevice::FromPrinterName(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppPrintDevice", L"GetDeviceSelector", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                return py::convert(winrt::Windows::Devices::Printers::IppPrintDevice::GetDeviceSelector());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* IppPrintDevice_GetMaxSupportedPdfSize(py::wrapper::Windows::Devices::Printers::IppPrintDevice* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppPrintDevice", L"GetMaxSupportedPdfSize", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* IppPrintDevice_GetMaxSupportedPdfVersion(py::wrapper::Windows::Devices::Printers::IppPrintDevice* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppPrintDevice", L"GetMaxSupportedPdfVersion", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* IppPrintDevice_GetPdlPassthroughProvider(py::wrapper::Windows::Devices::Printers::IppPrintDevice* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppPrintDevice", L"GetPdlPassthroughProvider", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* IppPrintDevice_GetPrinterAttributes(py::wrapper::Windows::Devices::Printers::IppPrintDevice* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppPrintDevice", L"GetPrinterAttributes", 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);

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

    static PyObject* IppPrintDevice_GetPrinterAttributesAsBuffer(py::wrapper::Windows::Devices::Printers::IppPrintDevice* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppPrintDevice", L"GetPrinterAttributesAsBuffer", 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);

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

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

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppPrintDevice", L"IsIppPrinter", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

                return py::convert(winrt::Windows::Devices::Printers::IppPrintDevice::IsIppPrinter(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* IppPrintDevice_IsPdlPassthroughSupported(py::wrapper::Windows::Devices::Printers::IppPrintDevice* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppPrintDevice", L"IsPdlPassthroughSupported", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

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

    static PyObject* IppPrintDevice_SetPrinterAttributes(py::wrapper::Windows::Devices::Printers::IppPrintDevice* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppPrintDevice", L"SetPrinterAttributes", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

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

    static PyObject* IppPrintDevice_SetPrinterAttributesFromBuffer(py::wrapper::Windows::Devices::Printers::IppPrintDevice* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.IppPrintDevice", L"SetPrinterAttributesFromBuffer", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Storage::Streams::IBuffer>(args, 0);

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

    static PyObject* IppPrintDevice_get_PrinterName(py::wrapper::Windows::Devices::Printers::IppPrintDevice* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.Printers.IppPrintDevice", L"PrinterName"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* IppPrintDevice_get_PrinterUri(py::wrapper::Windows::Devices::Printers::IppPrintDevice* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.Printers.IppPrintDevice", L"PrinterUri"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_IppPrintDevice(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Devices::Printers::IppPrintDevice>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_IppPrintDevice(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::Devices::Printers::IppPrintDevice>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_IppPrintDevice[] = {
        { "from_id", reinterpret_cast<PyCFunction>(IppPrintDevice_FromId), METH_VARARGS | METH_STATIC, nullptr },
        { "from_printer_name", reinterpret_cast<PyCFunction>(IppPrintDevice_FromPrinterName), METH_VARARGS | METH_STATIC, nullptr },
        { "get_device_selector", reinterpret_cast<PyCFunction>(IppPrintDevice_GetDeviceSelector), METH_VARARGS | METH_STATIC, nullptr },
        { "get_max_supported_pdf_size", reinterpret_cast<PyCFunction>(IppPrintDevice_GetMaxSupportedPdfSize), METH_VARARGS, nullptr },
        { "get_max_supported_pdf_version", reinterpret_cast<PyCFunction>(IppPrintDevice_GetMaxSupportedPdfVersion), METH_VARARGS, nullptr },
        { "get_pdl_passthrough_provider", reinterpret_cast<PyCFunction>(IppPrintDevice_GetPdlPassthroughProvider), METH_VARARGS, nullptr },
        { "get_printer_attributes", reinterpret_cast<PyCFunction>(IppPrintDevice_GetPrinterAttributes), METH_VARARGS, nullptr },
        { "get_printer_attributes_as_buffer", reinterpret_cast<PyCFunction>(IppPrintDevice_GetPrinterAttributesAsBuffer), METH_VARARGS, nullptr },
        { "is_ipp_printer", reinterpret_cast<PyCFunction>(IppPrintDevice_IsIppPrinter), METH_VARARGS | METH_STATIC, nullptr },
        { "is_pdl_passthrough_supported", reinterpret_cast<PyCFunction>(IppPrintDevice_IsPdlPassthroughSupported), METH_VARARGS, nullptr },
        { "set_printer_attributes", reinterpret_cast<PyCFunction>(IppPrintDevice_SetPrinterAttributes), METH_VARARGS, nullptr },
        { "set_printer_attributes_from_buffer", reinterpret_cast<PyCFunction>(IppPrintDevice_SetPrinterAttributesFromBuffer), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_IppPrintDevice, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_IppPrintDevice), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_IppPrintDevice[] = {
        { "printer_name", reinterpret_cast<getter>(IppPrintDevice_get_PrinterName), nullptr, nullptr, nullptr },
        { "printer_uri", reinterpret_cast<getter>(IppPrintDevice_get_PrinterUri), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_IppPrintDevice[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_IppPrintDevice) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_IppPrintDevice) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_IppPrintDevice) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_IppPrintDevice) },
        { },
    };

    static PyType_Spec type_spec_IppPrintDevice =
    {
        "_winsdk_Windows_Devices_Printers.IppPrintDevice",
        sizeof(py::wrapper::Windows::Devices::Printers::IppPrintDevice),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_IppPrintDevice
    };

    // ----- IppResolution class --------------------
    static constexpr const char* const type_name_IppResolution = "IppResolution";

    static PyObject* _new_IppResolution(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 == 3)
        {
            try
            {
                auto param0 = py::convert_to<int32_t>(args, 0);
                auto param1 = py::convert_to<int32_t>(args, 1);
                auto param2 = py::convert_to<winrt::Windows::Devices::Printers::IppResolutionUnit>(args, 2);

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

    static void _dealloc_IppResolution(py::wrapper::Windows::Devices::Printers::IppResolution* 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* IppResolution_get_Height(py::wrapper::Windows::Devices::Printers::IppResolution* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.Printers.IppResolution", L"Height"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* IppResolution_get_Unit(py::wrapper::Windows::Devices::Printers::IppResolution* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.Printers.IppResolution", L"Unit"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* IppResolution_get_Width(py::wrapper::Windows::Devices::Printers::IppResolution* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.Printers.IppResolution", L"Width"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_IppResolution(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Devices::Printers::IppResolution>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_IppResolution(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::Devices::Printers::IppResolution>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_IppResolution[] = {
        { "_assign_array_", _assign_array_IppResolution, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_IppResolution), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_IppResolution[] = {
        { "height", reinterpret_cast<getter>(IppResolution_get_Height), nullptr, nullptr, nullptr },
        { "unit", reinterpret_cast<getter>(IppResolution_get_Unit), nullptr, nullptr, nullptr },
        { "width", reinterpret_cast<getter>(IppResolution_get_Width), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_IppResolution[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_IppResolution) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_IppResolution) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_IppResolution) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_IppResolution) },
        { },
    };

    static PyType_Spec type_spec_IppResolution =
    {
        "_winsdk_Windows_Devices_Printers.IppResolution",
        sizeof(py::wrapper::Windows::Devices::Printers::IppResolution),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_IppResolution
    };

    // ----- IppSetAttributesResult class --------------------
    static constexpr const char* const type_name_IppSetAttributesResult = "IppSetAttributesResult";

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

    static void _dealloc_IppSetAttributesResult(py::wrapper::Windows::Devices::Printers::IppSetAttributesResult* 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* IppSetAttributesResult_get_AttributeErrors(py::wrapper::Windows::Devices::Printers::IppSetAttributesResult* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.Printers.IppSetAttributesResult", L"AttributeErrors"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* IppSetAttributesResult_get_Succeeded(py::wrapper::Windows::Devices::Printers::IppSetAttributesResult* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.Printers.IppSetAttributesResult", L"Succeeded"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_IppSetAttributesResult(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Devices::Printers::IppSetAttributesResult>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_IppSetAttributesResult(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::Devices::Printers::IppSetAttributesResult>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_IppSetAttributesResult[] = {
        { "_assign_array_", _assign_array_IppSetAttributesResult, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_IppSetAttributesResult), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_IppSetAttributesResult[] = {
        { "attribute_errors", reinterpret_cast<getter>(IppSetAttributesResult_get_AttributeErrors), nullptr, nullptr, nullptr },
        { "succeeded", reinterpret_cast<getter>(IppSetAttributesResult_get_Succeeded), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_IppSetAttributesResult[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_IppSetAttributesResult) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_IppSetAttributesResult) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_IppSetAttributesResult) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_IppSetAttributesResult) },
        { },
    };

    static PyType_Spec type_spec_IppSetAttributesResult =
    {
        "_winsdk_Windows_Devices_Printers.IppSetAttributesResult",
        sizeof(py::wrapper::Windows::Devices::Printers::IppSetAttributesResult),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_IppSetAttributesResult
    };

    // ----- IppTextWithLanguage class --------------------
    static constexpr const char* const type_name_IppTextWithLanguage = "IppTextWithLanguage";

    static PyObject* _new_IppTextWithLanguage(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 == 2)
        {
            try
            {
                auto param0 = py::convert_to<winrt::hstring>(args, 0);
                auto param1 = py::convert_to<winrt::hstring>(args, 1);

                winrt::Windows::Devices::Printers::IppTextWithLanguage instance{ param0, param1 };
                return py::wrap(instance, type);
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static void _dealloc_IppTextWithLanguage(py::wrapper::Windows::Devices::Printers::IppTextWithLanguage* 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* IppTextWithLanguage_get_Language(py::wrapper::Windows::Devices::Printers::IppTextWithLanguage* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.Printers.IppTextWithLanguage", L"Language"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* IppTextWithLanguage_get_Value(py::wrapper::Windows::Devices::Printers::IppTextWithLanguage* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.Printers.IppTextWithLanguage", L"Value"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_IppTextWithLanguage(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Devices::Printers::IppTextWithLanguage>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_IppTextWithLanguage(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::Devices::Printers::IppTextWithLanguage>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_IppTextWithLanguage[] = {
        { "_assign_array_", _assign_array_IppTextWithLanguage, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_IppTextWithLanguage), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_IppTextWithLanguage[] = {
        { "language", reinterpret_cast<getter>(IppTextWithLanguage_get_Language), nullptr, nullptr, nullptr },
        { "value", reinterpret_cast<getter>(IppTextWithLanguage_get_Value), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_IppTextWithLanguage[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_IppTextWithLanguage) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_IppTextWithLanguage) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_IppTextWithLanguage) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_IppTextWithLanguage) },
        { },
    };

    static PyType_Spec type_spec_IppTextWithLanguage =
    {
        "_winsdk_Windows_Devices_Printers.IppTextWithLanguage",
        sizeof(py::wrapper::Windows::Devices::Printers::IppTextWithLanguage),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_IppTextWithLanguage
    };

    // ----- PageConfigurationSettings class --------------------
    static constexpr const char* const type_name_PageConfigurationSettings = "PageConfigurationSettings";

    static PyObject* _new_PageConfigurationSettings(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::Devices::Printers::PageConfigurationSettings 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_PageConfigurationSettings(py::wrapper::Windows::Devices::Printers::PageConfigurationSettings* 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* PageConfigurationSettings_get_SizeSource(py::wrapper::Windows::Devices::Printers::PageConfigurationSettings* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.Printers.PageConfigurationSettings", L"SizeSource"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int PageConfigurationSettings_put_SizeSource(py::wrapper::Windows::Devices::Printers::PageConfigurationSettings* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.Printers.PageConfigurationSettings", L"SizeSource"))
        {
            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::Devices::Printers::PageConfigurationSource>(arg);

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

    static PyObject* PageConfigurationSettings_get_OrientationSource(py::wrapper::Windows::Devices::Printers::PageConfigurationSettings* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.Printers.PageConfigurationSettings", L"OrientationSource"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static int PageConfigurationSettings_put_OrientationSource(py::wrapper::Windows::Devices::Printers::PageConfigurationSettings* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.Printers.PageConfigurationSettings", L"OrientationSource"))
        {
            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::Devices::Printers::PageConfigurationSource>(arg);

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

    static PyObject* _assign_array_PageConfigurationSettings(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Devices::Printers::PageConfigurationSettings>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_PageConfigurationSettings(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::Devices::Printers::PageConfigurationSettings>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_PageConfigurationSettings[] = {
        { "_assign_array_", _assign_array_PageConfigurationSettings, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_PageConfigurationSettings), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_PageConfigurationSettings[] = {
        { "size_source", reinterpret_cast<getter>(PageConfigurationSettings_get_SizeSource), reinterpret_cast<setter>(PageConfigurationSettings_put_SizeSource), nullptr, nullptr },
        { "orientation_source", reinterpret_cast<getter>(PageConfigurationSettings_get_OrientationSource), reinterpret_cast<setter>(PageConfigurationSettings_put_OrientationSource), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_PageConfigurationSettings[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_PageConfigurationSettings) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_PageConfigurationSettings) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_PageConfigurationSettings) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_PageConfigurationSettings) },
        { },
    };

    static PyType_Spec type_spec_PageConfigurationSettings =
    {
        "_winsdk_Windows_Devices_Printers.PageConfigurationSettings",
        sizeof(py::wrapper::Windows::Devices::Printers::PageConfigurationSettings),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_PageConfigurationSettings
    };

    // ----- PdlPassthroughProvider class --------------------
    static constexpr const char* const type_name_PdlPassthroughProvider = "PdlPassthroughProvider";

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

    static void _dealloc_PdlPassthroughProvider(py::wrapper::Windows::Devices::Printers::PdlPassthroughProvider* 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* PdlPassthroughProvider_StartPrintJobWithPrintTicket(py::wrapper::Windows::Devices::Printers::PdlPassthroughProvider* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 4)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.PdlPassthroughProvider", L"StartPrintJobWithPrintTicket", 4))
            {
                py::set_arg_count_version_error(4);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::hstring>(args, 0);
                auto param1 = py::convert_to<winrt::hstring>(args, 1);
                auto param2 = py::convert_to<winrt::Windows::Storage::Streams::IInputStream>(args, 2);
                auto param3 = py::convert_to<winrt::Windows::Devices::Printers::PageConfigurationSettings>(args, 3);

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

    static PyObject* PdlPassthroughProvider_StartPrintJobWithTaskOptions(py::wrapper::Windows::Devices::Printers::PdlPassthroughProvider* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 4)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.PdlPassthroughProvider", L"StartPrintJobWithTaskOptions", 4))
            {
                py::set_arg_count_version_error(4);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::hstring>(args, 0);
                auto param1 = py::convert_to<winrt::hstring>(args, 1);
                auto param2 = py::convert_to<winrt::Windows::Graphics::Printing::PrintTaskOptions>(args, 2);
                auto param3 = py::convert_to<winrt::Windows::Devices::Printers::PageConfigurationSettings>(args, 3);

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

    static PyObject* PdlPassthroughProvider_get_SupportedPdlContentTypes(py::wrapper::Windows::Devices::Printers::PdlPassthroughProvider* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.Printers.PdlPassthroughProvider", L"SupportedPdlContentTypes"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_PdlPassthroughProvider(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Devices::Printers::PdlPassthroughProvider>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_PdlPassthroughProvider(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::Devices::Printers::PdlPassthroughProvider>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_PdlPassthroughProvider[] = {
        { "start_print_job_with_print_ticket", reinterpret_cast<PyCFunction>(PdlPassthroughProvider_StartPrintJobWithPrintTicket), METH_VARARGS, nullptr },
        { "start_print_job_with_task_options", reinterpret_cast<PyCFunction>(PdlPassthroughProvider_StartPrintJobWithTaskOptions), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_PdlPassthroughProvider, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_PdlPassthroughProvider), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_PdlPassthroughProvider[] = {
        { "supported_pdl_content_types", reinterpret_cast<getter>(PdlPassthroughProvider_get_SupportedPdlContentTypes), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_PdlPassthroughProvider[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_PdlPassthroughProvider) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_PdlPassthroughProvider) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_PdlPassthroughProvider) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_PdlPassthroughProvider) },
        { },
    };

    static PyType_Spec type_spec_PdlPassthroughProvider =
    {
        "_winsdk_Windows_Devices_Printers.PdlPassthroughProvider",
        sizeof(py::wrapper::Windows::Devices::Printers::PdlPassthroughProvider),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_PdlPassthroughProvider
    };

    // ----- PdlPassthroughTarget class --------------------
    static constexpr const char* const type_name_PdlPassthroughTarget = "PdlPassthroughTarget";

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

    static void _dealloc_PdlPassthroughTarget(py::wrapper::Windows::Devices::Printers::PdlPassthroughTarget* 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* PdlPassthroughTarget_Close(py::wrapper::Windows::Devices::Printers::PdlPassthroughTarget* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.PdlPassthroughTarget", L"Close", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* PdlPassthroughTarget_GetOutputStream(py::wrapper::Windows::Devices::Printers::PdlPassthroughTarget* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.PdlPassthroughTarget", L"GetOutputStream", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* PdlPassthroughTarget_Submit(py::wrapper::Windows::Devices::Printers::PdlPassthroughTarget* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.PdlPassthroughTarget", L"Submit", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* PdlPassthroughTarget_get_PrintJobId(py::wrapper::Windows::Devices::Printers::PdlPassthroughTarget* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.Printers.PdlPassthroughTarget", L"PrintJobId"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_PdlPassthroughTarget(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Devices::Printers::PdlPassthroughTarget>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_PdlPassthroughTarget(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::Devices::Printers::PdlPassthroughTarget>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _enter_PdlPassthroughTarget(py::wrapper::Windows::Devices::Printers::PdlPassthroughTarget* self) noexcept
    {
        Py_INCREF(self);
        return reinterpret_cast<PyObject*>(self);
    }

    static PyObject* _exit_PdlPassthroughTarget(py::wrapper::Windows::Devices::Printers::PdlPassthroughTarget* self) noexcept
    {
        try
        {
            self->obj.Close();
            Py_RETURN_FALSE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_PdlPassthroughTarget[] = {
        { "close", reinterpret_cast<PyCFunction>(PdlPassthroughTarget_Close), METH_VARARGS, nullptr },
        { "get_output_stream", reinterpret_cast<PyCFunction>(PdlPassthroughTarget_GetOutputStream), METH_VARARGS, nullptr },
        { "submit", reinterpret_cast<PyCFunction>(PdlPassthroughTarget_Submit), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_PdlPassthroughTarget, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_PdlPassthroughTarget), METH_O | METH_STATIC, nullptr },
        { "__enter__", reinterpret_cast<PyCFunction>(_enter_PdlPassthroughTarget), METH_NOARGS, nullptr },
        { "__exit__",  reinterpret_cast<PyCFunction>(_exit_PdlPassthroughTarget), METH_VARARGS, nullptr },
        { }
    };

    static PyGetSetDef _getset_PdlPassthroughTarget[] = {
        { "print_job_id", reinterpret_cast<getter>(PdlPassthroughTarget_get_PrintJobId), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_PdlPassthroughTarget[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_PdlPassthroughTarget) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_PdlPassthroughTarget) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_PdlPassthroughTarget) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_PdlPassthroughTarget) },
        { },
    };

    static PyType_Spec type_spec_PdlPassthroughTarget =
    {
        "_winsdk_Windows_Devices_Printers.PdlPassthroughTarget",
        sizeof(py::wrapper::Windows::Devices::Printers::PdlPassthroughTarget),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_PdlPassthroughTarget
    };

    // ----- Print3DDevice class --------------------
    static constexpr const char* const type_name_Print3DDevice = "Print3DDevice";

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

    static void _dealloc_Print3DDevice(py::wrapper::Windows::Devices::Printers::Print3DDevice* 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* Print3DDevice_FromIdAsync(PyObject* /*unused*/, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.Print3DDevice", L"FromIdAsync", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

                return py::convert(winrt::Windows::Devices::Printers::Print3DDevice::FromIdAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.Print3DDevice", L"GetDeviceSelector", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                return py::convert(winrt::Windows::Devices::Printers::Print3DDevice::GetDeviceSelector());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* Print3DDevice_get_PrintSchema(py::wrapper::Windows::Devices::Printers::Print3DDevice* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.Printers.Print3DDevice", L"PrintSchema"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

    static PyObject* _assign_array_Print3DDevice(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Devices::Printers::Print3DDevice>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_Print3DDevice(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::Devices::Printers::Print3DDevice>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_Print3DDevice[] = {
        { "from_id_async", reinterpret_cast<PyCFunction>(Print3DDevice_FromIdAsync), METH_VARARGS | METH_STATIC, nullptr },
        { "get_device_selector", reinterpret_cast<PyCFunction>(Print3DDevice_GetDeviceSelector), METH_VARARGS | METH_STATIC, nullptr },
        { "_assign_array_", _assign_array_Print3DDevice, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_Print3DDevice), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_Print3DDevice[] = {
        { "print_schema", reinterpret_cast<getter>(Print3DDevice_get_PrintSchema), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_Print3DDevice[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_Print3DDevice) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_Print3DDevice) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_Print3DDevice) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_Print3DDevice) },
        { },
    };

    static PyType_Spec type_spec_Print3DDevice =
    {
        "_winsdk_Windows_Devices_Printers.Print3DDevice",
        sizeof(py::wrapper::Windows::Devices::Printers::Print3DDevice),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_Print3DDevice
    };

    // ----- PrintSchema class --------------------
    static constexpr const char* const type_name_PrintSchema = "PrintSchema";

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

    static void _dealloc_PrintSchema(py::wrapper::Windows::Devices::Printers::PrintSchema* 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* PrintSchema_GetCapabilitiesAsync(py::wrapper::Windows::Devices::Printers::PrintSchema* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.PrintSchema", L"GetCapabilitiesAsync", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Storage::Streams::IRandomAccessStreamWithContentType>(args, 0);

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

    static PyObject* PrintSchema_GetDefaultPrintTicketAsync(py::wrapper::Windows::Devices::Printers::PrintSchema* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.PrintSchema", L"GetDefaultPrintTicketAsync", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* PrintSchema_MergeAndValidateWithDefaultPrintTicketAsync(py::wrapper::Windows::Devices::Printers::PrintSchema* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.Printers.PrintSchema", L"MergeAndValidateWithDefaultPrintTicketAsync", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Storage::Streams::IRandomAccessStreamWithContentType>(args, 0);

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

    static PyObject* _assign_array_PrintSchema(PyObject* /*unused*/, PyObject* arg) noexcept
    {
        auto array = std::make_unique<py::ComArray<winrt::Windows::Devices::Printers::PrintSchema>>();
        if (!py::cpp::_winrt::Array_Assign(arg, std::move(array)))
        {
            return nullptr;
        }
        Py_RETURN_NONE;
    }

    static PyObject* _from_PrintSchema(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::Devices::Printers::PrintSchema>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_PrintSchema[] = {
        { "get_capabilities_async", reinterpret_cast<PyCFunction>(PrintSchema_GetCapabilitiesAsync), METH_VARARGS, nullptr },
        { "get_default_print_ticket_async", reinterpret_cast<PyCFunction>(PrintSchema_GetDefaultPrintTicketAsync), METH_VARARGS, nullptr },
        { "merge_and_validate_with_default_print_ticket_async", reinterpret_cast<PyCFunction>(PrintSchema_MergeAndValidateWithDefaultPrintTicketAsync), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_PrintSchema, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_PrintSchema), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_PrintSchema[] = {
        { }
    };

    static PyType_Slot _type_slots_PrintSchema[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_PrintSchema) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_PrintSchema) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_PrintSchema) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_PrintSchema) },
        { },
    };

    static PyType_Spec type_spec_PrintSchema =
    {
        "_winsdk_Windows_Devices_Printers.PrintSchema",
        sizeof(py::wrapper::Windows::Devices::Printers::PrintSchema),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_PrintSchema
    };

    // ----- Windows.Devices.Printers Initialization --------------------
    PyDoc_STRVAR(module_doc, "Windows::Devices::Printers");

    static PyMethodDef module_methods[] = {
        {"_register_IppAttributeErrorReason", register_IppAttributeErrorReason, METH_O, "registers type"},
        {"_register_IppAttributeValueKind", register_IppAttributeValueKind, METH_O, "registers type"},
        {"_register_IppResolutionUnit", register_IppResolutionUnit, METH_O, "registers type"},
        {"_register_PageConfigurationSource", register_PageConfigurationSource, 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_IppAttributeErrorReason);
        Py_VISIT(state->type_IppAttributeValueKind);
        Py_VISIT(state->type_IppResolutionUnit);
        Py_VISIT(state->type_PageConfigurationSource);
        Py_VISIT(state->type_IppAttributeError);
        Py_VISIT(state->type_IppAttributeValue);
        Py_VISIT(state->type_IppIntegerRange);
        Py_VISIT(state->type_IppPrintDevice);
        Py_VISIT(state->type_IppResolution);
        Py_VISIT(state->type_IppSetAttributesResult);
        Py_VISIT(state->type_IppTextWithLanguage);
        Py_VISIT(state->type_PageConfigurationSettings);
        Py_VISIT(state->type_PdlPassthroughProvider);
        Py_VISIT(state->type_PdlPassthroughTarget);
        Py_VISIT(state->type_Print3DDevice);
        Py_VISIT(state->type_PrintSchema);

        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_IppAttributeErrorReason);
        Py_CLEAR(state->type_IppAttributeValueKind);
        Py_CLEAR(state->type_IppResolutionUnit);
        Py_CLEAR(state->type_PageConfigurationSource);
        Py_CLEAR(state->type_IppAttributeError);
        Py_CLEAR(state->type_IppAttributeValue);
        Py_CLEAR(state->type_IppIntegerRange);
        Py_CLEAR(state->type_IppPrintDevice);
        Py_CLEAR(state->type_IppResolution);
        Py_CLEAR(state->type_IppSetAttributesResult);
        Py_CLEAR(state->type_IppTextWithLanguage);
        Py_CLEAR(state->type_PageConfigurationSettings);
        Py_CLEAR(state->type_PdlPassthroughProvider);
        Py_CLEAR(state->type_PdlPassthroughTarget);
        Py_CLEAR(state->type_Print3DDevice);
        Py_CLEAR(state->type_PrintSchema);

        return 0;
    }


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

} // py::cpp::Windows::Devices::Printers

PyMODINIT_FUNC PyInit__winsdk_Windows_Devices_Printers(void) noexcept
{
    using namespace py::cpp::Windows::Devices::Printers;

    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_IppAttributeError = py::register_python_type(module.get(), type_name_IppAttributeError, &type_spec_IppAttributeError, bases.get(), nullptr);
    if (!state->type_IppAttributeError)
    {
        return nullptr;
    }

    state->type_IppAttributeValue = py::register_python_type(module.get(), type_name_IppAttributeValue, &type_spec_IppAttributeValue, bases.get(), nullptr);
    if (!state->type_IppAttributeValue)
    {
        return nullptr;
    }

    state->type_IppIntegerRange = py::register_python_type(module.get(), type_name_IppIntegerRange, &type_spec_IppIntegerRange, bases.get(), nullptr);
    if (!state->type_IppIntegerRange)
    {
        return nullptr;
    }

    state->type_IppPrintDevice = py::register_python_type(module.get(), type_name_IppPrintDevice, &type_spec_IppPrintDevice, bases.get(), nullptr);
    if (!state->type_IppPrintDevice)
    {
        return nullptr;
    }

    state->type_IppResolution = py::register_python_type(module.get(), type_name_IppResolution, &type_spec_IppResolution, bases.get(), nullptr);
    if (!state->type_IppResolution)
    {
        return nullptr;
    }

    state->type_IppSetAttributesResult = py::register_python_type(module.get(), type_name_IppSetAttributesResult, &type_spec_IppSetAttributesResult, bases.get(), nullptr);
    if (!state->type_IppSetAttributesResult)
    {
        return nullptr;
    }

    state->type_IppTextWithLanguage = py::register_python_type(module.get(), type_name_IppTextWithLanguage, &type_spec_IppTextWithLanguage, bases.get(), nullptr);
    if (!state->type_IppTextWithLanguage)
    {
        return nullptr;
    }

    state->type_PageConfigurationSettings = py::register_python_type(module.get(), type_name_PageConfigurationSettings, &type_spec_PageConfigurationSettings, bases.get(), nullptr);
    if (!state->type_PageConfigurationSettings)
    {
        return nullptr;
    }

    state->type_PdlPassthroughProvider = py::register_python_type(module.get(), type_name_PdlPassthroughProvider, &type_spec_PdlPassthroughProvider, bases.get(), nullptr);
    if (!state->type_PdlPassthroughProvider)
    {
        return nullptr;
    }

    state->type_PdlPassthroughTarget = py::register_python_type(module.get(), type_name_PdlPassthroughTarget, &type_spec_PdlPassthroughTarget, bases.get(), nullptr);
    if (!state->type_PdlPassthroughTarget)
    {
        return nullptr;
    }

    state->type_Print3DDevice = py::register_python_type(module.get(), type_name_Print3DDevice, &type_spec_Print3DDevice, bases.get(), nullptr);
    if (!state->type_Print3DDevice)
    {
        return nullptr;
    }

    state->type_PrintSchema = py::register_python_type(module.get(), type_name_PrintSchema, &type_spec_PrintSchema, bases.get(), nullptr);
    if (!state->type_PrintSchema)
    {
        return nullptr;
    }


    return module.detach();
}

PyObject* py::py_type<winrt::Windows::Devices::Printers::IppAttributeErrorReason>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Devices::Printers;

    PyObject* module = PyState_FindModule(&module_def);

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

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

    auto python_type = state->type_IppAttributeErrorReason;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Devices::Printers::IppAttributeErrorReason is not registered");
        return nullptr;
    }

    return python_type;
}

PyObject* py::py_type<winrt::Windows::Devices::Printers::IppAttributeValueKind>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Devices::Printers;

    PyObject* module = PyState_FindModule(&module_def);

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

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

    auto python_type = state->type_IppAttributeValueKind;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Devices::Printers::IppAttributeValueKind is not registered");
        return nullptr;
    }

    return python_type;
}

PyObject* py::py_type<winrt::Windows::Devices::Printers::IppResolutionUnit>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Devices::Printers;

    PyObject* module = PyState_FindModule(&module_def);

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

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

    auto python_type = state->type_IppResolutionUnit;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Devices::Printers::IppResolutionUnit is not registered");
        return nullptr;
    }

    return python_type;
}

PyObject* py::py_type<winrt::Windows::Devices::Printers::PageConfigurationSource>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Devices::Printers;

    PyObject* module = PyState_FindModule(&module_def);

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

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

    auto python_type = state->type_PageConfigurationSource;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Devices::Printers::PageConfigurationSource is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Devices::Printers::IppAttributeError>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Devices::Printers;

    PyObject* module = PyState_FindModule(&module_def);

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

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

    auto python_type = state->type_IppAttributeError;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Devices::Printers::IppAttributeError is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Devices::Printers::IppAttributeValue>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Devices::Printers;

    PyObject* module = PyState_FindModule(&module_def);

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

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

    auto python_type = state->type_IppAttributeValue;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Devices::Printers::IppAttributeValue is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Devices::Printers::IppIntegerRange>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Devices::Printers;

    PyObject* module = PyState_FindModule(&module_def);

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

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

    auto python_type = state->type_IppIntegerRange;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Devices::Printers::IppIntegerRange is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Devices::Printers::IppPrintDevice>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Devices::Printers;

    PyObject* module = PyState_FindModule(&module_def);

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

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

    auto python_type = state->type_IppPrintDevice;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Devices::Printers::IppPrintDevice is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Devices::Printers::IppResolution>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Devices::Printers;

    PyObject* module = PyState_FindModule(&module_def);

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

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

    auto python_type = state->type_IppResolution;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Devices::Printers::IppResolution is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Devices::Printers::IppSetAttributesResult>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Devices::Printers;

    PyObject* module = PyState_FindModule(&module_def);

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

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

    auto python_type = state->type_IppSetAttributesResult;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Devices::Printers::IppSetAttributesResult is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Devices::Printers::IppTextWithLanguage>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Devices::Printers;

    PyObject* module = PyState_FindModule(&module_def);

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

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

    auto python_type = state->type_IppTextWithLanguage;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Devices::Printers::IppTextWithLanguage is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Devices::Printers::PageConfigurationSettings>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Devices::Printers;

    PyObject* module = PyState_FindModule(&module_def);

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

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

    auto python_type = state->type_PageConfigurationSettings;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Devices::Printers::PageConfigurationSettings is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Devices::Printers::PdlPassthroughProvider>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Devices::Printers;

    PyObject* module = PyState_FindModule(&module_def);

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

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

    auto python_type = state->type_PdlPassthroughProvider;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Devices::Printers::PdlPassthroughProvider is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Devices::Printers::PdlPassthroughTarget>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Devices::Printers;

    PyObject* module = PyState_FindModule(&module_def);

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

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

    auto python_type = state->type_PdlPassthroughTarget;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Devices::Printers::PdlPassthroughTarget is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Devices::Printers::Print3DDevice>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Devices::Printers;

    PyObject* module = PyState_FindModule(&module_def);

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

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

    auto python_type = state->type_Print3DDevice;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Devices::Printers::Print3DDevice is not registered");
        return nullptr;
    }

    return python_type;
}

PyTypeObject* py::winrt_type<winrt::Windows::Devices::Printers::PrintSchema>::get_python_type() noexcept {
    using namespace py::cpp::Windows::Devices::Printers;

    PyObject* module = PyState_FindModule(&module_def);

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

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

    auto python_type = state->type_PrintSchema;

    if (!python_type) {
        PyErr_SetString(PyExc_RuntimeError, "type winrt::Windows::Devices::Printers::PrintSchema is not registered");
        return nullptr;
    }

    return python_type;
}
