using UnityEngine;
using UnityEngine.UI;
using Xsolla.Auth;
using Xsolla.Core;

namespace Xsolla.Samples.Authorization
{
    public class RegistrationPage : MonoBehaviour
    {
        // Declaration of variables for UI elements
     public InputField UsernameInput;
        public InputField EmailInputField;
        public InputField PasswordInputField;
        public Button RegisterButton;

        private void Start()
        {
            // Handling the button click
         RegisterButton.onClick.AddListener(() =>
            {
                // Get the username, email and password from input fields
             var username = UsernameInput.text;
                var email = EmailInputField.text;
                var password = PasswordInputField.text;

                // Call the user registration method
             // Pass credentials and callback functions for success and error cases
             XsollaAuth.Register(username, password, email, OnSuccess, OnError);
            });
        }

        private void OnSuccess(LoginLink loginLink)
        {
            Debug.Log("Registration successful");
            // Add actions taken in case of success
     }

        private void OnError(Error error)
        {
            Debug.LogError($"Registration failed. Error: {error.errorMessage}");
            // Add actions taken in case of error
     }
    }
}

using UnityEngine;
using UnityEngine.UI;
using Xsolla.Auth;
using Xsolla.Core;

namespace Xsolla.Samples.Authorization
{
    public class ResendConfirmationEmailPage : MonoBehaviour
    {
        // Declaration of variables for UI elements
     public InputField UsernameInput;
        public Button ResendEmailButton;

        private void Start()
        {
            // Handling the button click
         ResendEmailButton.onClick.AddListener(() =>
            {
                // Get the username from the input field
             var username = UsernameInput.text;

                // Call the resend confirmation email method
             // Pass the username and callback functions for success and error cases
             XsollaAuth.ResendConfirmationLink(username, OnSuccess, OnError);
            });
        }

        private void OnSuccess()
        {
            Debug.Log("Resend confirmation email successful");
            // Add actions taken in case of success
     }

        private void OnError(Error error)
        {
            Debug.LogError($"Resend confirmation email failed. Error: {error.errorMessage}");
            // Add actions taken in case of error
     }
    }
}

using UnityEngine;
using UnityEngine.UI;
using Xsolla.Auth;
using Xsolla.Core;

namespace Xsolla.Samples.Authorization
{
    public class AuthorizationPage : MonoBehaviour
    {
        // Declaration of variables for UI elements
     public InputField UsernameInput;
        public InputField PasswordInputField;
        public Button SignInButton;

        private void Start()
        {
            // Handling the button click
         SignInButton.onClick.AddListener(() =>
            {
                // Get the username and password from input fields
             var username = UsernameInput.text;
                var password = PasswordInputField.text;

                // Call the user authorization method
             // Pass credentials and callback functions for success and error cases
             XsollaAuth.SignIn(username, password, OnSuccess, OnError);
            });
        }

        private void OnSuccess()
        {
            Debug.Log("Authorization successful");
            // Add actions taken in case of success
     }

        private void OnError(Error error)
        {
            Debug.LogError($"Authorization failed. Error: {error.errorMessage}");
            // Add actions taken in case of error
     }
    }
}

using UnityEngine;
using UnityEngine.UI;
using Xsolla.Auth;
using Xsolla.Core;

namespace Xsolla.Samples.Authorization
{
    public class ResetPasswordPage : MonoBehaviour
    {
        // Declaration of variables for UI elements
     public InputField UsernameInput;
        public Button ResetPasswordButton;

        private void Start()
        {
            // Handling the button click
         ResetPasswordButton.onClick.AddListener(() =>
            {
                // Get the username from the input field
             var username = UsernameInput.text;

                // Call the password reset method
             // Pass the username and callback functions for success and error cases
             XsollaAuth.ResetPassword(username, OnSuccess, OnError);
            });
        }

        private void OnSuccess()
        {
            Debug.Log("Password reset successful");
            // Add actions taken in case of success
     }

        private void OnError(Error error)
        {
            Debug.LogError($"Password reset failed. Error: {error.errorMessage}");
            // Add actions taken in case of error
     }
    }
}

