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

#include "pybase.h"
#include "py.Windows.ApplicationModel.Store.h"

PyTypeObject* py::winrt_type<winrt::Windows::ApplicationModel::Store::CurrentApp>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::ApplicationModel::Store::CurrentAppSimulator>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::ApplicationModel::Store::LicenseInformation>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::ApplicationModel::Store::ListingInformation>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::ApplicationModel::Store::ProductLicense>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::ApplicationModel::Store::ProductListing>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::ApplicationModel::Store::ProductPurchaseDisplayProperties>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::ApplicationModel::Store::PurchaseResults>::python_type;
PyTypeObject* py::winrt_type<winrt::Windows::ApplicationModel::Store::UnfulfilledConsumable>::python_type;

namespace py::cpp::Windows::ApplicationModel::Store
{
    // ----- CurrentApp class --------------------
    constexpr const char* const _type_name_CurrentApp = "CurrentApp";

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

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

        if (arg_count == 0)
        {
            try
            {
                return py::convert(winrt::Windows::ApplicationModel::Store::CurrentApp::GetAppPurchaseCampaignIdAsync());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 0)
        {
            try
            {
                return py::convert(winrt::Windows::ApplicationModel::Store::CurrentApp::GetAppReceiptAsync());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

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

                return py::convert(winrt::Windows::ApplicationModel::Store::CurrentApp::GetCustomerCollectionsIdAsync(param0, param1));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

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

                return py::convert(winrt::Windows::ApplicationModel::Store::CurrentApp::GetCustomerPurchaseIdAsync(param0, param1));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

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

                return py::convert(winrt::Windows::ApplicationModel::Store::CurrentApp::GetProductReceiptAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 0)
        {
            try
            {
                return py::convert(winrt::Windows::ApplicationModel::Store::CurrentApp::GetUnfulfilledConsumablesAsync());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 0)
        {
            try
            {
                return py::convert(winrt::Windows::ApplicationModel::Store::CurrentApp::LoadListingInformationAsync());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

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

                return py::convert(winrt::Windows::ApplicationModel::Store::CurrentApp::LoadListingInformationByKeywordsAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

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

                return py::convert(winrt::Windows::ApplicationModel::Store::CurrentApp::LoadListingInformationByProductIdsAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

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

                return py::convert(winrt::Windows::ApplicationModel::Store::CurrentApp::ReportConsumableFulfillmentAsync(param0, param1));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

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

                winrt::Windows::ApplicationModel::Store::CurrentApp::ReportProductFulfillment(param0);
                Py_RETURN_NONE;
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

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

                return py::convert(winrt::Windows::ApplicationModel::Store::CurrentApp::RequestAppPurchaseAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

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

                return py::convert(winrt::Windows::ApplicationModel::Store::CurrentApp::RequestProductPurchaseAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 2)
        {
            try
            {
                auto param0 = py::convert_to<winrt::hstring>(args, 0);
                auto param1 = py::convert_to<bool>(args, 1);

                return py::convert(winrt::Windows::ApplicationModel::Store::CurrentApp::RequestProductPurchaseAsync(param0, param1));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 3)
        {
            try
            {
                auto param0 = py::convert_to<winrt::hstring>(args, 0);
                auto param1 = py::convert_to<winrt::hstring>(args, 1);
                auto param2 = py::convert_to<winrt::Windows::ApplicationModel::Store::ProductPurchaseDisplayProperties>(args, 2);

                return py::convert(winrt::Windows::ApplicationModel::Store::CurrentApp::RequestProductPurchaseAsync(param0, param1, param2));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* CurrentApp_get_AppId(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(winrt::Windows::ApplicationModel::Store::CurrentApp::AppId());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CurrentApp_get_LicenseInformation(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(winrt::Windows::ApplicationModel::Store::CurrentApp::LicenseInformation());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CurrentApp_get_LinkUri(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(winrt::Windows::ApplicationModel::Store::CurrentApp::LinkUri());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_CurrentApp[] = {
        { "get_app_purchase_campaign_id_async", reinterpret_cast<PyCFunction>(CurrentApp_GetAppPurchaseCampaignIdAsync), METH_VARARGS | METH_STATIC, nullptr },
        { "get_app_receipt_async", reinterpret_cast<PyCFunction>(CurrentApp_GetAppReceiptAsync), METH_VARARGS | METH_STATIC, nullptr },
        { "get_customer_collections_id_async", reinterpret_cast<PyCFunction>(CurrentApp_GetCustomerCollectionsIdAsync), METH_VARARGS | METH_STATIC, nullptr },
        { "get_customer_purchase_id_async", reinterpret_cast<PyCFunction>(CurrentApp_GetCustomerPurchaseIdAsync), METH_VARARGS | METH_STATIC, nullptr },
        { "get_product_receipt_async", reinterpret_cast<PyCFunction>(CurrentApp_GetProductReceiptAsync), METH_VARARGS | METH_STATIC, nullptr },
        { "get_unfulfilled_consumables_async", reinterpret_cast<PyCFunction>(CurrentApp_GetUnfulfilledConsumablesAsync), METH_VARARGS | METH_STATIC, nullptr },
        { "load_listing_information_async", reinterpret_cast<PyCFunction>(CurrentApp_LoadListingInformationAsync), METH_VARARGS | METH_STATIC, nullptr },
        { "load_listing_information_by_keywords_async", reinterpret_cast<PyCFunction>(CurrentApp_LoadListingInformationByKeywordsAsync), METH_VARARGS | METH_STATIC, nullptr },
        { "load_listing_information_by_product_ids_async", reinterpret_cast<PyCFunction>(CurrentApp_LoadListingInformationByProductIdsAsync), METH_VARARGS | METH_STATIC, nullptr },
        { "report_consumable_fulfillment_async", reinterpret_cast<PyCFunction>(CurrentApp_ReportConsumableFulfillmentAsync), METH_VARARGS | METH_STATIC, nullptr },
        { "report_product_fulfillment", reinterpret_cast<PyCFunction>(CurrentApp_ReportProductFulfillment), METH_VARARGS | METH_STATIC, nullptr },
        { "request_app_purchase_async", reinterpret_cast<PyCFunction>(CurrentApp_RequestAppPurchaseAsync), METH_VARARGS | METH_STATIC, nullptr },
        { "request_product_purchase_async", reinterpret_cast<PyCFunction>(CurrentApp_RequestProductPurchaseAsync), METH_VARARGS | METH_STATIC, nullptr },
        { "get_app_id", reinterpret_cast<PyCFunction>(CurrentApp_get_AppId), METH_NOARGS | METH_STATIC, nullptr },
        { "get_license_information", reinterpret_cast<PyCFunction>(CurrentApp_get_LicenseInformation), METH_NOARGS | METH_STATIC, nullptr },
        { "get_link_uri", reinterpret_cast<PyCFunction>(CurrentApp_get_LinkUri), METH_NOARGS | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_CurrentApp[] = {
        { }
    };

    static PyType_Slot _type_slots_CurrentApp[] = 
    {
        { Py_tp_new, _new_CurrentApp },
        { Py_tp_methods, _methods_CurrentApp },
        { Py_tp_getset, _getset_CurrentApp },
        { },
    };

    static PyType_Spec _type_spec_CurrentApp =
    {
        "_winsdk_Windows_ApplicationModel_Store.CurrentApp",
        0,
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_CurrentApp
    };

    // ----- CurrentAppSimulator class --------------------
    constexpr const char* const _type_name_CurrentAppSimulator = "CurrentAppSimulator";

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

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

        if (arg_count == 0)
        {
            try
            {
                return py::convert(winrt::Windows::ApplicationModel::Store::CurrentAppSimulator::GetAppPurchaseCampaignIdAsync());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 0)
        {
            try
            {
                return py::convert(winrt::Windows::ApplicationModel::Store::CurrentAppSimulator::GetAppReceiptAsync());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

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

                return py::convert(winrt::Windows::ApplicationModel::Store::CurrentAppSimulator::GetProductReceiptAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 0)
        {
            try
            {
                return py::convert(winrt::Windows::ApplicationModel::Store::CurrentAppSimulator::GetUnfulfilledConsumablesAsync());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

        if (arg_count == 0)
        {
            try
            {
                return py::convert(winrt::Windows::ApplicationModel::Store::CurrentAppSimulator::LoadListingInformationAsync());
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

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

                return py::convert(winrt::Windows::ApplicationModel::Store::CurrentAppSimulator::LoadListingInformationByKeywordsAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

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

                return py::convert(winrt::Windows::ApplicationModel::Store::CurrentAppSimulator::LoadListingInformationByProductIdsAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

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

                return py::convert(winrt::Windows::ApplicationModel::Store::CurrentAppSimulator::ReloadSimulatorAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

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

                return py::convert(winrt::Windows::ApplicationModel::Store::CurrentAppSimulator::ReportConsumableFulfillmentAsync(param0, param1));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

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

                return py::convert(winrt::Windows::ApplicationModel::Store::CurrentAppSimulator::RequestAppPurchaseAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

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

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

                return py::convert(winrt::Windows::ApplicationModel::Store::CurrentAppSimulator::RequestProductPurchaseAsync(param0));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 2)
        {
            try
            {
                auto param0 = py::convert_to<winrt::hstring>(args, 0);
                auto param1 = py::convert_to<bool>(args, 1);

                return py::convert(winrt::Windows::ApplicationModel::Store::CurrentAppSimulator::RequestProductPurchaseAsync(param0, param1));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 3)
        {
            try
            {
                auto param0 = py::convert_to<winrt::hstring>(args, 0);
                auto param1 = py::convert_to<winrt::hstring>(args, 1);
                auto param2 = py::convert_to<winrt::Windows::ApplicationModel::Store::ProductPurchaseDisplayProperties>(args, 2);

                return py::convert(winrt::Windows::ApplicationModel::Store::CurrentAppSimulator::RequestProductPurchaseAsync(param0, param1, param2));
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else
        {
            py::set_invalid_arg_count_error(arg_count);
            return nullptr;
        }
    }

    static PyObject* CurrentAppSimulator_get_AppId(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(winrt::Windows::ApplicationModel::Store::CurrentAppSimulator::AppId());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CurrentAppSimulator_get_LicenseInformation(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(winrt::Windows::ApplicationModel::Store::CurrentAppSimulator::LicenseInformation());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* CurrentAppSimulator_get_LinkUri(PyObject* /*unused*/, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(winrt::Windows::ApplicationModel::Store::CurrentAppSimulator::LinkUri());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_CurrentAppSimulator[] = {
        { "get_app_purchase_campaign_id_async", reinterpret_cast<PyCFunction>(CurrentAppSimulator_GetAppPurchaseCampaignIdAsync), METH_VARARGS | METH_STATIC, nullptr },
        { "get_app_receipt_async", reinterpret_cast<PyCFunction>(CurrentAppSimulator_GetAppReceiptAsync), METH_VARARGS | METH_STATIC, nullptr },
        { "get_product_receipt_async", reinterpret_cast<PyCFunction>(CurrentAppSimulator_GetProductReceiptAsync), METH_VARARGS | METH_STATIC, nullptr },
        { "get_unfulfilled_consumables_async", reinterpret_cast<PyCFunction>(CurrentAppSimulator_GetUnfulfilledConsumablesAsync), METH_VARARGS | METH_STATIC, nullptr },
        { "load_listing_information_async", reinterpret_cast<PyCFunction>(CurrentAppSimulator_LoadListingInformationAsync), METH_VARARGS | METH_STATIC, nullptr },
        { "load_listing_information_by_keywords_async", reinterpret_cast<PyCFunction>(CurrentAppSimulator_LoadListingInformationByKeywordsAsync), METH_VARARGS | METH_STATIC, nullptr },
        { "load_listing_information_by_product_ids_async", reinterpret_cast<PyCFunction>(CurrentAppSimulator_LoadListingInformationByProductIdsAsync), METH_VARARGS | METH_STATIC, nullptr },
        { "reload_simulator_async", reinterpret_cast<PyCFunction>(CurrentAppSimulator_ReloadSimulatorAsync), METH_VARARGS | METH_STATIC, nullptr },
        { "report_consumable_fulfillment_async", reinterpret_cast<PyCFunction>(CurrentAppSimulator_ReportConsumableFulfillmentAsync), METH_VARARGS | METH_STATIC, nullptr },
        { "request_app_purchase_async", reinterpret_cast<PyCFunction>(CurrentAppSimulator_RequestAppPurchaseAsync), METH_VARARGS | METH_STATIC, nullptr },
        { "request_product_purchase_async", reinterpret_cast<PyCFunction>(CurrentAppSimulator_RequestProductPurchaseAsync), METH_VARARGS | METH_STATIC, nullptr },
        { "get_app_id", reinterpret_cast<PyCFunction>(CurrentAppSimulator_get_AppId), METH_NOARGS | METH_STATIC, nullptr },
        { "get_license_information", reinterpret_cast<PyCFunction>(CurrentAppSimulator_get_LicenseInformation), METH_NOARGS | METH_STATIC, nullptr },
        { "get_link_uri", reinterpret_cast<PyCFunction>(CurrentAppSimulator_get_LinkUri), METH_NOARGS | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_CurrentAppSimulator[] = {
        { }
    };

    static PyType_Slot _type_slots_CurrentAppSimulator[] = 
    {
        { Py_tp_new, _new_CurrentAppSimulator },
        { Py_tp_methods, _methods_CurrentAppSimulator },
        { Py_tp_getset, _getset_CurrentAppSimulator },
        { },
    };

    static PyType_Spec _type_spec_CurrentAppSimulator =
    {
        "_winsdk_Windows_ApplicationModel_Store.CurrentAppSimulator",
        0,
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_CurrentAppSimulator
    };

    // ----- LicenseInformation class --------------------
    constexpr const char* const _type_name_LicenseInformation = "LicenseInformation";

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

    static void _dealloc_LicenseInformation(py::wrapper::Windows::ApplicationModel::Store::LicenseInformation* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* LicenseInformation_get_ExpirationDate(py::wrapper::Windows::ApplicationModel::Store::LicenseInformation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ExpirationDate());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* LicenseInformation_get_IsActive(py::wrapper::Windows::ApplicationModel::Store::LicenseInformation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.IsActive());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* LicenseInformation_get_IsTrial(py::wrapper::Windows::ApplicationModel::Store::LicenseInformation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.IsTrial());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* LicenseInformation_get_ProductLicenses(py::wrapper::Windows::ApplicationModel::Store::LicenseInformation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ProductLicenses());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* LicenseInformation_add_LicenseChanged(py::wrapper::Windows::ApplicationModel::Store::LicenseInformation* self, PyObject* arg) noexcept
    {
        try
        {
            auto param0 = py::convert_to<winrt::Windows::ApplicationModel::Store::LicenseChangedEventHandler>(arg);

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

    static PyObject* LicenseInformation_remove_LicenseChanged(py::wrapper::Windows::ApplicationModel::Store::LicenseInformation* self, PyObject* arg) noexcept
    {
        try
        {
            auto param0 = py::convert_to<winrt::event_token>(arg);

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

    static PyObject* _from_LicenseInformation(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::ApplicationModel::Store::LicenseInformation>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyMethodDef _methods_LicenseInformation[] = {
        { "add_license_changed", reinterpret_cast<PyCFunction>(LicenseInformation_add_LicenseChanged), METH_O, nullptr },
        { "remove_license_changed", reinterpret_cast<PyCFunction>(LicenseInformation_remove_LicenseChanged), METH_O, nullptr },
        { "_from", reinterpret_cast<PyCFunction>(_from_LicenseInformation), METH_O | METH_STATIC, nullptr },
        { }
    };

    static PyGetSetDef _getset_LicenseInformation[] = {
        { "expiration_date", reinterpret_cast<getter>(LicenseInformation_get_ExpirationDate), nullptr, nullptr, nullptr },
        { "is_active", reinterpret_cast<getter>(LicenseInformation_get_IsActive), nullptr, nullptr, nullptr },
        { "is_trial", reinterpret_cast<getter>(LicenseInformation_get_IsTrial), nullptr, nullptr, nullptr },
        { "product_licenses", reinterpret_cast<getter>(LicenseInformation_get_ProductLicenses), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_LicenseInformation[] = 
    {
        { Py_tp_new, _new_LicenseInformation },
        { Py_tp_dealloc, _dealloc_LicenseInformation },
        { Py_tp_methods, _methods_LicenseInformation },
        { Py_tp_getset, _getset_LicenseInformation },
        { },
    };

    static PyType_Spec _type_spec_LicenseInformation =
    {
        "_winsdk_Windows_ApplicationModel_Store.LicenseInformation",
        sizeof(py::wrapper::Windows::ApplicationModel::Store::LicenseInformation),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_LicenseInformation
    };

    // ----- ListingInformation class --------------------
    constexpr const char* const _type_name_ListingInformation = "ListingInformation";

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

    static void _dealloc_ListingInformation(py::wrapper::Windows::ApplicationModel::Store::ListingInformation* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* ListingInformation_get_AgeRating(py::wrapper::Windows::ApplicationModel::Store::ListingInformation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.AgeRating());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ListingInformation_get_CurrentMarket(py::wrapper::Windows::ApplicationModel::Store::ListingInformation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.CurrentMarket());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ListingInformation_get_Description(py::wrapper::Windows::ApplicationModel::Store::ListingInformation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Description());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ListingInformation_get_FormattedPrice(py::wrapper::Windows::ApplicationModel::Store::ListingInformation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.FormattedPrice());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ListingInformation_get_Name(py::wrapper::Windows::ApplicationModel::Store::ListingInformation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Name());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ListingInformation_get_ProductListings(py::wrapper::Windows::ApplicationModel::Store::ListingInformation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ProductListings());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ListingInformation_get_CurrencyCode(py::wrapper::Windows::ApplicationModel::Store::ListingInformation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.CurrencyCode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ListingInformation_get_FormattedBasePrice(py::wrapper::Windows::ApplicationModel::Store::ListingInformation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.FormattedBasePrice());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ListingInformation_get_IsOnSale(py::wrapper::Windows::ApplicationModel::Store::ListingInformation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.IsOnSale());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ListingInformation_get_SaleEndDate(py::wrapper::Windows::ApplicationModel::Store::ListingInformation* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.SaleEndDate());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_ListingInformation(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::ApplicationModel::Store::ListingInformation>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

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

    static PyGetSetDef _getset_ListingInformation[] = {
        { "age_rating", reinterpret_cast<getter>(ListingInformation_get_AgeRating), nullptr, nullptr, nullptr },
        { "current_market", reinterpret_cast<getter>(ListingInformation_get_CurrentMarket), nullptr, nullptr, nullptr },
        { "description", reinterpret_cast<getter>(ListingInformation_get_Description), nullptr, nullptr, nullptr },
        { "formatted_price", reinterpret_cast<getter>(ListingInformation_get_FormattedPrice), nullptr, nullptr, nullptr },
        { "name", reinterpret_cast<getter>(ListingInformation_get_Name), nullptr, nullptr, nullptr },
        { "product_listings", reinterpret_cast<getter>(ListingInformation_get_ProductListings), nullptr, nullptr, nullptr },
        { "currency_code", reinterpret_cast<getter>(ListingInformation_get_CurrencyCode), nullptr, nullptr, nullptr },
        { "formatted_base_price", reinterpret_cast<getter>(ListingInformation_get_FormattedBasePrice), nullptr, nullptr, nullptr },
        { "is_on_sale", reinterpret_cast<getter>(ListingInformation_get_IsOnSale), nullptr, nullptr, nullptr },
        { "sale_end_date", reinterpret_cast<getter>(ListingInformation_get_SaleEndDate), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ListingInformation[] = 
    {
        { Py_tp_new, _new_ListingInformation },
        { Py_tp_dealloc, _dealloc_ListingInformation },
        { Py_tp_methods, _methods_ListingInformation },
        { Py_tp_getset, _getset_ListingInformation },
        { },
    };

    static PyType_Spec _type_spec_ListingInformation =
    {
        "_winsdk_Windows_ApplicationModel_Store.ListingInformation",
        sizeof(py::wrapper::Windows::ApplicationModel::Store::ListingInformation),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ListingInformation
    };

    // ----- ProductLicense class --------------------
    constexpr const char* const _type_name_ProductLicense = "ProductLicense";

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

    static void _dealloc_ProductLicense(py::wrapper::Windows::ApplicationModel::Store::ProductLicense* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* ProductLicense_get_ExpirationDate(py::wrapper::Windows::ApplicationModel::Store::ProductLicense* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ExpirationDate());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ProductLicense_get_IsActive(py::wrapper::Windows::ApplicationModel::Store::ProductLicense* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.IsActive());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ProductLicense_get_ProductId(py::wrapper::Windows::ApplicationModel::Store::ProductLicense* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ProductId());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ProductLicense_get_IsConsumable(py::wrapper::Windows::ApplicationModel::Store::ProductLicense* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.IsConsumable());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_ProductLicense(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::ApplicationModel::Store::ProductLicense>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

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

    static PyGetSetDef _getset_ProductLicense[] = {
        { "expiration_date", reinterpret_cast<getter>(ProductLicense_get_ExpirationDate), nullptr, nullptr, nullptr },
        { "is_active", reinterpret_cast<getter>(ProductLicense_get_IsActive), nullptr, nullptr, nullptr },
        { "product_id", reinterpret_cast<getter>(ProductLicense_get_ProductId), nullptr, nullptr, nullptr },
        { "is_consumable", reinterpret_cast<getter>(ProductLicense_get_IsConsumable), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ProductLicense[] = 
    {
        { Py_tp_new, _new_ProductLicense },
        { Py_tp_dealloc, _dealloc_ProductLicense },
        { Py_tp_methods, _methods_ProductLicense },
        { Py_tp_getset, _getset_ProductLicense },
        { },
    };

    static PyType_Spec _type_spec_ProductLicense =
    {
        "_winsdk_Windows_ApplicationModel_Store.ProductLicense",
        sizeof(py::wrapper::Windows::ApplicationModel::Store::ProductLicense),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ProductLicense
    };

    // ----- ProductListing class --------------------
    constexpr const char* const _type_name_ProductListing = "ProductListing";

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

    static void _dealloc_ProductListing(py::wrapper::Windows::ApplicationModel::Store::ProductListing* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* ProductListing_get_FormattedPrice(py::wrapper::Windows::ApplicationModel::Store::ProductListing* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.FormattedPrice());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ProductListing_get_Name(py::wrapper::Windows::ApplicationModel::Store::ProductListing* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Name());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ProductListing_get_ProductId(py::wrapper::Windows::ApplicationModel::Store::ProductListing* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ProductId());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ProductListing_get_FormattedBasePrice(py::wrapper::Windows::ApplicationModel::Store::ProductListing* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.FormattedBasePrice());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ProductListing_get_IsOnSale(py::wrapper::Windows::ApplicationModel::Store::ProductListing* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.IsOnSale());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ProductListing_get_SaleEndDate(py::wrapper::Windows::ApplicationModel::Store::ProductListing* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.SaleEndDate());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ProductListing_get_CurrencyCode(py::wrapper::Windows::ApplicationModel::Store::ProductListing* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.CurrencyCode());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ProductListing_get_Description(py::wrapper::Windows::ApplicationModel::Store::ProductListing* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Description());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ProductListing_get_ImageUri(py::wrapper::Windows::ApplicationModel::Store::ProductListing* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ImageUri());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ProductListing_get_Keywords(py::wrapper::Windows::ApplicationModel::Store::ProductListing* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Keywords());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ProductListing_get_Tag(py::wrapper::Windows::ApplicationModel::Store::ProductListing* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Tag());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* ProductListing_get_ProductType(py::wrapper::Windows::ApplicationModel::Store::ProductListing* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ProductType());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_ProductListing(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::ApplicationModel::Store::ProductListing>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

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

    static PyGetSetDef _getset_ProductListing[] = {
        { "formatted_price", reinterpret_cast<getter>(ProductListing_get_FormattedPrice), nullptr, nullptr, nullptr },
        { "name", reinterpret_cast<getter>(ProductListing_get_Name), nullptr, nullptr, nullptr },
        { "product_id", reinterpret_cast<getter>(ProductListing_get_ProductId), nullptr, nullptr, nullptr },
        { "formatted_base_price", reinterpret_cast<getter>(ProductListing_get_FormattedBasePrice), nullptr, nullptr, nullptr },
        { "is_on_sale", reinterpret_cast<getter>(ProductListing_get_IsOnSale), nullptr, nullptr, nullptr },
        { "sale_end_date", reinterpret_cast<getter>(ProductListing_get_SaleEndDate), nullptr, nullptr, nullptr },
        { "currency_code", reinterpret_cast<getter>(ProductListing_get_CurrencyCode), nullptr, nullptr, nullptr },
        { "description", reinterpret_cast<getter>(ProductListing_get_Description), nullptr, nullptr, nullptr },
        { "image_uri", reinterpret_cast<getter>(ProductListing_get_ImageUri), nullptr, nullptr, nullptr },
        { "keywords", reinterpret_cast<getter>(ProductListing_get_Keywords), nullptr, nullptr, nullptr },
        { "tag", reinterpret_cast<getter>(ProductListing_get_Tag), nullptr, nullptr, nullptr },
        { "product_type", reinterpret_cast<getter>(ProductListing_get_ProductType), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ProductListing[] = 
    {
        { Py_tp_new, _new_ProductListing },
        { Py_tp_dealloc, _dealloc_ProductListing },
        { Py_tp_methods, _methods_ProductListing },
        { Py_tp_getset, _getset_ProductListing },
        { },
    };

    static PyType_Spec _type_spec_ProductListing =
    {
        "_winsdk_Windows_ApplicationModel_Store.ProductListing",
        sizeof(py::wrapper::Windows::ApplicationModel::Store::ProductListing),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ProductListing
    };

    // ----- ProductPurchaseDisplayProperties class --------------------
    constexpr const char* const _type_name_ProductPurchaseDisplayProperties = "ProductPurchaseDisplayProperties";

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

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

                winrt::Windows::ApplicationModel::Store::ProductPurchaseDisplayProperties instance{ param0 };
                return py::wrap(instance, type);
            }
            catch (...)
            {
                py::to_PyErr();
                return nullptr;
            }
        }
        else if (arg_count == 0)
        {
            try
            {
                winrt::Windows::ApplicationModel::Store::ProductPurchaseDisplayProperties 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_ProductPurchaseDisplayProperties(py::wrapper::Windows::ApplicationModel::Store::ProductPurchaseDisplayProperties* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* ProductPurchaseDisplayProperties_get_Name(py::wrapper::Windows::ApplicationModel::Store::ProductPurchaseDisplayProperties* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Name());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

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

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

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

    static PyObject* ProductPurchaseDisplayProperties_get_Image(py::wrapper::Windows::ApplicationModel::Store::ProductPurchaseDisplayProperties* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Image());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

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

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

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

    static PyObject* ProductPurchaseDisplayProperties_get_Description(py::wrapper::Windows::ApplicationModel::Store::ProductPurchaseDisplayProperties* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Description());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

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

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

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

    static PyObject* _from_ProductPurchaseDisplayProperties(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::ApplicationModel::Store::ProductPurchaseDisplayProperties>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

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

    static PyGetSetDef _getset_ProductPurchaseDisplayProperties[] = {
        { "name", reinterpret_cast<getter>(ProductPurchaseDisplayProperties_get_Name), reinterpret_cast<setter>(ProductPurchaseDisplayProperties_put_Name), nullptr, nullptr },
        { "image", reinterpret_cast<getter>(ProductPurchaseDisplayProperties_get_Image), reinterpret_cast<setter>(ProductPurchaseDisplayProperties_put_Image), nullptr, nullptr },
        { "description", reinterpret_cast<getter>(ProductPurchaseDisplayProperties_get_Description), reinterpret_cast<setter>(ProductPurchaseDisplayProperties_put_Description), nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_ProductPurchaseDisplayProperties[] = 
    {
        { Py_tp_new, _new_ProductPurchaseDisplayProperties },
        { Py_tp_dealloc, _dealloc_ProductPurchaseDisplayProperties },
        { Py_tp_methods, _methods_ProductPurchaseDisplayProperties },
        { Py_tp_getset, _getset_ProductPurchaseDisplayProperties },
        { },
    };

    static PyType_Spec _type_spec_ProductPurchaseDisplayProperties =
    {
        "_winsdk_Windows_ApplicationModel_Store.ProductPurchaseDisplayProperties",
        sizeof(py::wrapper::Windows::ApplicationModel::Store::ProductPurchaseDisplayProperties),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_ProductPurchaseDisplayProperties
    };

    // ----- PurchaseResults class --------------------
    constexpr const char* const _type_name_PurchaseResults = "PurchaseResults";

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

    static void _dealloc_PurchaseResults(py::wrapper::Windows::ApplicationModel::Store::PurchaseResults* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* PurchaseResults_get_OfferId(py::wrapper::Windows::ApplicationModel::Store::PurchaseResults* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.OfferId());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PurchaseResults_get_ReceiptXml(py::wrapper::Windows::ApplicationModel::Store::PurchaseResults* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ReceiptXml());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PurchaseResults_get_Status(py::wrapper::Windows::ApplicationModel::Store::PurchaseResults* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.Status());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* PurchaseResults_get_TransactionId(py::wrapper::Windows::ApplicationModel::Store::PurchaseResults* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.TransactionId());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_PurchaseResults(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::ApplicationModel::Store::PurchaseResults>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

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

    static PyGetSetDef _getset_PurchaseResults[] = {
        { "offer_id", reinterpret_cast<getter>(PurchaseResults_get_OfferId), nullptr, nullptr, nullptr },
        { "receipt_xml", reinterpret_cast<getter>(PurchaseResults_get_ReceiptXml), nullptr, nullptr, nullptr },
        { "status", reinterpret_cast<getter>(PurchaseResults_get_Status), nullptr, nullptr, nullptr },
        { "transaction_id", reinterpret_cast<getter>(PurchaseResults_get_TransactionId), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_PurchaseResults[] = 
    {
        { Py_tp_new, _new_PurchaseResults },
        { Py_tp_dealloc, _dealloc_PurchaseResults },
        { Py_tp_methods, _methods_PurchaseResults },
        { Py_tp_getset, _getset_PurchaseResults },
        { },
    };

    static PyType_Spec _type_spec_PurchaseResults =
    {
        "_winsdk_Windows_ApplicationModel_Store.PurchaseResults",
        sizeof(py::wrapper::Windows::ApplicationModel::Store::PurchaseResults),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_PurchaseResults
    };

    // ----- UnfulfilledConsumable class --------------------
    constexpr const char* const _type_name_UnfulfilledConsumable = "UnfulfilledConsumable";

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

    static void _dealloc_UnfulfilledConsumable(py::wrapper::Windows::ApplicationModel::Store::UnfulfilledConsumable* self)
    {
        auto hash_value = std::hash<winrt::Windows::Foundation::IInspectable>{}(self->obj);
        py::wrapped_instance(hash_value, nullptr);
        self->obj = nullptr;
    }

    static PyObject* UnfulfilledConsumable_get_OfferId(py::wrapper::Windows::ApplicationModel::Store::UnfulfilledConsumable* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.OfferId());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* UnfulfilledConsumable_get_ProductId(py::wrapper::Windows::ApplicationModel::Store::UnfulfilledConsumable* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.ProductId());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* UnfulfilledConsumable_get_TransactionId(py::wrapper::Windows::ApplicationModel::Store::UnfulfilledConsumable* self, void* /*unused*/) noexcept
    {
        try
        {
            return py::convert(self->obj.TransactionId());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

    static PyObject* _from_UnfulfilledConsumable(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::ApplicationModel::Store::UnfulfilledConsumable>());
        }
        catch (...)
        {
            py::to_PyErr();
            return nullptr;
        }
    }

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

    static PyGetSetDef _getset_UnfulfilledConsumable[] = {
        { "offer_id", reinterpret_cast<getter>(UnfulfilledConsumable_get_OfferId), nullptr, nullptr, nullptr },
        { "product_id", reinterpret_cast<getter>(UnfulfilledConsumable_get_ProductId), nullptr, nullptr, nullptr },
        { "transaction_id", reinterpret_cast<getter>(UnfulfilledConsumable_get_TransactionId), nullptr, nullptr, nullptr },
        { }
    };

    static PyType_Slot _type_slots_UnfulfilledConsumable[] = 
    {
        { Py_tp_new, _new_UnfulfilledConsumable },
        { Py_tp_dealloc, _dealloc_UnfulfilledConsumable },
        { Py_tp_methods, _methods_UnfulfilledConsumable },
        { Py_tp_getset, _getset_UnfulfilledConsumable },
        { },
    };

    static PyType_Spec _type_spec_UnfulfilledConsumable =
    {
        "_winsdk_Windows_ApplicationModel_Store.UnfulfilledConsumable",
        sizeof(py::wrapper::Windows::ApplicationModel::Store::UnfulfilledConsumable),
        0,
        Py_TPFLAGS_DEFAULT,
        _type_slots_UnfulfilledConsumable
    };

    // ----- Windows.ApplicationModel.Store Initialization --------------------
    static int module_exec(PyObject* module) noexcept
    {
        try
        {
            py::pyobj_handle bases { PyTuple_Pack(1, py::winrt_type<py::Object>::python_type) };

            py::winrt_type<winrt::Windows::ApplicationModel::Store::CurrentApp>::python_type = py::register_python_type(module, _type_name_CurrentApp, &_type_spec_CurrentApp, nullptr);
            py::winrt_type<winrt::Windows::ApplicationModel::Store::CurrentAppSimulator>::python_type = py::register_python_type(module, _type_name_CurrentAppSimulator, &_type_spec_CurrentAppSimulator, nullptr);
            py::winrt_type<winrt::Windows::ApplicationModel::Store::LicenseInformation>::python_type = py::register_python_type(module, _type_name_LicenseInformation, &_type_spec_LicenseInformation, bases.get());
            py::winrt_type<winrt::Windows::ApplicationModel::Store::ListingInformation>::python_type = py::register_python_type(module, _type_name_ListingInformation, &_type_spec_ListingInformation, bases.get());
            py::winrt_type<winrt::Windows::ApplicationModel::Store::ProductLicense>::python_type = py::register_python_type(module, _type_name_ProductLicense, &_type_spec_ProductLicense, bases.get());
            py::winrt_type<winrt::Windows::ApplicationModel::Store::ProductListing>::python_type = py::register_python_type(module, _type_name_ProductListing, &_type_spec_ProductListing, bases.get());
            py::winrt_type<winrt::Windows::ApplicationModel::Store::ProductPurchaseDisplayProperties>::python_type = py::register_python_type(module, _type_name_ProductPurchaseDisplayProperties, &_type_spec_ProductPurchaseDisplayProperties, bases.get());
            py::winrt_type<winrt::Windows::ApplicationModel::Store::PurchaseResults>::python_type = py::register_python_type(module, _type_name_PurchaseResults, &_type_spec_PurchaseResults, bases.get());
            py::winrt_type<winrt::Windows::ApplicationModel::Store::UnfulfilledConsumable>::python_type = py::register_python_type(module, _type_name_UnfulfilledConsumable, &_type_spec_UnfulfilledConsumable, bases.get());

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

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

    PyDoc_STRVAR(module_doc, "Windows.ApplicationModel.Store");

    static PyModuleDef module_def
        = {PyModuleDef_HEAD_INIT,
           "_winsdk_Windows_ApplicationModel_Store",
           module_doc,
           0,
           nullptr,
           module_slots,
           nullptr,
           nullptr,
           nullptr};
} // py::cpp::Windows::ApplicationModel::Store

PyMODINIT_FUNC
PyInit__winsdk_Windows_ApplicationModel_Store (void) noexcept
{
    return PyModuleDef_Init(&py::cpp::Windows::ApplicationModel::Store::module_def);
}
