How to properly format classes for JSON deserialization with JSON.net for Unity?

First, a few minor tweaks that might depend on your JSON library (it looks like you're using the Newtonsoft JSON library, rather than the built-in Unity JsonUtility); I can't say whether your version behaves differently, but for Unity's JSON implementation:

• The serializer will serialize/deserialize fields, not properties - so you'd have to remove all the { get; set; } auto-property markup to get the fields to be picked up that way

• Your fields need to be marked public or [SerializeField] - your ItemBase and StatBonus members lack this at the moment.

• The serializer starts at the level of the members of the root object, rather than treating the root object as a named member of an enclosing object, so you can remove the outermost "Items":{ ... } wrapper and jump straight from the outer {...} into your categories.

Again, feel free to disregard these points if they're unique to Unity's JsonUtility and not reflective of the library you're using.

The more fundamental problem is that your JSON and your class definitions don't agree.

Your JSON corresponds to an Items class with named fields for each category, which is just a list or array of ItemBase:

[System.Serializable]
public class Items
{
    public List<ItemBase> Ingredients;
    public List<ItemBase> Consumables;
    public List<ItemBase> Concoctions;
    public List<ItemBase> Equipment;
    public List<ItemBase> Abilities;
}

Your Items class corresponds to JSON with a type field, and anonymous array/list entries for each category, each one having an id member to contain the list:

{
    "type": [
        {
            "id": [
                {   
                    "ID": "foo",
                    "Icon": "bar",
                    "Name": "baz",
                    "Consumable": false
                }
            ]
        },
        {
            "id": [
                {
                    "ID": "foo",
                    "Icon": "bar",
                    "Name": "baz",
                    "Consumable": false
                }
            ]
        }
    ]
}

A good way to make sure your JSON and internal class definitions match-up: whip up a script that synthetically creates and populates an instance of your class with dummy data, then spits out the JSON that results.

public class JSONTest : MonoBehaviour
{
    [TextArea(5, 50)]
    public string jsonOutput;

    void Start()
    {
        var items = new Items();

        items.type = new List<ItemCategory>();
        var category = new ItemCategory();
        items.type.Add(category);
        category = new ItemCategory();
        items.type.Add(category);

        category.id = new List<ItemBase>();
        category.id.Add(new ItemBase() { ID = "foo", Icon = "bar", Name = "baz", Cooldown = 42, Duration = 7, EffectDescription = "Very Good", Description = "Something" });

        jsonOutput = JsonUtility.ToJson(items, true);
    }
}

Then you can compare the formatting of that result against the JSON you were trying to use, to either adjust your input to match your internal representation, or adjust your internal representation to suit your input.