using UnityEngine;
using UnityEngine.UI;
using Xsolla.Auth;
using Xsolla.Core;

namespace Xsolla.Samples.Authorization
{
    public class SocialAuthorizationPage : MonoBehaviour
    {
        // Declaration of variables for SocialProvider and signIn button
     public SocialProvider SocialProvider = SocialProvider.Facebook;
        public Button SignInButton;

        private void Start()
        {
            // Handling the button click
         SignInButton.onClick.AddListener(() =>
            {
                // Call the social authorization method
             // Pass the social network provider and callback functions for success, error and cancel cases
             XsollaAuth.AuthViaSocialNetwork(SocialProvider, OnSuccess, OnError, OnCancel);
            });
        }

        private void OnSuccess()
        {
            Debug.Log("Social authorization successful");
            // Add actions taken in case of success
     }

        private void OnError(Error error)
        {
            Debug.LogError($"Social authorization failed. Error: {error.errorMessage}");
            // Add actions taken in case of error
     }

        private void OnCancel()
        {
            Debug.Log("Social authorization cancelled by user.");
            // Add actions taken in case the user canceles authorization
     }
    }
}

using UnityEngine;
using UnityEngine.UI;

namespace Xsolla.Samples.DisplayCatalog
{
    public class VirtualItemWidget : MonoBehaviour
    {
        // Declaration of variables for UI elements
     public Text NameText;
        public Text DescriptionText;
        public Text PriceText;
        public Image IconImage;
    }
}

using System.Linq;
using UnityEngine;
using Xsolla.Auth;
using Xsolla.Catalog;
using Xsolla.Core;

namespace Xsolla.Samples.DisplayCatalog
{
    public class VirtualItemsPage : MonoBehaviour
    {
        // Declaration of variables for widget's container and prefab
     public Transform WidgetsContainer;
        public GameObject WidgetPrefab;

        private void Start()
        {
            // Starting the authentication process
         // Pass the credentials and callback functions for success and error cases
         // The credentials (username and password) are hard-coded for simplicity
         XsollaAuth.SignIn("xsolla", "xsolla", OnAuthenticationSuccess, OnError);
        }

        private void OnAuthenticationSuccess()
        {
            // Starting the items request from the store after successful authentication
         XsollaCatalog.GetCatalog(OnItemsRequestSuccess, OnError);
        }

        private void OnItemsRequestSuccess(StoreItems storeItems)
        {
            // Iterating the items collection
         foreach (var storeItem in storeItems.items)
            {
                // Instantiating the widget prefab as child of the container
             var widgetGo = Instantiate(WidgetPrefab, WidgetsContainer, false);
                var widget = widgetGo.GetComponent<VirtualItemWidget>();

                // Assigning the values for UI elements
             widget.NameText.text = storeItem.name;
                widget.DescriptionText.text = storeItem.description;

                // The item can be purchased for real money or virtual currency
             // Checking the price type and assigning the values for appropriate UI elements
             if (storeItem.price != null)
                {
                    var realMoneyPrice = storeItem.price;
                    widget.PriceText.text = $"{realMoneyPrice.amount} {realMoneyPrice.currency}";
                }
                else if (storeItem.virtual_prices != null)
                {
                    var virtualCurrencyPrice = storeItem.virtual_prices.First(x => x.is_default);
                    widget.PriceText.text = $"{virtualCurrencyPrice.name}: {virtualCurrencyPrice.amount}";
                }

                // Loading the item image and assigning it to the UI element
             ImageLoader.LoadSprite(storeItem.image_url, sprite => widget.IconImage.sprite = sprite);
            }
        }

        private void OnError(Error error)
        {
            Debug.LogError($"Error: {error.errorMessage}");
            // Add actions taken in case of error
     }
    }
}

using UnityEngine;
using UnityEngine.UI;

namespace Xsolla.Samples.DisplayCatalog
{
    public class VirtualItemWidget : MonoBehaviour
    {
        // Declaration of variables for UI elements
     public Text NameText;
        public Text DescriptionText;
        public Text PriceText;
        public Image IconImage;
    }
}

