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

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

PyTypeObject* py::winrt_type<winrt::Windows::Devices::Printers::IppAttributeError>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Devices::Printers::IppAttributeValue>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Devices::Printers::IppIntegerRange>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Devices::Printers::IppPrintDevice>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Devices::Printers::IppResolution>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Devices::Printers::IppSetAttributesResult>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Devices::Printers::IppTextWithLanguage>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Devices::Printers::Print3DDevice>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::Devices::Printers::PrintSchema>::python_type;

namespace py::cpp::Windows::Devices::Printers
{
    // ----- IppAttributeError class --------------------
    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)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* IppAttributeError_GetUnsupportedValues(py::wrapper::Windows::Devices::Printers::IppAttributeError* self, PyObject* args) noexcept
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            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
    {
        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
    {
        try
        {
            return py::convert(self->obj.Reason());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    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 },
        { "_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, _new_IppAttributeError },
        { Py_tp_dealloc, _dealloc_IppAttributeError },
        { Py_tp_methods, _methods_IppAttributeError },
        { Py_tp_getset, _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 --------------------
    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)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

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

        if (arg_count == 1)
        {
            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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

                return py::convert(winrt::Windows::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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

                return py::convert(winrt::Windows::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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

                return py::convert(winrt::Windows::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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

                return py::convert(winrt::Windows::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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

                return py::convert(winrt::Windows::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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

                return py::convert(winrt::Windows::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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

                return py::convert(winrt::Windows::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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

                return py::convert(winrt::Windows::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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

                return py::convert(winrt::Windows::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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

                return py::convert(winrt::Windows::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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

                return py::convert(winrt::Windows::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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

                return py::convert(winrt::Windows::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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

                return py::convert(winrt::Windows::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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

                return py::convert(winrt::Windows::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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

                return py::convert(winrt::Windows::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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            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
    {
        try
        {
            return py::convert(self->obj.Kind());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    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 },
        { "_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, _new_IppAttributeValue },
        { Py_tp_dealloc, _dealloc_IppAttributeValue },
        { Py_tp_methods, _methods_IppAttributeValue },
        { Py_tp_getset, _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 --------------------
    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;
        }

        Py_ssize_t 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)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* IppIntegerRange_get_End(py::wrapper::Windows::Devices::Printers::IppIntegerRange* self, void* /*unused*/) noexcept
    {
        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
    {
        try
        {
            return py::convert(self->obj.Start());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    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[] = {
        { "_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, _new_IppIntegerRange },
        { Py_tp_dealloc, _dealloc_IppIntegerRange },
        { Py_tp_methods, _methods_IppIntegerRange },
        { Py_tp_getset, _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 --------------------
    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)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

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

        if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Foundation::Collections::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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

                return py::convert(self->obj.GetPrinterAttributesAsBuffer(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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

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

                return py::convert(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
    {
        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
    {
        try
        {
            return py::convert(self->obj.PrinterUri());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    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[] = {
        { "get_printer_attributes", reinterpret_cast<PyCFunction>(IppPrintDevice_GetPrinterAttributes), METH_VARARGS, nullptr },
        { "get_printer_attributes_as_buffer", reinterpret_cast<PyCFunction>(IppPrintDevice_GetPrinterAttributesAsBuffer), 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 },
        { "_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, _new_IppPrintDevice },
        { Py_tp_dealloc, _dealloc_IppPrintDevice },
        { Py_tp_methods, _methods_IppPrintDevice },
        { Py_tp_getset, _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 --------------------
    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;
        }

        Py_ssize_t 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)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* IppResolution_get_Height(py::wrapper::Windows::Devices::Printers::IppResolution* self, void* /*unused*/) noexcept
    {
        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
    {
        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
    {
        try
        {
            return py::convert(self->obj.Width());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    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[] = {
        { "_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, _new_IppResolution },
        { Py_tp_dealloc, _dealloc_IppResolution },
        { Py_tp_methods, _methods_IppResolution },
        { Py_tp_getset, _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 --------------------
    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)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* IppSetAttributesResult_get_AttributeErrors(py::wrapper::Windows::Devices::Printers::IppSetAttributesResult* self, void* /*unused*/) noexcept
    {
        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
    {
        try
        {
            return py::convert(self->obj.Succeeded());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    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[] = {
        { "_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, _new_IppSetAttributesResult },
        { Py_tp_dealloc, _dealloc_IppSetAttributesResult },
        { Py_tp_methods, _methods_IppSetAttributesResult },
        { Py_tp_getset, _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 --------------------
    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;
        }

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

                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)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* IppTextWithLanguage_get_Language(py::wrapper::Windows::Devices::Printers::IppTextWithLanguage* self, void* /*unused*/) noexcept
    {
        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
    {
        try
        {
            return py::convert(self->obj.Value());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    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[] = {
        { "_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, _new_IppTextWithLanguage },
        { Py_tp_dealloc, _dealloc_IppTextWithLanguage },
        { Py_tp_methods, _methods_IppTextWithLanguage },
        { Py_tp_getset, _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
    };

    // ----- Print3DDevice class --------------------
    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)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

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

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

                return py::convert(winrt::Windows::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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            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
    {
        try
        {
            return py::convert(self->obj.PrintSchema());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    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 },
        { "_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, _new_Print3DDevice },
        { Py_tp_dealloc, _dealloc_Print3DDevice },
        { Py_tp_methods, _methods_Print3DDevice },
        { Py_tp_getset, _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 --------------------
    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)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

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

        if (arg_count == 1)
        {
            try
            {
                auto param0 = py::convert_to<winrt::Windows::Storage::Streams::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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            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
    {
        Py_ssize_t arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            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* _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 },
        { "_from", reinterpret_cast<PyCFunction>(_from_PrintSchema), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_PrintSchema[] = {
        { }
    };

    static PyType_Slot _type_slots_PrintSchema[] = 
    {
        { Py_tp_new, _new_PrintSchema },
        { Py_tp_dealloc, _dealloc_PrintSchema },
        { Py_tp_methods, _methods_PrintSchema },
        { Py_tp_getset, _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 --------------------
    static int module_exec(PyObject* module) noexcept
    {
        try
        {
            py::pyobj_handle bases { PyTuple_Pack(1, py::winrt_type<py::Object>::python_type) };

            py::winrt_type<winrt::Windows::Devices::Printers::IppAttributeError>::python_type = py::register_python_type(module, _type_name_IppAttributeError, &_type_spec_IppAttributeError, bases.get());
            py::winrt_type<winrt::Windows::Devices::Printers::IppAttributeValue>::python_type = py::register_python_type(module, _type_name_IppAttributeValue, &_type_spec_IppAttributeValue, bases.get());
            py::winrt_type<winrt::Windows::Devices::Printers::IppIntegerRange>::python_type = py::register_python_type(module, _type_name_IppIntegerRange, &_type_spec_IppIntegerRange, bases.get());
            py::winrt_type<winrt::Windows::Devices::Printers::IppPrintDevice>::python_type = py::register_python_type(module, _type_name_IppPrintDevice, &_type_spec_IppPrintDevice, bases.get());
            py::winrt_type<winrt::Windows::Devices::Printers::IppResolution>::python_type = py::register_python_type(module, _type_name_IppResolution, &_type_spec_IppResolution, bases.get());
            py::winrt_type<winrt::Windows::Devices::Printers::IppSetAttributesResult>::python_type = py::register_python_type(module, _type_name_IppSetAttributesResult, &_type_spec_IppSetAttributesResult, bases.get());
            py::winrt_type<winrt::Windows::Devices::Printers::IppTextWithLanguage>::python_type = py::register_python_type(module, _type_name_IppTextWithLanguage, &_type_spec_IppTextWithLanguage, bases.get());
            py::winrt_type<winrt::Windows::Devices::Printers::Print3DDevice>::python_type = py::register_python_type(module, _type_name_Print3DDevice, &_type_spec_Print3DDevice, bases.get());
            py::winrt_type<winrt::Windows::Devices::Printers::PrintSchema>::python_type = py::register_python_type(module, _type_name_PrintSchema, &_type_spec_PrintSchema, bases.get());

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

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

    PyDoc_STRVAR(module_doc, "Windows.Devices.Printers");

    static PyModuleDef module_def
        = {PyModuleDef_HEAD_INIT,
           "_winsdk_Windows_Devices_Printers",
           module_doc,
           0,
           nullptr,
           module_slots,
           nullptr,
           nullptr,
           nullptr};
} // py::cpp::Windows::Devices::Printers

PyMODINIT_FUNC
PyInit__winsdk_Windows_Devices_Printers (void) noexcept
{
    return PyModuleDef_Init(&py::cpp::Windows::Devices::Printers::module_def);
}
