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

#include "py.Windows.Devices.PointOfService.Provider.h"


namespace py::cpp::Windows::Devices::PointOfService::Provider
{
    // ----- BarcodeScannerDisableScannerRequest class --------------------

    static PyObject* _new_BarcodeScannerDisableScannerRequest(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerDisableScannerRequest>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerDisableScannerRequest>::type_name);
        return nullptr;
    }

    static void _dealloc_BarcodeScannerDisableScannerRequest(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerDisableScannerRequest* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* BarcodeScannerDisableScannerRequest_ReportCompletedAsync(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerDisableScannerRequest* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerDisableScannerRequest", L"ReportCompletedAsync", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* BarcodeScannerDisableScannerRequest_ReportFailedAsync(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerDisableScannerRequest* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerDisableScannerRequest", L"ReportFailedAsync", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                return py::convert(self->obj.ReportFailedAsync());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerDisableScannerRequest", L"ReportFailedAsync", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

                return py::convert(self->obj.ReportFailedAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerDisableScannerRequest", L"ReportFailedAsync", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

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

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

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

    static PyObject* _from_BarcodeScannerDisableScannerRequest(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::PointOfService::Provider::BarcodeScannerDisableScannerRequest>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_BarcodeScannerDisableScannerRequest[] = {
        { "report_completed_async", reinterpret_cast<PyCFunction>(BarcodeScannerDisableScannerRequest_ReportCompletedAsync), METH_VARARGS, nullptr },
        { "report_failed_async", reinterpret_cast<PyCFunction>(BarcodeScannerDisableScannerRequest_ReportFailedAsync), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_BarcodeScannerDisableScannerRequest, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_BarcodeScannerDisableScannerRequest), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_BarcodeScannerDisableScannerRequest[] = {
        { }
    };

    static PyType_Slot _type_slots_BarcodeScannerDisableScannerRequest[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_BarcodeScannerDisableScannerRequest) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_BarcodeScannerDisableScannerRequest) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_BarcodeScannerDisableScannerRequest) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_BarcodeScannerDisableScannerRequest) },
        { },
    };

    static PyType_Spec type_spec_BarcodeScannerDisableScannerRequest =
    {
        "winrt._winrt_windows_devices_pointofservice_provider.BarcodeScannerDisableScannerRequest",
        sizeof(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerDisableScannerRequest),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_BarcodeScannerDisableScannerRequest
    };

    // ----- BarcodeScannerDisableScannerRequestEventArgs class --------------------

    static PyObject* _new_BarcodeScannerDisableScannerRequestEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerDisableScannerRequestEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerDisableScannerRequestEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_BarcodeScannerDisableScannerRequestEventArgs(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerDisableScannerRequestEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* BarcodeScannerDisableScannerRequestEventArgs_GetDeferral(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerDisableScannerRequestEventArgs* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerDisableScannerRequestEventArgs", L"GetDeferral", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

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

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

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

    static PyObject* _from_BarcodeScannerDisableScannerRequestEventArgs(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::PointOfService::Provider::BarcodeScannerDisableScannerRequestEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_BarcodeScannerDisableScannerRequestEventArgs[] = {
        { "get_deferral", reinterpret_cast<PyCFunction>(BarcodeScannerDisableScannerRequestEventArgs_GetDeferral), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_BarcodeScannerDisableScannerRequestEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_BarcodeScannerDisableScannerRequestEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_BarcodeScannerDisableScannerRequestEventArgs[] = {
        { "request", reinterpret_cast<getter>(BarcodeScannerDisableScannerRequestEventArgs_get_Request), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_BarcodeScannerDisableScannerRequestEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_BarcodeScannerDisableScannerRequestEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_BarcodeScannerDisableScannerRequestEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_BarcodeScannerDisableScannerRequestEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_BarcodeScannerDisableScannerRequestEventArgs) },
        { },
    };

    static PyType_Spec type_spec_BarcodeScannerDisableScannerRequestEventArgs =
    {
        "winrt._winrt_windows_devices_pointofservice_provider.BarcodeScannerDisableScannerRequestEventArgs",
        sizeof(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerDisableScannerRequestEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_BarcodeScannerDisableScannerRequestEventArgs
    };

    // ----- BarcodeScannerEnableScannerRequest class --------------------

    static PyObject* _new_BarcodeScannerEnableScannerRequest(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerEnableScannerRequest>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerEnableScannerRequest>::type_name);
        return nullptr;
    }

    static void _dealloc_BarcodeScannerEnableScannerRequest(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerEnableScannerRequest* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* BarcodeScannerEnableScannerRequest_ReportCompletedAsync(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerEnableScannerRequest* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerEnableScannerRequest", L"ReportCompletedAsync", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* BarcodeScannerEnableScannerRequest_ReportFailedAsync(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerEnableScannerRequest* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerEnableScannerRequest", L"ReportFailedAsync", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                return py::convert(self->obj.ReportFailedAsync());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerEnableScannerRequest", L"ReportFailedAsync", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

                return py::convert(self->obj.ReportFailedAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerEnableScannerRequest", L"ReportFailedAsync", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

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

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

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

    static PyObject* _from_BarcodeScannerEnableScannerRequest(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::PointOfService::Provider::BarcodeScannerEnableScannerRequest>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_BarcodeScannerEnableScannerRequest[] = {
        { "report_completed_async", reinterpret_cast<PyCFunction>(BarcodeScannerEnableScannerRequest_ReportCompletedAsync), METH_VARARGS, nullptr },
        { "report_failed_async", reinterpret_cast<PyCFunction>(BarcodeScannerEnableScannerRequest_ReportFailedAsync), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_BarcodeScannerEnableScannerRequest, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_BarcodeScannerEnableScannerRequest), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_BarcodeScannerEnableScannerRequest[] = {
        { }
    };

    static PyType_Slot _type_slots_BarcodeScannerEnableScannerRequest[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_BarcodeScannerEnableScannerRequest) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_BarcodeScannerEnableScannerRequest) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_BarcodeScannerEnableScannerRequest) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_BarcodeScannerEnableScannerRequest) },
        { },
    };

    static PyType_Spec type_spec_BarcodeScannerEnableScannerRequest =
    {
        "winrt._winrt_windows_devices_pointofservice_provider.BarcodeScannerEnableScannerRequest",
        sizeof(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerEnableScannerRequest),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_BarcodeScannerEnableScannerRequest
    };

    // ----- BarcodeScannerEnableScannerRequestEventArgs class --------------------

    static PyObject* _new_BarcodeScannerEnableScannerRequestEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerEnableScannerRequestEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerEnableScannerRequestEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_BarcodeScannerEnableScannerRequestEventArgs(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerEnableScannerRequestEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* BarcodeScannerEnableScannerRequestEventArgs_GetDeferral(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerEnableScannerRequestEventArgs* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerEnableScannerRequestEventArgs", L"GetDeferral", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

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

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

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

    static PyObject* _from_BarcodeScannerEnableScannerRequestEventArgs(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::PointOfService::Provider::BarcodeScannerEnableScannerRequestEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_BarcodeScannerEnableScannerRequestEventArgs[] = {
        { "get_deferral", reinterpret_cast<PyCFunction>(BarcodeScannerEnableScannerRequestEventArgs_GetDeferral), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_BarcodeScannerEnableScannerRequestEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_BarcodeScannerEnableScannerRequestEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_BarcodeScannerEnableScannerRequestEventArgs[] = {
        { "request", reinterpret_cast<getter>(BarcodeScannerEnableScannerRequestEventArgs_get_Request), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_BarcodeScannerEnableScannerRequestEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_BarcodeScannerEnableScannerRequestEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_BarcodeScannerEnableScannerRequestEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_BarcodeScannerEnableScannerRequestEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_BarcodeScannerEnableScannerRequestEventArgs) },
        { },
    };

    static PyType_Spec type_spec_BarcodeScannerEnableScannerRequestEventArgs =
    {
        "winrt._winrt_windows_devices_pointofservice_provider.BarcodeScannerEnableScannerRequestEventArgs",
        sizeof(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerEnableScannerRequestEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_BarcodeScannerEnableScannerRequestEventArgs
    };

    // ----- BarcodeScannerFrameReader class --------------------

    static PyObject* _new_BarcodeScannerFrameReader(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerFrameReader>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerFrameReader>::type_name);
        return nullptr;
    }

    static void _dealloc_BarcodeScannerFrameReader(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerFrameReader* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* BarcodeScannerFrameReader_Close(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerFrameReader* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReader", 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* BarcodeScannerFrameReader_StartAsync(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerFrameReader* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReader", L"StartAsync", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* BarcodeScannerFrameReader_StopAsync(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerFrameReader* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReader", L"StopAsync", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* BarcodeScannerFrameReader_TryAcquireLatestFrameAsync(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerFrameReader* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReader", L"TryAcquireLatestFrameAsync", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

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

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

    static PyObject* BarcodeScannerFrameReader_add_FrameArrived(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerFrameReader* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReader", L"FrameArrived"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerFrameReader, winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerFrameReaderFrameArrivedEventArgs>>(arg);

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

    static PyObject* BarcodeScannerFrameReader_remove_FrameArrived(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerFrameReader* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReader", L"FrameArrived"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

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

    static PyObject* _from_BarcodeScannerFrameReader(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::PointOfService::Provider::BarcodeScannerFrameReader>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _enter_BarcodeScannerFrameReader(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerFrameReader* self, PyObject* /*unused*/) noexcept
    {
        return Py_NewRef(self);
    }

    static PyObject* _exit_BarcodeScannerFrameReader(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerFrameReader* self, PyObject* /*unused*/) noexcept
    {
        try
        {
            self->obj.Close();
            Py_RETURN_FALSE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_BarcodeScannerFrameReader[] = {
        { "close", reinterpret_cast<PyCFunction>(BarcodeScannerFrameReader_Close), METH_VARARGS, nullptr },
        { "start_async", reinterpret_cast<PyCFunction>(BarcodeScannerFrameReader_StartAsync), METH_VARARGS, nullptr },
        { "stop_async", reinterpret_cast<PyCFunction>(BarcodeScannerFrameReader_StopAsync), METH_VARARGS, nullptr },
        { "try_acquire_latest_frame_async", reinterpret_cast<PyCFunction>(BarcodeScannerFrameReader_TryAcquireLatestFrameAsync), METH_VARARGS, nullptr },
        { "add_frame_arrived", reinterpret_cast<PyCFunction>(BarcodeScannerFrameReader_add_FrameArrived), METH_O, nullptr },
        { "remove_frame_arrived", reinterpret_cast<PyCFunction>(BarcodeScannerFrameReader_remove_FrameArrived), METH_O, nullptr },
        { "_assign_array_", _assign_array_BarcodeScannerFrameReader, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_BarcodeScannerFrameReader), METH_O | METH_STATIC, nullptr },
        { "__enter__", reinterpret_cast<PyCFunction>(_enter_BarcodeScannerFrameReader), METH_NOARGS, nullptr },
        { "__exit__",  reinterpret_cast<PyCFunction>(_exit_BarcodeScannerFrameReader), METH_VARARGS, nullptr },
        { }
    };

    static PyGetSetDef _getset_BarcodeScannerFrameReader[] = {
        { "connection", reinterpret_cast<getter>(BarcodeScannerFrameReader_get_Connection), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_BarcodeScannerFrameReader[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_BarcodeScannerFrameReader) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_BarcodeScannerFrameReader) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_BarcodeScannerFrameReader) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_BarcodeScannerFrameReader) },
        { },
    };

    static PyType_Spec type_spec_BarcodeScannerFrameReader =
    {
        "winrt._winrt_windows_devices_pointofservice_provider.BarcodeScannerFrameReader",
        sizeof(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerFrameReader),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_BarcodeScannerFrameReader
    };

    // ----- BarcodeScannerFrameReaderFrameArrivedEventArgs class --------------------

    static PyObject* _new_BarcodeScannerFrameReaderFrameArrivedEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerFrameReaderFrameArrivedEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerFrameReaderFrameArrivedEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_BarcodeScannerFrameReaderFrameArrivedEventArgs(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerFrameReaderFrameArrivedEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* BarcodeScannerFrameReaderFrameArrivedEventArgs_GetDeferral(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerFrameReaderFrameArrivedEventArgs* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerFrameReaderFrameArrivedEventArgs", L"GetDeferral", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

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

    static PyObject* _from_BarcodeScannerFrameReaderFrameArrivedEventArgs(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::PointOfService::Provider::BarcodeScannerFrameReaderFrameArrivedEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_BarcodeScannerFrameReaderFrameArrivedEventArgs[] = {
        { "get_deferral", reinterpret_cast<PyCFunction>(BarcodeScannerFrameReaderFrameArrivedEventArgs_GetDeferral), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_BarcodeScannerFrameReaderFrameArrivedEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_BarcodeScannerFrameReaderFrameArrivedEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_BarcodeScannerFrameReaderFrameArrivedEventArgs[] = {
        { }
    };

    static PyType_Slot _type_slots_BarcodeScannerFrameReaderFrameArrivedEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_BarcodeScannerFrameReaderFrameArrivedEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_BarcodeScannerFrameReaderFrameArrivedEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_BarcodeScannerFrameReaderFrameArrivedEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_BarcodeScannerFrameReaderFrameArrivedEventArgs) },
        { },
    };

    static PyType_Spec type_spec_BarcodeScannerFrameReaderFrameArrivedEventArgs =
    {
        "winrt._winrt_windows_devices_pointofservice_provider.BarcodeScannerFrameReaderFrameArrivedEventArgs",
        sizeof(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerFrameReaderFrameArrivedEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_BarcodeScannerFrameReaderFrameArrivedEventArgs
    };

    // ----- BarcodeScannerGetSymbologyAttributesRequest class --------------------

    static PyObject* _new_BarcodeScannerGetSymbologyAttributesRequest(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerGetSymbologyAttributesRequest>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerGetSymbologyAttributesRequest>::type_name);
        return nullptr;
    }

    static void _dealloc_BarcodeScannerGetSymbologyAttributesRequest(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerGetSymbologyAttributesRequest* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* BarcodeScannerGetSymbologyAttributesRequest_ReportCompletedAsync(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerGetSymbologyAttributesRequest* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerGetSymbologyAttributesRequest", L"ReportCompletedAsync", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

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

    static PyObject* BarcodeScannerGetSymbologyAttributesRequest_ReportFailedAsync(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerGetSymbologyAttributesRequest* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerGetSymbologyAttributesRequest", L"ReportFailedAsync", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                return py::convert(self->obj.ReportFailedAsync());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerGetSymbologyAttributesRequest", L"ReportFailedAsync", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

                return py::convert(self->obj.ReportFailedAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerGetSymbologyAttributesRequest", L"ReportFailedAsync", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

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

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

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

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

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

    static PyObject* _from_BarcodeScannerGetSymbologyAttributesRequest(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::PointOfService::Provider::BarcodeScannerGetSymbologyAttributesRequest>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_BarcodeScannerGetSymbologyAttributesRequest[] = {
        { "report_completed_async", reinterpret_cast<PyCFunction>(BarcodeScannerGetSymbologyAttributesRequest_ReportCompletedAsync), METH_VARARGS, nullptr },
        { "report_failed_async", reinterpret_cast<PyCFunction>(BarcodeScannerGetSymbologyAttributesRequest_ReportFailedAsync), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_BarcodeScannerGetSymbologyAttributesRequest, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_BarcodeScannerGetSymbologyAttributesRequest), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_BarcodeScannerGetSymbologyAttributesRequest[] = {
        { "symbology", reinterpret_cast<getter>(BarcodeScannerGetSymbologyAttributesRequest_get_Symbology), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_BarcodeScannerGetSymbologyAttributesRequest[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_BarcodeScannerGetSymbologyAttributesRequest) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_BarcodeScannerGetSymbologyAttributesRequest) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_BarcodeScannerGetSymbologyAttributesRequest) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_BarcodeScannerGetSymbologyAttributesRequest) },
        { },
    };

    static PyType_Spec type_spec_BarcodeScannerGetSymbologyAttributesRequest =
    {
        "winrt._winrt_windows_devices_pointofservice_provider.BarcodeScannerGetSymbologyAttributesRequest",
        sizeof(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerGetSymbologyAttributesRequest),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_BarcodeScannerGetSymbologyAttributesRequest
    };

    // ----- BarcodeScannerGetSymbologyAttributesRequestEventArgs class --------------------

    static PyObject* _new_BarcodeScannerGetSymbologyAttributesRequestEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerGetSymbologyAttributesRequestEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerGetSymbologyAttributesRequestEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_BarcodeScannerGetSymbologyAttributesRequestEventArgs(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerGetSymbologyAttributesRequestEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* BarcodeScannerGetSymbologyAttributesRequestEventArgs_GetDeferral(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerGetSymbologyAttributesRequestEventArgs* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerGetSymbologyAttributesRequestEventArgs", L"GetDeferral", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

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

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

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

    static PyObject* _from_BarcodeScannerGetSymbologyAttributesRequestEventArgs(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::PointOfService::Provider::BarcodeScannerGetSymbologyAttributesRequestEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_BarcodeScannerGetSymbologyAttributesRequestEventArgs[] = {
        { "get_deferral", reinterpret_cast<PyCFunction>(BarcodeScannerGetSymbologyAttributesRequestEventArgs_GetDeferral), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_BarcodeScannerGetSymbologyAttributesRequestEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_BarcodeScannerGetSymbologyAttributesRequestEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_BarcodeScannerGetSymbologyAttributesRequestEventArgs[] = {
        { "request", reinterpret_cast<getter>(BarcodeScannerGetSymbologyAttributesRequestEventArgs_get_Request), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_BarcodeScannerGetSymbologyAttributesRequestEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_BarcodeScannerGetSymbologyAttributesRequestEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_BarcodeScannerGetSymbologyAttributesRequestEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_BarcodeScannerGetSymbologyAttributesRequestEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_BarcodeScannerGetSymbologyAttributesRequestEventArgs) },
        { },
    };

    static PyType_Spec type_spec_BarcodeScannerGetSymbologyAttributesRequestEventArgs =
    {
        "winrt._winrt_windows_devices_pointofservice_provider.BarcodeScannerGetSymbologyAttributesRequestEventArgs",
        sizeof(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerGetSymbologyAttributesRequestEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_BarcodeScannerGetSymbologyAttributesRequestEventArgs
    };

    // ----- BarcodeScannerHideVideoPreviewRequest class --------------------

    static PyObject* _new_BarcodeScannerHideVideoPreviewRequest(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerHideVideoPreviewRequest>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerHideVideoPreviewRequest>::type_name);
        return nullptr;
    }

    static void _dealloc_BarcodeScannerHideVideoPreviewRequest(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerHideVideoPreviewRequest* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* BarcodeScannerHideVideoPreviewRequest_ReportCompletedAsync(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerHideVideoPreviewRequest* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerHideVideoPreviewRequest", L"ReportCompletedAsync", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* BarcodeScannerHideVideoPreviewRequest_ReportFailedAsync(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerHideVideoPreviewRequest* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerHideVideoPreviewRequest", L"ReportFailedAsync", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                return py::convert(self->obj.ReportFailedAsync());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerHideVideoPreviewRequest", L"ReportFailedAsync", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

                return py::convert(self->obj.ReportFailedAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerHideVideoPreviewRequest", L"ReportFailedAsync", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

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

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

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

    static PyObject* _from_BarcodeScannerHideVideoPreviewRequest(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::PointOfService::Provider::BarcodeScannerHideVideoPreviewRequest>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_BarcodeScannerHideVideoPreviewRequest[] = {
        { "report_completed_async", reinterpret_cast<PyCFunction>(BarcodeScannerHideVideoPreviewRequest_ReportCompletedAsync), METH_VARARGS, nullptr },
        { "report_failed_async", reinterpret_cast<PyCFunction>(BarcodeScannerHideVideoPreviewRequest_ReportFailedAsync), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_BarcodeScannerHideVideoPreviewRequest, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_BarcodeScannerHideVideoPreviewRequest), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_BarcodeScannerHideVideoPreviewRequest[] = {
        { }
    };

    static PyType_Slot _type_slots_BarcodeScannerHideVideoPreviewRequest[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_BarcodeScannerHideVideoPreviewRequest) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_BarcodeScannerHideVideoPreviewRequest) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_BarcodeScannerHideVideoPreviewRequest) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_BarcodeScannerHideVideoPreviewRequest) },
        { },
    };

    static PyType_Spec type_spec_BarcodeScannerHideVideoPreviewRequest =
    {
        "winrt._winrt_windows_devices_pointofservice_provider.BarcodeScannerHideVideoPreviewRequest",
        sizeof(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerHideVideoPreviewRequest),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_BarcodeScannerHideVideoPreviewRequest
    };

    // ----- BarcodeScannerHideVideoPreviewRequestEventArgs class --------------------

    static PyObject* _new_BarcodeScannerHideVideoPreviewRequestEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerHideVideoPreviewRequestEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerHideVideoPreviewRequestEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_BarcodeScannerHideVideoPreviewRequestEventArgs(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerHideVideoPreviewRequestEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* BarcodeScannerHideVideoPreviewRequestEventArgs_GetDeferral(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerHideVideoPreviewRequestEventArgs* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerHideVideoPreviewRequestEventArgs", L"GetDeferral", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

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

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

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

    static PyObject* _from_BarcodeScannerHideVideoPreviewRequestEventArgs(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::PointOfService::Provider::BarcodeScannerHideVideoPreviewRequestEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_BarcodeScannerHideVideoPreviewRequestEventArgs[] = {
        { "get_deferral", reinterpret_cast<PyCFunction>(BarcodeScannerHideVideoPreviewRequestEventArgs_GetDeferral), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_BarcodeScannerHideVideoPreviewRequestEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_BarcodeScannerHideVideoPreviewRequestEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_BarcodeScannerHideVideoPreviewRequestEventArgs[] = {
        { "request", reinterpret_cast<getter>(BarcodeScannerHideVideoPreviewRequestEventArgs_get_Request), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_BarcodeScannerHideVideoPreviewRequestEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_BarcodeScannerHideVideoPreviewRequestEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_BarcodeScannerHideVideoPreviewRequestEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_BarcodeScannerHideVideoPreviewRequestEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_BarcodeScannerHideVideoPreviewRequestEventArgs) },
        { },
    };

    static PyType_Spec type_spec_BarcodeScannerHideVideoPreviewRequestEventArgs =
    {
        "winrt._winrt_windows_devices_pointofservice_provider.BarcodeScannerHideVideoPreviewRequestEventArgs",
        sizeof(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerHideVideoPreviewRequestEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_BarcodeScannerHideVideoPreviewRequestEventArgs
    };

    // ----- BarcodeScannerProviderConnection class --------------------

    static PyObject* _new_BarcodeScannerProviderConnection(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerProviderConnection>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerProviderConnection>::type_name);
        return nullptr;
    }

    static void _dealloc_BarcodeScannerProviderConnection(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerProviderConnection* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* BarcodeScannerProviderConnection_Close(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerProviderConnection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection", 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* BarcodeScannerProviderConnection_CreateFrameReaderAsync(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerProviderConnection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection", L"CreateFrameReaderAsync", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                return py::convert(self->obj.CreateFrameReaderAsync());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection", L"CreateFrameReaderAsync", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Graphics::Imaging::BitmapPixelFormat>(args, 0);

                return py::convert(self->obj.CreateFrameReaderAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection", L"CreateFrameReaderAsync", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Graphics::Imaging::BitmapPixelFormat>(args, 0);
                auto param1 = py::convert_to<winrt::Windows::Graphics::Imaging::BitmapSize>(args, 1);

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

    static PyObject* BarcodeScannerProviderConnection_ReportErrorAsync(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerProviderConnection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection", L"ReportErrorAsync", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

                return py::convert(self->obj.ReportErrorAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 3)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection", L"ReportErrorAsync", 3))
            {
                py::set_arg_count_version_error(3);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Devices::PointOfService::UnifiedPosErrorData>(args, 0);
                auto param1 = py::convert_to<bool>(args, 1);
                auto param2 = py::convert_to<winrt::Windows::Devices::PointOfService::BarcodeScannerReport>(args, 2);

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

    static PyObject* BarcodeScannerProviderConnection_ReportScannedDataAsync(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerProviderConnection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection", L"ReportScannedDataAsync", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

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

    static PyObject* BarcodeScannerProviderConnection_ReportTriggerStateAsync(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerProviderConnection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection", L"ReportTriggerStateAsync", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

            try
            {
                auto param0 = py::convert_to<winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerTriggerState>(args, 0);

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

    static PyObject* BarcodeScannerProviderConnection_Start(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerProviderConnection* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection", L"Start", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

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

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

    static int BarcodeScannerProviderConnection_put_Version(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerProviderConnection* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection", L"Version"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

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

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

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

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

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

    static int BarcodeScannerProviderConnection_put_Name(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerProviderConnection* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection", L"Name"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

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

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

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

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

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

    static int BarcodeScannerProviderConnection_put_CompanyName(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerProviderConnection* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection", L"CompanyName"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return -1;
        }

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

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

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

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

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

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

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

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

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

    static PyObject* BarcodeScannerProviderConnection_add_DisableScannerRequested(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerProviderConnection* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection", L"DisableScannerRequested"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerProviderConnection, winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerDisableScannerRequestEventArgs>>(arg);

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

    static PyObject* BarcodeScannerProviderConnection_remove_DisableScannerRequested(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerProviderConnection* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection", L"DisableScannerRequested"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* BarcodeScannerProviderConnection_add_EnableScannerRequested(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerProviderConnection* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection", L"EnableScannerRequested"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerProviderConnection, winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerEnableScannerRequestEventArgs>>(arg);

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

    static PyObject* BarcodeScannerProviderConnection_remove_EnableScannerRequested(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerProviderConnection* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection", L"EnableScannerRequested"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* BarcodeScannerProviderConnection_add_GetBarcodeSymbologyAttributesRequested(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerProviderConnection* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection", L"GetBarcodeSymbologyAttributesRequested"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerProviderConnection, winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerGetSymbologyAttributesRequestEventArgs>>(arg);

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

    static PyObject* BarcodeScannerProviderConnection_remove_GetBarcodeSymbologyAttributesRequested(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerProviderConnection* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection", L"GetBarcodeSymbologyAttributesRequested"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* BarcodeScannerProviderConnection_add_HideVideoPreviewRequested(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerProviderConnection* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection", L"HideVideoPreviewRequested"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerProviderConnection, winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerHideVideoPreviewRequestEventArgs>>(arg);

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

    static PyObject* BarcodeScannerProviderConnection_remove_HideVideoPreviewRequested(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerProviderConnection* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection", L"HideVideoPreviewRequested"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* BarcodeScannerProviderConnection_add_SetActiveSymbologiesRequested(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerProviderConnection* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection", L"SetActiveSymbologiesRequested"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerProviderConnection, winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerSetActiveSymbologiesRequestEventArgs>>(arg);

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

    static PyObject* BarcodeScannerProviderConnection_remove_SetActiveSymbologiesRequested(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerProviderConnection* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection", L"SetActiveSymbologiesRequested"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* BarcodeScannerProviderConnection_add_SetBarcodeSymbologyAttributesRequested(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerProviderConnection* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection", L"SetBarcodeSymbologyAttributesRequested"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerProviderConnection, winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerSetSymbologyAttributesRequestEventArgs>>(arg);

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

    static PyObject* BarcodeScannerProviderConnection_remove_SetBarcodeSymbologyAttributesRequested(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerProviderConnection* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection", L"SetBarcodeSymbologyAttributesRequested"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* BarcodeScannerProviderConnection_add_StartSoftwareTriggerRequested(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerProviderConnection* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection", L"StartSoftwareTriggerRequested"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerProviderConnection, winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerStartSoftwareTriggerRequestEventArgs>>(arg);

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

    static PyObject* BarcodeScannerProviderConnection_remove_StartSoftwareTriggerRequested(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerProviderConnection* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection", L"StartSoftwareTriggerRequested"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

    static PyObject* BarcodeScannerProviderConnection_add_StopSoftwareTriggerRequested(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerProviderConnection* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection", L"StopSoftwareTriggerRequested"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

        try
        {
            auto param0 = py::convert_to<winrt::Windows::Foundation::TypedEventHandler<winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerProviderConnection, winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerStopSoftwareTriggerRequestEventArgs>>(arg);

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

    static PyObject* BarcodeScannerProviderConnection_remove_StopSoftwareTriggerRequested(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerProviderConnection* self, PyObject* arg) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsEventPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerProviderConnection", L"StopSoftwareTriggerRequested"))
        {
            PyErr_SetString(PyExc_AttributeError, "event is not available in this version of Windows");
            return nullptr;
        }

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

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

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

    static PyObject* _from_BarcodeScannerProviderConnection(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::PointOfService::Provider::BarcodeScannerProviderConnection>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _enter_BarcodeScannerProviderConnection(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerProviderConnection* self, PyObject* /*unused*/) noexcept
    {
        return Py_NewRef(self);
    }

    static PyObject* _exit_BarcodeScannerProviderConnection(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerProviderConnection* self, PyObject* /*unused*/) noexcept
    {
        try
        {
            self->obj.Close();
            Py_RETURN_FALSE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_BarcodeScannerProviderConnection[] = {
        { "close", reinterpret_cast<PyCFunction>(BarcodeScannerProviderConnection_Close), METH_VARARGS, nullptr },
        { "create_frame_reader_async", reinterpret_cast<PyCFunction>(BarcodeScannerProviderConnection_CreateFrameReaderAsync), METH_VARARGS, nullptr },
        { "report_error_async", reinterpret_cast<PyCFunction>(BarcodeScannerProviderConnection_ReportErrorAsync), METH_VARARGS, nullptr },
        { "report_scanned_data_async", reinterpret_cast<PyCFunction>(BarcodeScannerProviderConnection_ReportScannedDataAsync), METH_VARARGS, nullptr },
        { "report_trigger_state_async", reinterpret_cast<PyCFunction>(BarcodeScannerProviderConnection_ReportTriggerStateAsync), METH_VARARGS, nullptr },
        { "start", reinterpret_cast<PyCFunction>(BarcodeScannerProviderConnection_Start), METH_VARARGS, nullptr },
        { "add_disable_scanner_requested", reinterpret_cast<PyCFunction>(BarcodeScannerProviderConnection_add_DisableScannerRequested), METH_O, nullptr },
        { "remove_disable_scanner_requested", reinterpret_cast<PyCFunction>(BarcodeScannerProviderConnection_remove_DisableScannerRequested), METH_O, nullptr },
        { "add_enable_scanner_requested", reinterpret_cast<PyCFunction>(BarcodeScannerProviderConnection_add_EnableScannerRequested), METH_O, nullptr },
        { "remove_enable_scanner_requested", reinterpret_cast<PyCFunction>(BarcodeScannerProviderConnection_remove_EnableScannerRequested), METH_O, nullptr },
        { "add_get_barcode_symbology_attributes_requested", reinterpret_cast<PyCFunction>(BarcodeScannerProviderConnection_add_GetBarcodeSymbologyAttributesRequested), METH_O, nullptr },
        { "remove_get_barcode_symbology_attributes_requested", reinterpret_cast<PyCFunction>(BarcodeScannerProviderConnection_remove_GetBarcodeSymbologyAttributesRequested), METH_O, nullptr },
        { "add_hide_video_preview_requested", reinterpret_cast<PyCFunction>(BarcodeScannerProviderConnection_add_HideVideoPreviewRequested), METH_O, nullptr },
        { "remove_hide_video_preview_requested", reinterpret_cast<PyCFunction>(BarcodeScannerProviderConnection_remove_HideVideoPreviewRequested), METH_O, nullptr },
        { "add_set_active_symbologies_requested", reinterpret_cast<PyCFunction>(BarcodeScannerProviderConnection_add_SetActiveSymbologiesRequested), METH_O, nullptr },
        { "remove_set_active_symbologies_requested", reinterpret_cast<PyCFunction>(BarcodeScannerProviderConnection_remove_SetActiveSymbologiesRequested), METH_O, nullptr },
        { "add_set_barcode_symbology_attributes_requested", reinterpret_cast<PyCFunction>(BarcodeScannerProviderConnection_add_SetBarcodeSymbologyAttributesRequested), METH_O, nullptr },
        { "remove_set_barcode_symbology_attributes_requested", reinterpret_cast<PyCFunction>(BarcodeScannerProviderConnection_remove_SetBarcodeSymbologyAttributesRequested), METH_O, nullptr },
        { "add_start_software_trigger_requested", reinterpret_cast<PyCFunction>(BarcodeScannerProviderConnection_add_StartSoftwareTriggerRequested), METH_O, nullptr },
        { "remove_start_software_trigger_requested", reinterpret_cast<PyCFunction>(BarcodeScannerProviderConnection_remove_StartSoftwareTriggerRequested), METH_O, nullptr },
        { "add_stop_software_trigger_requested", reinterpret_cast<PyCFunction>(BarcodeScannerProviderConnection_add_StopSoftwareTriggerRequested), METH_O, nullptr },
        { "remove_stop_software_trigger_requested", reinterpret_cast<PyCFunction>(BarcodeScannerProviderConnection_remove_StopSoftwareTriggerRequested), METH_O, nullptr },
        { "_assign_array_", _assign_array_BarcodeScannerProviderConnection, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_BarcodeScannerProviderConnection), METH_O | METH_STATIC, nullptr },
        { "__enter__", reinterpret_cast<PyCFunction>(_enter_BarcodeScannerProviderConnection), METH_NOARGS, nullptr },
        { "__exit__",  reinterpret_cast<PyCFunction>(_exit_BarcodeScannerProviderConnection), METH_VARARGS, nullptr },
        { }
    };

    static PyGetSetDef _getset_BarcodeScannerProviderConnection[] = {
        { "version", reinterpret_cast<getter>(BarcodeScannerProviderConnection_get_Version), reinterpret_cast<setter>(BarcodeScannerProviderConnection_put_Version), nullptr, nullptr },
        { "name", reinterpret_cast<getter>(BarcodeScannerProviderConnection_get_Name), reinterpret_cast<setter>(BarcodeScannerProviderConnection_put_Name), nullptr, nullptr },
        { "company_name", reinterpret_cast<getter>(BarcodeScannerProviderConnection_get_CompanyName), reinterpret_cast<setter>(BarcodeScannerProviderConnection_put_CompanyName), nullptr, nullptr },
        { "id", reinterpret_cast<getter>(BarcodeScannerProviderConnection_get_Id), nullptr, nullptr, nullptr },
        { "supported_symbologies", reinterpret_cast<getter>(BarcodeScannerProviderConnection_get_SupportedSymbologies), nullptr, nullptr, nullptr },
        { "video_device_id", reinterpret_cast<getter>(BarcodeScannerProviderConnection_get_VideoDeviceId), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_BarcodeScannerProviderConnection[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_BarcodeScannerProviderConnection) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_BarcodeScannerProviderConnection) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_BarcodeScannerProviderConnection) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_BarcodeScannerProviderConnection) },
        { },
    };

    static PyType_Spec type_spec_BarcodeScannerProviderConnection =
    {
        "winrt._winrt_windows_devices_pointofservice_provider.BarcodeScannerProviderConnection",
        sizeof(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerProviderConnection),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_BarcodeScannerProviderConnection
    };

    // ----- BarcodeScannerProviderTriggerDetails class --------------------

    static PyObject* _new_BarcodeScannerProviderTriggerDetails(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerProviderTriggerDetails>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerProviderTriggerDetails>::type_name);
        return nullptr;
    }

    static void _dealloc_BarcodeScannerProviderTriggerDetails(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerProviderTriggerDetails* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

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

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

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

    static PyObject* _from_BarcodeScannerProviderTriggerDetails(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::PointOfService::Provider::BarcodeScannerProviderTriggerDetails>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_BarcodeScannerProviderTriggerDetails[] = {
        { "_assign_array_", _assign_array_BarcodeScannerProviderTriggerDetails, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_BarcodeScannerProviderTriggerDetails), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_BarcodeScannerProviderTriggerDetails[] = {
        { "connection", reinterpret_cast<getter>(BarcodeScannerProviderTriggerDetails_get_Connection), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_BarcodeScannerProviderTriggerDetails[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_BarcodeScannerProviderTriggerDetails) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_BarcodeScannerProviderTriggerDetails) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_BarcodeScannerProviderTriggerDetails) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_BarcodeScannerProviderTriggerDetails) },
        { },
    };

    static PyType_Spec type_spec_BarcodeScannerProviderTriggerDetails =
    {
        "winrt._winrt_windows_devices_pointofservice_provider.BarcodeScannerProviderTriggerDetails",
        sizeof(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerProviderTriggerDetails),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_BarcodeScannerProviderTriggerDetails
    };

    // ----- BarcodeScannerSetActiveSymbologiesRequest class --------------------

    static PyObject* _new_BarcodeScannerSetActiveSymbologiesRequest(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerSetActiveSymbologiesRequest>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerSetActiveSymbologiesRequest>::type_name);
        return nullptr;
    }

    static void _dealloc_BarcodeScannerSetActiveSymbologiesRequest(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerSetActiveSymbologiesRequest* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* BarcodeScannerSetActiveSymbologiesRequest_ReportCompletedAsync(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerSetActiveSymbologiesRequest* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerSetActiveSymbologiesRequest", L"ReportCompletedAsync", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* BarcodeScannerSetActiveSymbologiesRequest_ReportFailedAsync(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerSetActiveSymbologiesRequest* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerSetActiveSymbologiesRequest", L"ReportFailedAsync", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                return py::convert(self->obj.ReportFailedAsync());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerSetActiveSymbologiesRequest", L"ReportFailedAsync", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

                return py::convert(self->obj.ReportFailedAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerSetActiveSymbologiesRequest", L"ReportFailedAsync", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

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

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

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

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

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

    static PyObject* _from_BarcodeScannerSetActiveSymbologiesRequest(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::PointOfService::Provider::BarcodeScannerSetActiveSymbologiesRequest>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_BarcodeScannerSetActiveSymbologiesRequest[] = {
        { "report_completed_async", reinterpret_cast<PyCFunction>(BarcodeScannerSetActiveSymbologiesRequest_ReportCompletedAsync), METH_VARARGS, nullptr },
        { "report_failed_async", reinterpret_cast<PyCFunction>(BarcodeScannerSetActiveSymbologiesRequest_ReportFailedAsync), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_BarcodeScannerSetActiveSymbologiesRequest, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_BarcodeScannerSetActiveSymbologiesRequest), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_BarcodeScannerSetActiveSymbologiesRequest[] = {
        { "symbologies", reinterpret_cast<getter>(BarcodeScannerSetActiveSymbologiesRequest_get_Symbologies), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_BarcodeScannerSetActiveSymbologiesRequest[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_BarcodeScannerSetActiveSymbologiesRequest) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_BarcodeScannerSetActiveSymbologiesRequest) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_BarcodeScannerSetActiveSymbologiesRequest) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_BarcodeScannerSetActiveSymbologiesRequest) },
        { },
    };

    static PyType_Spec type_spec_BarcodeScannerSetActiveSymbologiesRequest =
    {
        "winrt._winrt_windows_devices_pointofservice_provider.BarcodeScannerSetActiveSymbologiesRequest",
        sizeof(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerSetActiveSymbologiesRequest),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_BarcodeScannerSetActiveSymbologiesRequest
    };

    // ----- BarcodeScannerSetActiveSymbologiesRequestEventArgs class --------------------

    static PyObject* _new_BarcodeScannerSetActiveSymbologiesRequestEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerSetActiveSymbologiesRequestEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerSetActiveSymbologiesRequestEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_BarcodeScannerSetActiveSymbologiesRequestEventArgs(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerSetActiveSymbologiesRequestEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* BarcodeScannerSetActiveSymbologiesRequestEventArgs_GetDeferral(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerSetActiveSymbologiesRequestEventArgs* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerSetActiveSymbologiesRequestEventArgs", L"GetDeferral", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

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

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

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

    static PyObject* _from_BarcodeScannerSetActiveSymbologiesRequestEventArgs(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::PointOfService::Provider::BarcodeScannerSetActiveSymbologiesRequestEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_BarcodeScannerSetActiveSymbologiesRequestEventArgs[] = {
        { "get_deferral", reinterpret_cast<PyCFunction>(BarcodeScannerSetActiveSymbologiesRequestEventArgs_GetDeferral), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_BarcodeScannerSetActiveSymbologiesRequestEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_BarcodeScannerSetActiveSymbologiesRequestEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_BarcodeScannerSetActiveSymbologiesRequestEventArgs[] = {
        { "request", reinterpret_cast<getter>(BarcodeScannerSetActiveSymbologiesRequestEventArgs_get_Request), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_BarcodeScannerSetActiveSymbologiesRequestEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_BarcodeScannerSetActiveSymbologiesRequestEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_BarcodeScannerSetActiveSymbologiesRequestEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_BarcodeScannerSetActiveSymbologiesRequestEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_BarcodeScannerSetActiveSymbologiesRequestEventArgs) },
        { },
    };

    static PyType_Spec type_spec_BarcodeScannerSetActiveSymbologiesRequestEventArgs =
    {
        "winrt._winrt_windows_devices_pointofservice_provider.BarcodeScannerSetActiveSymbologiesRequestEventArgs",
        sizeof(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerSetActiveSymbologiesRequestEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_BarcodeScannerSetActiveSymbologiesRequestEventArgs
    };

    // ----- BarcodeScannerSetSymbologyAttributesRequest class --------------------

    static PyObject* _new_BarcodeScannerSetSymbologyAttributesRequest(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerSetSymbologyAttributesRequest>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerSetSymbologyAttributesRequest>::type_name);
        return nullptr;
    }

    static void _dealloc_BarcodeScannerSetSymbologyAttributesRequest(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerSetSymbologyAttributesRequest* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* BarcodeScannerSetSymbologyAttributesRequest_ReportCompletedAsync(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerSetSymbologyAttributesRequest* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerSetSymbologyAttributesRequest", L"ReportCompletedAsync", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* BarcodeScannerSetSymbologyAttributesRequest_ReportFailedAsync(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerSetSymbologyAttributesRequest* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerSetSymbologyAttributesRequest", L"ReportFailedAsync", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                return py::convert(self->obj.ReportFailedAsync());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerSetSymbologyAttributesRequest", L"ReportFailedAsync", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

                return py::convert(self->obj.ReportFailedAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerSetSymbologyAttributesRequest", L"ReportFailedAsync", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

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

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

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

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

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

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

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

    static PyObject* _from_BarcodeScannerSetSymbologyAttributesRequest(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::PointOfService::Provider::BarcodeScannerSetSymbologyAttributesRequest>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_BarcodeScannerSetSymbologyAttributesRequest[] = {
        { "report_completed_async", reinterpret_cast<PyCFunction>(BarcodeScannerSetSymbologyAttributesRequest_ReportCompletedAsync), METH_VARARGS, nullptr },
        { "report_failed_async", reinterpret_cast<PyCFunction>(BarcodeScannerSetSymbologyAttributesRequest_ReportFailedAsync), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_BarcodeScannerSetSymbologyAttributesRequest, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_BarcodeScannerSetSymbologyAttributesRequest), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_BarcodeScannerSetSymbologyAttributesRequest[] = {
        { "attributes", reinterpret_cast<getter>(BarcodeScannerSetSymbologyAttributesRequest_get_Attributes), nullptr, nullptr, nullptr },
        { "symbology", reinterpret_cast<getter>(BarcodeScannerSetSymbologyAttributesRequest_get_Symbology), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_BarcodeScannerSetSymbologyAttributesRequest[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_BarcodeScannerSetSymbologyAttributesRequest) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_BarcodeScannerSetSymbologyAttributesRequest) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_BarcodeScannerSetSymbologyAttributesRequest) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_BarcodeScannerSetSymbologyAttributesRequest) },
        { },
    };

    static PyType_Spec type_spec_BarcodeScannerSetSymbologyAttributesRequest =
    {
        "winrt._winrt_windows_devices_pointofservice_provider.BarcodeScannerSetSymbologyAttributesRequest",
        sizeof(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerSetSymbologyAttributesRequest),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_BarcodeScannerSetSymbologyAttributesRequest
    };

    // ----- BarcodeScannerSetSymbologyAttributesRequestEventArgs class --------------------

    static PyObject* _new_BarcodeScannerSetSymbologyAttributesRequestEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerSetSymbologyAttributesRequestEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerSetSymbologyAttributesRequestEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_BarcodeScannerSetSymbologyAttributesRequestEventArgs(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerSetSymbologyAttributesRequestEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* BarcodeScannerSetSymbologyAttributesRequestEventArgs_GetDeferral(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerSetSymbologyAttributesRequestEventArgs* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerSetSymbologyAttributesRequestEventArgs", L"GetDeferral", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

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

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

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

    static PyObject* _from_BarcodeScannerSetSymbologyAttributesRequestEventArgs(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::PointOfService::Provider::BarcodeScannerSetSymbologyAttributesRequestEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_BarcodeScannerSetSymbologyAttributesRequestEventArgs[] = {
        { "get_deferral", reinterpret_cast<PyCFunction>(BarcodeScannerSetSymbologyAttributesRequestEventArgs_GetDeferral), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_BarcodeScannerSetSymbologyAttributesRequestEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_BarcodeScannerSetSymbologyAttributesRequestEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_BarcodeScannerSetSymbologyAttributesRequestEventArgs[] = {
        { "request", reinterpret_cast<getter>(BarcodeScannerSetSymbologyAttributesRequestEventArgs_get_Request), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_BarcodeScannerSetSymbologyAttributesRequestEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_BarcodeScannerSetSymbologyAttributesRequestEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_BarcodeScannerSetSymbologyAttributesRequestEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_BarcodeScannerSetSymbologyAttributesRequestEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_BarcodeScannerSetSymbologyAttributesRequestEventArgs) },
        { },
    };

    static PyType_Spec type_spec_BarcodeScannerSetSymbologyAttributesRequestEventArgs =
    {
        "winrt._winrt_windows_devices_pointofservice_provider.BarcodeScannerSetSymbologyAttributesRequestEventArgs",
        sizeof(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerSetSymbologyAttributesRequestEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_BarcodeScannerSetSymbologyAttributesRequestEventArgs
    };

    // ----- BarcodeScannerStartSoftwareTriggerRequest class --------------------

    static PyObject* _new_BarcodeScannerStartSoftwareTriggerRequest(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerStartSoftwareTriggerRequest>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerStartSoftwareTriggerRequest>::type_name);
        return nullptr;
    }

    static void _dealloc_BarcodeScannerStartSoftwareTriggerRequest(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerStartSoftwareTriggerRequest* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* BarcodeScannerStartSoftwareTriggerRequest_ReportCompletedAsync(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerStartSoftwareTriggerRequest* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerStartSoftwareTriggerRequest", L"ReportCompletedAsync", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* BarcodeScannerStartSoftwareTriggerRequest_ReportFailedAsync(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerStartSoftwareTriggerRequest* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerStartSoftwareTriggerRequest", L"ReportFailedAsync", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                return py::convert(self->obj.ReportFailedAsync());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerStartSoftwareTriggerRequest", L"ReportFailedAsync", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

                return py::convert(self->obj.ReportFailedAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerStartSoftwareTriggerRequest", L"ReportFailedAsync", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

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

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

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

    static PyObject* _from_BarcodeScannerStartSoftwareTriggerRequest(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::PointOfService::Provider::BarcodeScannerStartSoftwareTriggerRequest>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_BarcodeScannerStartSoftwareTriggerRequest[] = {
        { "report_completed_async", reinterpret_cast<PyCFunction>(BarcodeScannerStartSoftwareTriggerRequest_ReportCompletedAsync), METH_VARARGS, nullptr },
        { "report_failed_async", reinterpret_cast<PyCFunction>(BarcodeScannerStartSoftwareTriggerRequest_ReportFailedAsync), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_BarcodeScannerStartSoftwareTriggerRequest, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_BarcodeScannerStartSoftwareTriggerRequest), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_BarcodeScannerStartSoftwareTriggerRequest[] = {
        { }
    };

    static PyType_Slot _type_slots_BarcodeScannerStartSoftwareTriggerRequest[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_BarcodeScannerStartSoftwareTriggerRequest) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_BarcodeScannerStartSoftwareTriggerRequest) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_BarcodeScannerStartSoftwareTriggerRequest) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_BarcodeScannerStartSoftwareTriggerRequest) },
        { },
    };

    static PyType_Spec type_spec_BarcodeScannerStartSoftwareTriggerRequest =
    {
        "winrt._winrt_windows_devices_pointofservice_provider.BarcodeScannerStartSoftwareTriggerRequest",
        sizeof(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerStartSoftwareTriggerRequest),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_BarcodeScannerStartSoftwareTriggerRequest
    };

    // ----- BarcodeScannerStartSoftwareTriggerRequestEventArgs class --------------------

    static PyObject* _new_BarcodeScannerStartSoftwareTriggerRequestEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerStartSoftwareTriggerRequestEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerStartSoftwareTriggerRequestEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_BarcodeScannerStartSoftwareTriggerRequestEventArgs(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerStartSoftwareTriggerRequestEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* BarcodeScannerStartSoftwareTriggerRequestEventArgs_GetDeferral(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerStartSoftwareTriggerRequestEventArgs* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerStartSoftwareTriggerRequestEventArgs", L"GetDeferral", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

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

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

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

    static PyObject* _from_BarcodeScannerStartSoftwareTriggerRequestEventArgs(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::PointOfService::Provider::BarcodeScannerStartSoftwareTriggerRequestEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_BarcodeScannerStartSoftwareTriggerRequestEventArgs[] = {
        { "get_deferral", reinterpret_cast<PyCFunction>(BarcodeScannerStartSoftwareTriggerRequestEventArgs_GetDeferral), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_BarcodeScannerStartSoftwareTriggerRequestEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_BarcodeScannerStartSoftwareTriggerRequestEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_BarcodeScannerStartSoftwareTriggerRequestEventArgs[] = {
        { "request", reinterpret_cast<getter>(BarcodeScannerStartSoftwareTriggerRequestEventArgs_get_Request), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_BarcodeScannerStartSoftwareTriggerRequestEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_BarcodeScannerStartSoftwareTriggerRequestEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_BarcodeScannerStartSoftwareTriggerRequestEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_BarcodeScannerStartSoftwareTriggerRequestEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_BarcodeScannerStartSoftwareTriggerRequestEventArgs) },
        { },
    };

    static PyType_Spec type_spec_BarcodeScannerStartSoftwareTriggerRequestEventArgs =
    {
        "winrt._winrt_windows_devices_pointofservice_provider.BarcodeScannerStartSoftwareTriggerRequestEventArgs",
        sizeof(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerStartSoftwareTriggerRequestEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_BarcodeScannerStartSoftwareTriggerRequestEventArgs
    };

    // ----- BarcodeScannerStopSoftwareTriggerRequest class --------------------

    static PyObject* _new_BarcodeScannerStopSoftwareTriggerRequest(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerStopSoftwareTriggerRequest>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerStopSoftwareTriggerRequest>::type_name);
        return nullptr;
    }

    static void _dealloc_BarcodeScannerStopSoftwareTriggerRequest(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerStopSoftwareTriggerRequest* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* BarcodeScannerStopSoftwareTriggerRequest_ReportCompletedAsync(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerStopSoftwareTriggerRequest* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerStopSoftwareTriggerRequest", L"ReportCompletedAsync", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

    static PyObject* BarcodeScannerStopSoftwareTriggerRequest_ReportFailedAsync(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerStopSoftwareTriggerRequest* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerStopSoftwareTriggerRequest", L"ReportFailedAsync", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

            try
            {
                return py::convert(self->obj.ReportFailedAsync());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 1)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerStopSoftwareTriggerRequest", L"ReportFailedAsync", 1))
            {
                py::set_arg_count_version_error(1);
                return nullptr;
            }

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

                return py::convert(self->obj.ReportFailedAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 2)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerStopSoftwareTriggerRequest", L"ReportFailedAsync", 2))
            {
                py::set_arg_count_version_error(2);
                return nullptr;
            }

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

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

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

    static PyObject* _from_BarcodeScannerStopSoftwareTriggerRequest(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::PointOfService::Provider::BarcodeScannerStopSoftwareTriggerRequest>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_BarcodeScannerStopSoftwareTriggerRequest[] = {
        { "report_completed_async", reinterpret_cast<PyCFunction>(BarcodeScannerStopSoftwareTriggerRequest_ReportCompletedAsync), METH_VARARGS, nullptr },
        { "report_failed_async", reinterpret_cast<PyCFunction>(BarcodeScannerStopSoftwareTriggerRequest_ReportFailedAsync), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_BarcodeScannerStopSoftwareTriggerRequest, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_BarcodeScannerStopSoftwareTriggerRequest), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_BarcodeScannerStopSoftwareTriggerRequest[] = {
        { }
    };

    static PyType_Slot _type_slots_BarcodeScannerStopSoftwareTriggerRequest[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_BarcodeScannerStopSoftwareTriggerRequest) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_BarcodeScannerStopSoftwareTriggerRequest) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_BarcodeScannerStopSoftwareTriggerRequest) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_BarcodeScannerStopSoftwareTriggerRequest) },
        { },
    };

    static PyType_Spec type_spec_BarcodeScannerStopSoftwareTriggerRequest =
    {
        "winrt._winrt_windows_devices_pointofservice_provider.BarcodeScannerStopSoftwareTriggerRequest",
        sizeof(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerStopSoftwareTriggerRequest),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_BarcodeScannerStopSoftwareTriggerRequest
    };

    // ----- BarcodeScannerStopSoftwareTriggerRequestEventArgs class --------------------

    static PyObject* _new_BarcodeScannerStopSoftwareTriggerRequestEventArgs(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerStopSoftwareTriggerRequestEventArgs>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerStopSoftwareTriggerRequestEventArgs>::type_name);
        return nullptr;
    }

    static void _dealloc_BarcodeScannerStopSoftwareTriggerRequestEventArgs(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerStopSoftwareTriggerRequestEventArgs* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* BarcodeScannerStopSoftwareTriggerRequestEventArgs_GetDeferral(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerStopSoftwareTriggerRequestEventArgs* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerStopSoftwareTriggerRequestEventArgs", L"GetDeferral", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

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

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

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

    static PyObject* _from_BarcodeScannerStopSoftwareTriggerRequestEventArgs(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::PointOfService::Provider::BarcodeScannerStopSoftwareTriggerRequestEventArgs>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_BarcodeScannerStopSoftwareTriggerRequestEventArgs[] = {
        { "get_deferral", reinterpret_cast<PyCFunction>(BarcodeScannerStopSoftwareTriggerRequestEventArgs_GetDeferral), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_BarcodeScannerStopSoftwareTriggerRequestEventArgs, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_BarcodeScannerStopSoftwareTriggerRequestEventArgs), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_BarcodeScannerStopSoftwareTriggerRequestEventArgs[] = {
        { "request", reinterpret_cast<getter>(BarcodeScannerStopSoftwareTriggerRequestEventArgs_get_Request), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_BarcodeScannerStopSoftwareTriggerRequestEventArgs[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_BarcodeScannerStopSoftwareTriggerRequestEventArgs) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_BarcodeScannerStopSoftwareTriggerRequestEventArgs) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_BarcodeScannerStopSoftwareTriggerRequestEventArgs) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_BarcodeScannerStopSoftwareTriggerRequestEventArgs) },
        { },
    };

    static PyType_Spec type_spec_BarcodeScannerStopSoftwareTriggerRequestEventArgs =
    {
        "winrt._winrt_windows_devices_pointofservice_provider.BarcodeScannerStopSoftwareTriggerRequestEventArgs",
        sizeof(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerStopSoftwareTriggerRequestEventArgs),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_BarcodeScannerStopSoftwareTriggerRequestEventArgs
    };

    // ----- BarcodeScannerVideoFrame class --------------------

    static PyObject* _new_BarcodeScannerVideoFrame(PyTypeObject* /*unused*/, PyObject* /*unused*/, PyObject* /*unused*/) noexcept
    {
        static_assert(py::py_type<winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerVideoFrame>::type_name);
        py::set_invalid_activation_error(py::py_type<winrt::Windows::Devices::PointOfService::Provider::BarcodeScannerVideoFrame>::type_name);
        return nullptr;
    }

    static void _dealloc_BarcodeScannerVideoFrame(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerVideoFrame* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* BarcodeScannerVideoFrame_Close(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerVideoFrame* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerVideoFrame", 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* BarcodeScannerVideoFrame_get_Format(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerVideoFrame* self, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.PointOfService.Provider.BarcodeScannerVideoFrame", L"Format"))
        {
            PyErr_SetString(PyExc_AttributeError, "property is not available in this version of Windows");
            return nullptr;
        }

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

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

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

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

    static PyObject* _from_BarcodeScannerVideoFrame(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::PointOfService::Provider::BarcodeScannerVideoFrame>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _enter_BarcodeScannerVideoFrame(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerVideoFrame* self, PyObject* /*unused*/) noexcept
    {
        return Py_NewRef(self);
    }

    static PyObject* _exit_BarcodeScannerVideoFrame(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerVideoFrame* self, PyObject* /*unused*/) noexcept
    {
        try
        {
            self->obj.Close();
            Py_RETURN_FALSE;
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_BarcodeScannerVideoFrame[] = {
        { "close", reinterpret_cast<PyCFunction>(BarcodeScannerVideoFrame_Close), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_BarcodeScannerVideoFrame, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_BarcodeScannerVideoFrame), METH_O | METH_STATIC, nullptr },
        { "__enter__", reinterpret_cast<PyCFunction>(_enter_BarcodeScannerVideoFrame), METH_NOARGS, nullptr },
        { "__exit__",  reinterpret_cast<PyCFunction>(_exit_BarcodeScannerVideoFrame), METH_VARARGS, nullptr },
        { }
    };

    static PyGetSetDef _getset_BarcodeScannerVideoFrame[] = {
        { "format", reinterpret_cast<getter>(BarcodeScannerVideoFrame_get_Format), nullptr, nullptr, nullptr },
        { "height", reinterpret_cast<getter>(BarcodeScannerVideoFrame_get_Height), nullptr, nullptr, nullptr },
        { "pixel_data", reinterpret_cast<getter>(BarcodeScannerVideoFrame_get_PixelData), nullptr, nullptr, nullptr },
        { "width", reinterpret_cast<getter>(BarcodeScannerVideoFrame_get_Width), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_BarcodeScannerVideoFrame[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_BarcodeScannerVideoFrame) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_BarcodeScannerVideoFrame) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_BarcodeScannerVideoFrame) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_BarcodeScannerVideoFrame) },
        { },
    };

    static PyType_Spec type_spec_BarcodeScannerVideoFrame =
    {
        "winrt._winrt_windows_devices_pointofservice_provider.BarcodeScannerVideoFrame",
        sizeof(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeScannerVideoFrame),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_BarcodeScannerVideoFrame
    };

    // ----- BarcodeSymbologyAttributesBuilder class --------------------

    static PyObject* _new_BarcodeSymbologyAttributesBuilder(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::PointOfService::Provider::BarcodeSymbologyAttributesBuilder 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_BarcodeSymbologyAttributesBuilder(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeSymbologyAttributesBuilder* self) noexcept
    {
        auto tp = Py_TYPE(self);
        std::destroy_at(&self->obj);
        tp->tp_free(self);
        Py_DECREF(tp);
    }

    static PyObject* BarcodeSymbologyAttributesBuilder_CreateAttributes(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeSymbologyAttributesBuilder* self, PyObject* args) noexcept
    {
        auto arg_count = PyTuple_Size(args);

        if (arg_count == 0)
        {
            if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsMethodPresent(L"Windows.Devices.PointOfService.Provider.BarcodeSymbologyAttributesBuilder", L"CreateAttributes", 0))
            {
                py::set_arg_count_version_error(0);
                return nullptr;
            }

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

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

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

    static int BarcodeSymbologyAttributesBuilder_put_IsDecodeLengthSupported(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeSymbologyAttributesBuilder* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.PointOfService.Provider.BarcodeSymbologyAttributesBuilder", L"IsDecodeLengthSupported"))
        {
            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<bool>(arg);

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

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

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

    static int BarcodeSymbologyAttributesBuilder_put_IsCheckDigitValidationSupported(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeSymbologyAttributesBuilder* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.PointOfService.Provider.BarcodeSymbologyAttributesBuilder", L"IsCheckDigitValidationSupported"))
        {
            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<bool>(arg);

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

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

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

    static int BarcodeSymbologyAttributesBuilder_put_IsCheckDigitTransmissionSupported(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeSymbologyAttributesBuilder* self, PyObject* arg, void* /*unused*/) noexcept
    {
        if (!winrt::Windows::Foundation::Metadata::ApiInformation::IsPropertyPresent(L"Windows.Devices.PointOfService.Provider.BarcodeSymbologyAttributesBuilder", L"IsCheckDigitTransmissionSupported"))
        {
            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<bool>(arg);

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

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

    static PyObject* _from_BarcodeSymbologyAttributesBuilder(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::PointOfService::Provider::BarcodeSymbologyAttributesBuilder>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_BarcodeSymbologyAttributesBuilder[] = {
        { "create_attributes", reinterpret_cast<PyCFunction>(BarcodeSymbologyAttributesBuilder_CreateAttributes), METH_VARARGS, nullptr },
        { "_assign_array_", _assign_array_BarcodeSymbologyAttributesBuilder, METH_O | METH_STATIC, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_BarcodeSymbologyAttributesBuilder), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_BarcodeSymbologyAttributesBuilder[] = {
        { "is_decode_length_supported", reinterpret_cast<getter>(BarcodeSymbologyAttributesBuilder_get_IsDecodeLengthSupported), reinterpret_cast<setter>(BarcodeSymbologyAttributesBuilder_put_IsDecodeLengthSupported), nullptr, nullptr },
        { "is_check_digit_validation_supported", reinterpret_cast<getter>(BarcodeSymbologyAttributesBuilder_get_IsCheckDigitValidationSupported), reinterpret_cast<setter>(BarcodeSymbologyAttributesBuilder_put_IsCheckDigitValidationSupported), nullptr, nullptr },
        { "is_check_digit_transmission_supported", reinterpret_cast<getter>(BarcodeSymbologyAttributesBuilder_get_IsCheckDigitTransmissionSupported), reinterpret_cast<setter>(BarcodeSymbologyAttributesBuilder_put_IsCheckDigitTransmissionSupported), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_BarcodeSymbologyAttributesBuilder[] = 
    {
        { Py_tp_new, reinterpret_cast<void*>(_new_BarcodeSymbologyAttributesBuilder) },
        { Py_tp_dealloc, reinterpret_cast<void*>(_dealloc_BarcodeSymbologyAttributesBuilder) },
        { Py_tp_methods, reinterpret_cast<void*>(_methods_BarcodeSymbologyAttributesBuilder) },
        { Py_tp_getset, reinterpret_cast<void*>(_getset_BarcodeSymbologyAttributesBuilder) },
        { },
    };

    static PyType_Spec type_spec_BarcodeSymbologyAttributesBuilder =
    {
        "winrt._winrt_windows_devices_pointofservice_provider.BarcodeSymbologyAttributesBuilder",
        sizeof(py::wrapper::Windows::Devices::PointOfService::Provider::BarcodeSymbologyAttributesBuilder),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_BarcodeSymbologyAttributesBuilder
    };

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


    static PyModuleDef module_def
        = {PyModuleDef_HEAD_INIT,
           "_winrt_windows_devices_pointofservice_provider",
           module_doc,
           0,
           nullptr,
           nullptr,
           nullptr,
           nullptr,
           nullptr};

} // py::cpp::Windows::Devices::PointOfService::Provider

PyMODINIT_FUNC PyInit__winrt_windows_devices_pointofservice_provider(void) noexcept
{
    using namespace py::cpp::Windows::Devices::PointOfService::Provider;

    if (py::import_winrt_runtime() == -1)
    {
        return nullptr;
    }

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

    if (!module)
    {
        return nullptr;
    }

    auto object_type = py::get_object_type();
    if (!object_type)
    {
        return nullptr;
    }

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

    if (!object_bases)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_BarcodeScannerDisableScannerRequest, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_BarcodeScannerDisableScannerRequestEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_BarcodeScannerEnableScannerRequest, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_BarcodeScannerEnableScannerRequestEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_BarcodeScannerFrameReader, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_BarcodeScannerFrameReaderFrameArrivedEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_BarcodeScannerGetSymbologyAttributesRequest, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_BarcodeScannerGetSymbologyAttributesRequestEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_BarcodeScannerHideVideoPreviewRequest, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_BarcodeScannerHideVideoPreviewRequestEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_BarcodeScannerProviderConnection, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_BarcodeScannerProviderTriggerDetails, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_BarcodeScannerSetActiveSymbologiesRequest, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_BarcodeScannerSetActiveSymbologiesRequestEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_BarcodeScannerSetSymbologyAttributesRequest, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_BarcodeScannerSetSymbologyAttributesRequestEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_BarcodeScannerStartSoftwareTriggerRequest, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_BarcodeScannerStartSoftwareTriggerRequestEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_BarcodeScannerStopSoftwareTriggerRequest, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_BarcodeScannerStopSoftwareTriggerRequestEventArgs, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_BarcodeScannerVideoFrame, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }

    if (py::register_python_type(module.get(), &type_spec_BarcodeSymbologyAttributesBuilder, object_bases.get(), nullptr) == -1)
    {
        return nullptr;
    }


    return module.detach();
}