using UnityEngine;
using UnityEngine.UI;

namespace Xsolla.Samples.DisplayCatalog
{
    public class VirtualItemGroupButton : MonoBehaviour
    {
        // Declaration of variables for UI elements
     public Text NameText;
        public Button Button;
    }
}

using System.Collections.Generic;
using System.Linq;
using UnityEngine;
using Xsolla.Auth;
using Xsolla.Catalog;
using Xsolla.Core;

namespace Xsolla.Samples.DisplayCatalog
{
    public class VirtualItemsByGroupsPage : MonoBehaviour
    {
        // Declaration of variables for widget's container and prefab
     public Transform GroupButtonsContainer;
        public GameObject GroupButtonPrefab;
        public Transform ItemWidgetsContainer;
        public GameObject ItemWidgetPrefab;

        private void Start()
        {
            // Starting the authentication process
         // Pass the credentials and callback functions for success and error cases
         // The credentials (username and password) are hard-coded for simplicity
         XsollaAuth.SignIn("xsolla", "xsolla", OnAuthenticationSuccess, OnError);
        }

        private void OnAuthenticationSuccess()
        {
            // Starting the items request from the store after successful authentication
         // Pass the callback functions for success and error cases
         XsollaCatalog.GetCatalog(OnItemsRequestSuccess, OnError);
        }

        private void OnItemsRequestSuccess(StoreItems storeItems)
        {
            // Selecting the group’s name from items and order them alphabetically
         var groupNames = storeItems.items
                .SelectMany(x => x.groups)
                .GroupBy(x => x.name)
                .Select(x => x.First())
                .OrderBy(x => x.name)
                .Select(x => x.name)
                .ToList();

            // Add group name for catalog category with all items regardless of group affiliation
         groupNames.Insert(0, "All");

            // Iterating the group names collection
         foreach (var groupName in groupNames)
            {
                // Instantiating the button prefab as child of the container
             var buttonGo = Instantiate(GroupButtonPrefab, GroupButtonsContainer, false);
                var groupButton = buttonGo.GetComponent<VirtualItemGroupButton>();

                // Assigning the values for UI elements
             groupButton.NameText.text = groupName;

                // Adding listener for button click event
             groupButton.Button.onClick.AddListener(() => OnGroupSelected(groupName, storeItems));
            }

            // Calling method for redraw page
         OnGroupSelected("All", storeItems);
        }

        private void OnGroupSelected(string groupName, StoreItems storeItems)
        {
            // Clear container
         DeleteAllChildren(ItemWidgetsContainer);

            // Declaring variable for items to be displayed on the page
         IEnumerable<StoreItem> itemsForDisplay;
            if (groupName == "All")
            {
                itemsForDisplay = storeItems.items;
            }
            else
            {
                itemsForDisplay = storeItems.items.Where(item => item.groups.Any(group => group.name == groupName));
            }

            // Iterating the items collection and assigning values for appropriate UI elements
         foreach (var storeItem in itemsForDisplay)
            {
                // Instantiating the widget prefab as child of the container
             var widgetGo = Instantiate(ItemWidgetPrefab, ItemWidgetsContainer, false);
                var widget = widgetGo.GetComponent<VirtualItemWidget>();

                // Assigning the values for UI elements
             widget.NameText.text = storeItem.name;
                widget.DescriptionText.text = storeItem.description;

                // The item can be purchased for real money or virtual currency
             // Checking the price type and assigning the appropriate value for price text
             if (storeItem.price != null)
                {
                    var realMoneyPrice = storeItem.price;
                    widget.PriceText.text = $"{realMoneyPrice.amount} {realMoneyPrice.currency}";
                }
                else if (storeItem.virtual_prices != null)
                {
                    var virtualCurrencyPrice = storeItem.virtual_prices.First(x => x.is_default);
                    widget.PriceText.text = $"{virtualCurrencyPrice.name}: {virtualCurrencyPrice.amount}";
                }

                // Loading the image for item icon and assigning it to the UI element
             ImageLoader.LoadSprite(storeItem.image_url, sprite => widget.IconImage.sprite = sprite);
            }
        }

        private void OnError(Error error)
        {
            Debug.LogError($"Error: {error.errorMessage}");
            //  Add actions taken in case of error
     }

        // Utility method to delete all children of a container
     private static void DeleteAllChildren(Transform parent)
        {
            var childList = parent.Cast<Transform>().ToList();
            foreach (var childTransform in childList)
            {
                Destroy(childTransform.gameObject);
            }
        }
    }
}

using UnityEngine;
using UnityEngine.UI;

namespace Xsolla.Samples.DisplayCatalog
{
    public class BundleWidget : MonoBehaviour
    {
        // Declaration of variables for UI elements
     public Text NameText;
        public Text DescriptionText;
        public Text PriceText;
        public Text ContentText;
        public Image IconImage;
    }
}

using System.Linq;
using UnityEngine;
using Xsolla.Auth;
using Xsolla.Catalog;
using Xsolla.Core;

namespace Xsolla.Samples.DisplayCatalog
{
    public class BundlesPage : MonoBehaviour
    {
        // Declaration of variables for widget's container and prefab
     public Transform WidgetsContainer;
        public GameObject WidgetPrefab;

        private void Start()
        {
            // Starting the authentication process
         // Pass the credentials and callback functions for success and error cases
         // The credentials (username and password) are hard-coded for simplicity
         XsollaAuth.SignIn("xsolla", "xsolla", OnAuthenticationSuccess, OnError);
        }

        private void OnAuthenticationSuccess()
        {
            // Starting the bundle request from the store after successful authentication
         // Pass the callback functions for success and error cases
         XsollaCatalog.GetBundles(OnBundlesRequestSuccess, OnError);
        }

        private void OnBundlesRequestSuccess(BundleItems bundleItems)
        {
            // Iterating the bundles collection
         foreach (var bundleItem in bundleItems.items)
            {
                // Instantiating the widget prefab as child of the container
             var widgetGo = Instantiate(WidgetPrefab, WidgetsContainer, false);
                var widget = widgetGo.GetComponent<BundleWidget>();

                // Assigning the values for UI elements
             widget.NameText.text = bundleItem.name;
                widget.DescriptionText.text = bundleItem.description;

                // Creating the string with bundle content and assigning it to the UI element
             var bundleContent = bundleItem.content.Select(x => $"{x.name} x {x.quantity}");
                widget.ContentText.text = string.Join("\n", bundleContent);

                // The bundle can be purchased for real money or virtual currency
             // Checking the price type and assigning the values for appropriate UI elements
             if (bundleItem.price != null)
                {
                    var realMoneyPrice = bundleItem.price;
                    widget.PriceText.text = $"{realMoneyPrice.amount} {realMoneyPrice.currency}";
                }
                else if (bundleItem.virtual_prices != null)
                {
                    var virtualCurrencyPrice = bundleItem.virtual_prices.First(x => x.is_default);
                    widget.PriceText.text = $"{virtualCurrencyPrice.name}: {virtualCurrencyPrice.amount}";
                }

                // Loading the bundle image and assigning it to the UI element
             ImageLoader.LoadSprite(bundleItem.image_url, sprite => widget.IconImage.sprite = sprite);
            }
        }

        private void OnError(Error error)
        {
            Debug.LogError($"Error: {error.errorMessage}");
            // Add actions taken in case of error
     }
    }
}

using UnityEngine;
using UnityEngine.UI;

namespace Xsolla.Samples.DisplayCatalog
{
    public class VirtualCurrencyPackageWidget : MonoBehaviour
    {
        // Declaration of variables for UI elements
     public Text NameText;
        public Text DescriptionText;
        public Text PriceText;
        public Image IconImage;
    }
}

using System.Linq;
using UnityEngine;
using Xsolla.Auth;
using Xsolla.Catalog;
using Xsolla.Core;

namespace Xsolla.Samples.DisplayCatalog
{
    public class VirtualCurrencyPackagesPage : MonoBehaviour
    {
        // Declaration of variables for widget's container and prefab
     public Transform WidgetsContainer;
        public GameObject WidgetPrefab;

        private void Start()
        {
            // Starting the authentication process
         // Pass the credentials and callback functions for success and error cases
         // The credentials (username and password) are hard-coded for simplicity
         XsollaAuth.SignIn("xsolla", "xsolla", OnAuthenticationSuccess, OnError);
        }

        private void OnAuthenticationSuccess()
        {
            // After successful authentication starting the request for packages from store
         // Pass the callback functions for success and error cases
         XsollaCatalog.GetVirtualCurrencyPackagesList(OnPackagesRequestSuccess, OnError);
        }

        private void OnPackagesRequestSuccess(VirtualCurrencyPackages packageItems)
        {
            // Iterating the virtual currency packages collection
         foreach (var packageItem in packageItems.items)
            {
                // Instantiating the widget prefab as child of the container
             var widgetGo = Instantiate(WidgetPrefab, WidgetsContainer, false);
                var widget = widgetGo.GetComponent<VirtualCurrencyPackageWidget>();

                // Assigning the values for UI elements
             widget.NameText.text = packageItem.name;
                widget.DescriptionText.text = packageItem.description;

                // The package can be purchased for real money or virtual currency
             // Checking the price type and assigning the values for appropriate UI elements
             if (packageItem.price != null)
                {
                    var realMoneyPrice = packageItem.price;
                    widget.PriceText.text = $"{realMoneyPrice.amount} {realMoneyPrice.currency}";
                }
                else if (packageItem.virtual_prices != null)
                {
                    var virtualCurrencyPrice = packageItem.virtual_prices.First(x => x.is_default);
                    widget.PriceText.text = $"{virtualCurrencyPrice.name}: {virtualCurrencyPrice.amount}";
                }

                // Loading the package image and assigning it to the UI element
             ImageLoader.LoadSprite(packageItem.image_url, sprite => widget.IconImage.sprite = sprite);
            }
        }

        private void OnError(Error error)
        {
            Debug.LogError($"Error: {error.errorMessage}");
            // Add actions taken in case of error
     }
    }
}

using UnityEngine;
using UnityEngine.UI;

namespace Xsolla.Samples.SellForRealMoney
{
    public class VirtualItemWidget : MonoBehaviour
    {
        // Declaration of variables for UI elements
     public Text NameText;
        public Text DescriptionText;
        public Text PriceText;
        public Image IconImage;
        public Button BuyButton;
    }
}

using UnityEngine;
using Xsolla.Auth;
using Xsolla.Catalog;
using Xsolla.Core;

namespace Xsolla.Samples.SellForRealMoney
{
    public class VirtualItemsPage : MonoBehaviour
    {
        // Declaration of variables for widget's container and prefab
     public Transform WidgetsContainer;
        public GameObject WidgetPrefab;

        private void Start()
        {
            // Starting the authentication process
         // Pass the credentials and callback functions for success and error cases
         // The credentials (username and password) are hard-coded for simplicity
         XsollaAuth.SignIn("xsolla", "xsolla", OnAuthenticationSuccess, OnError);
        }

        private void OnAuthenticationSuccess()
        {
            // Starting the items request from the store after successful authentication
         // Pass the callback functions for success and error cases
         XsollaCatalog.GetCatalog(OnItemsRequestSuccess, OnError);
        }

        private void OnItemsRequestSuccess(StoreItems storeItems)
        {
            // Iterating the items collection
         foreach (var storeItem in storeItems.items)
            {
                // Skipping items without prices in real money
             if (storeItem.price == null)
                    continue;

                // Instantiating the widget prefab as child of the container
             var widgetGo = Instantiate(WidgetPrefab, WidgetsContainer, false);
                var widget = widgetGo.GetComponent<VirtualItemWidget>();

                // Assigning the values for UI elements
             widget.NameText.text = storeItem.name;
                widget.DescriptionText.text = storeItem.description;

                // Assigning the price and currency values for UI elements
             var price = storeItem.price;
                widget.PriceText.text = $"{price.amount} {price.currency}";

                // Loading the item image and assigning it to the UI element
             ImageLoader.LoadSprite(storeItem.image_url, sprite => widget.IconImage.sprite = sprite);

                // Assigning the click listener for the buy button
             widget.BuyButton.onClick.AddListener(() =>
                {
                    // Starting the purchase process
                 // Pass the item SKU and callback functions for success and error cases
                 XsollaCatalog.Purchase(storeItem.sku, OnPurchaseSuccess, OnError);
                });
            }
        }

        private void OnPurchaseSuccess(OrderStatus status)
        {
            Debug.Log("Purchase successful");
            // Add actions taken in case of success
     }

        private void OnError(Error error)
        {
            Debug.LogError($"Error: {error.errorMessage}");
            // Add actions taken in case of error
     }
    }
}

using UnityEngine;
using UnityEngine.UI;

namespace Xsolla.Samples.SellForVirtualCurrency
{
    public class VirtualItemWidget : MonoBehaviour
    {
        // Declaration of variables for UI elements
     public Text NameText;
        public Text DescriptionText;
        public Text PriceText;
        public Image IconImage;
        public Button BuyButton;
    }
}

using System.Linq;
using UnityEngine;
using Xsolla.Auth;
using Xsolla.Catalog;
using Xsolla.Core;

namespace Xsolla.Samples.SellForVirtualCurrency
{
    public class VirtualItemsPage : MonoBehaviour
    {
        // Declaration of variables for containers and widget prefabs
     public Transform WidgetsContainer;
        public GameObject WidgetPrefab;

        private void Start()
        {
            // Starting the authentication process
         // Pass the credentials and callback functions for success and error cases
         // The credentials (username and password) are hard-coded for simplicity
         XsollaAuth.SignIn("xsolla", "xsolla", OnAuthenticationSuccess, OnError);
        }

        private void OnAuthenticationSuccess()
        {
            // After successful authentication starting the request for catalog from store
         // Pass the callback functions for success and error cases
         XsollaCatalog.GetCatalog(OnItemsRequestSuccess, OnError);
        }

        private void OnItemsRequestSuccess(StoreItems storeItems)
        {
            // Iterating the items collection
         foreach (var storeItem in storeItems.items)
            {
                // Skipping items without prices in virtual currency
             if (storeItem.virtual_prices.Length == 0)
                    continue;

                // Instantiating the widget prefab as child of the container
             var widgetGo = Instantiate(WidgetPrefab, WidgetsContainer, false);
                var widget = widgetGo.GetComponent<VirtualItemWidget>();

                // Assigning the values for UI elements
             widget.NameText.text = storeItem.name;
                widget.DescriptionText.text = storeItem.description;

                // Assigning the price and currency values for UI elements
             // The first price is used for the sake of simplicity
             var price = storeItem.virtual_prices.First(x => x.is_default);
                widget.PriceText.text = $"{price.name}: {price.amount}";

                // Loading the item image and assigning it to the UI element
             ImageLoader.LoadSprite(storeItem.image_url, sprite => widget.IconImage.sprite = sprite);

                // Assigning the click listener for the buy button
             widget.BuyButton.onClick.AddListener(() =>
                {
                    // Starting the purchase process
                 // Pass the item SKU, the price virtual currency SKU and callback functions for success and error cases
                 XsollaCatalog.PurchaseForVirtualCurrency(storeItem.sku, price.sku, OnPurchaseSuccess, OnError);
                });
            }
        }

        private void OnPurchaseSuccess(OrderStatus status)
        {
            Debug.Log("Purchase successful");
            // Add actions taken in case of success
     }

        private void OnError(Error error)
        {
            Debug.LogError($"Error: {error.errorMessage}");
            // Add actions taken in case of error
     }
    }
}

using UnityEngine;
using UnityEngine.UI;

namespace Xsolla.Samples.DisplayVirtualCurrencyBalance
{
    public class VirtualCurrencyWidget : MonoBehaviour
    {
        // Declaration of variables for UI elements
     public Text NameText;
        public Text AmountText;
        public Image IconImage;
    }
}

using UnityEngine;
using Xsolla.Auth;
using Xsolla.Core;
using Xsolla.Inventory;

namespace Xsolla.Samples.DisplayVirtualCurrencyBalance
{
    public class VirtualCurrenciesPage : MonoBehaviour
    {
        // Declaration of variables for widget's container and prefab
     public Transform WidgetsContainer;
        public GameObject WidgetPrefab;

        private void Start()
        {
            // Starting the authentication process
         // Pass the credentials and callback functions for success and error cases
         // The credentials (username and password) are hard-coded for simplicity
         XsollaAuth.SignIn("xsolla", "xsolla", OnAuthenticationSuccess, OnError);
        }

        private void OnAuthenticationSuccess()
        {
            // Starting the virtual currencies request from the store after successful authentication
         // Pass the callback functions for success and error cases
         XsollaInventory.GetVirtualCurrencyBalance(OnBalanceRequestSuccess, OnError);
        }

        private void OnBalanceRequestSuccess(VirtualCurrencyBalances balance)
        {
            // Iterating the virtual currency balances collection
         foreach (var balanceItem in balance.items)
            {
                // Instantiating the widget prefab as child of the container
             var widgetGo = Instantiate(WidgetPrefab, WidgetsContainer, false);
                var widget = widgetGo.GetComponent<VirtualCurrencyWidget>();

                // Assigning the values for UI elements
             widget.NameText.text = balanceItem.name;
                widget.AmountText.text = balanceItem.amount.ToString();

                ImageLoader.LoadSprite(balanceItem.image_url, sprite => widget.IconImage.sprite = sprite);
            }
        }

        private void OnError(Error error)
        {
            Debug.LogError($"Error: {error.errorMessage}");
            // Add actions taken in case of error
     }
    }
}

using UnityEngine;
using UnityEngine.UI;

namespace Xsolla.Samples.DisplayItemsInInventory
{
    public class InventoryItemWidget : MonoBehaviour
    {
        // Declaration of variables for UI elements
     public Text NameText;
        public Text DescriptionText;
        public Text QuantityText;
        public Image IconImage;
    }
}

using UnityEngine;
using Xsolla.Auth;
using Xsolla.Core;
using Xsolla.Inventory;

namespace Xsolla.Samples.DisplayItemsInInventory
{
    public class InventoryItemsPage : MonoBehaviour
    {
        // Declaration of variables for widget's container and prefab
     public Transform WidgetsContainer;
        public GameObject WidgetPrefab;

        private void Start()
        {
            // Starting the authentication process
         // Pass the credentials and callback functions for success and error cases
         // The credentials (username and password) are hard-coded for simplicity
         XsollaAuth.SignIn("xsolla", "xsolla", OnAuthenticationSuccess, OnError);
        }

        private void OnAuthenticationSuccess()
        {
            // Starting the items request from the store after successful authentication
         // Pass the callback functions for success and error cases
         XsollaInventory.GetInventoryItems(OnItemsRequestSuccess, OnError);
        }

        private void OnItemsRequestSuccess(InventoryItems inventoryItems)
        {
            // Iterating the items collection
         foreach (var inventoryItem in inventoryItems.items)
            {
                // Skipping virtual currency items
             if (inventoryItem.VirtualItemType == VirtualItemType.VirtualCurrency)
                    continue;

                // Instantiating the widget prefab as child of the container
             var widgetGo = Instantiate(WidgetPrefab, WidgetsContainer, false);
                var widget = widgetGo.GetComponent<InventoryItemWidget>();

                // Assigning the values for UI elements
             widget.NameText.text = inventoryItem.name;
                widget.DescriptionText.text = inventoryItem.description;
                widget.QuantityText.text = inventoryItem.quantity.ToString();

                // Loading the item image and assigning it to the UI element
             ImageLoader.LoadSprite(inventoryItem.image_url, sprite => widget.IconImage.sprite = sprite);
            }
        }

        private void OnError(Error error)
        {
            Debug.LogError($"Error: {error.errorMessage}");
            // Add actions taken in case of error
     }
    }
}