diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100755
index 0000000..7a84ea5
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1 @@
+Replaced when project is built from commit logs via Semantic Release.
diff --git a/CHANGELOG.md.meta b/CHANGELOG.md.meta
new file mode 100644
index 0000000..bbdfb4e
--- /dev/null
+++ b/CHANGELOG.md.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 738a34c22e4054e0a9c06d5e9919a4cc
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Documentation~/com.fluid.elastic-inventory.md b/Documentation~/com.fluid.elastic-inventory.md
new file mode 100755
index 0000000..f37d25d
--- /dev/null
+++ b/Documentation~/com.fluid.elastic-inventory.md
@@ -0,0 +1 @@
+Documentation beyond README.md goes here.
diff --git a/Editor.meta b/Editor.meta
new file mode 100644
index 0000000..aabfaf7
--- /dev/null
+++ b/Editor.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: b86cd99dfac11486f829781bc5f81db9
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Editor/Components.meta b/Editor/Components.meta
new file mode 100644
index 0000000..0c13621
--- /dev/null
+++ b/Editor/Components.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 699c1cdf6b6745028d78c7cf7c6b35d2
+timeCreated: 1684875207
\ No newline at end of file
diff --git a/Editor/Components/Atoms.meta b/Editor/Components/Atoms.meta
new file mode 100644
index 0000000..946cc9a
--- /dev/null
+++ b/Editor/Components/Atoms.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: a105d96d3ce44d899180fd2fdd6f9a38
+timeCreated: 1685131372
\ No newline at end of file
diff --git a/Editor/Components/Atoms/DropdownAdd.cs b/Editor/Components/Atoms/DropdownAdd.cs
new file mode 100644
index 0000000..6a6a4b5
--- /dev/null
+++ b/Editor/Components/Atoms/DropdownAdd.cs
@@ -0,0 +1,59 @@
+using System.Collections.Generic;
+using UnityEngine.UIElements;
+
+namespace CleverCrow.Fluid.ElasticInventory.Editors {
+    public class DropdownAdd<T> : ComponentBase {
+        readonly DropdownField _dropdown;
+        readonly List<KeyValuePair<string, T>> _choices;
+        readonly string _addText;
+        readonly VisualElement _containerParent;
+        readonly bool _resetOnInteract;
+
+        // @TODO Make addText optional so the categories will update on click
+        public DropdownAdd (
+            VisualElement containerParent,
+            string addText,
+            List<KeyValuePair<string, T>> choices,
+            bool resetOnInteract = true
+        ) : base(containerParent) {
+            _containerParent = containerParent;
+            _choices = choices;
+            _addText = addText;
+            _resetOnInteract = resetOnInteract;
+
+            var keys = choices.ConvertAll(choice => choice.Key);
+            keys.Insert(0, addText);
+
+            _dropdown = CreateDropdownField(keys);
+        }
+
+        public void BindClick (System.Action<T> callback) {
+            _dropdown.RegisterCallback<ChangeEvent<string>>(e => {
+                if (_resetOnInteract) _dropdown.value = _addText;
+                if (e.newValue == _addText) {
+                    callback(default);
+                    return;
+                }
+
+                var choice = _choices.Find(c => c.Key == e.newValue);
+                callback(choice.Value);
+            });
+        }
+
+        private DropdownField CreateDropdownField (List<string> keys) {
+            var dropdown = new DropdownField() {
+                choices = keys,
+                value = _addText
+            };
+
+            _containerParent.Add(dropdown);
+
+            return dropdown;
+        }
+
+        public void SetValue (int indexOf) {
+            if (indexOf < 0 || indexOf >= _choices.Count) return;
+            _dropdown.value = _choices[indexOf].Key;
+        }
+    }
+}
diff --git a/Editor/Components/Atoms/DropdownAdd.cs.meta b/Editor/Components/Atoms/DropdownAdd.cs.meta
new file mode 100644
index 0000000..b51cc06
--- /dev/null
+++ b/Editor/Components/Atoms/DropdownAdd.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: a56c8ee0400e4882937932ebbbf8a923
+timeCreated: 1685131381
\ No newline at end of file
diff --git a/Editor/Components/Molecules.meta b/Editor/Components/Molecules.meta
new file mode 100644
index 0000000..6bc36bb
--- /dev/null
+++ b/Editor/Components/Molecules.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: a786f15a2afb46b2b81f9c8891c80ba0
+timeCreated: 1687027657
\ No newline at end of file
diff --git a/Editor/Components/Molecules/SearchInput.meta b/Editor/Components/Molecules/SearchInput.meta
new file mode 100644
index 0000000..91c1d68
--- /dev/null
+++ b/Editor/Components/Molecules/SearchInput.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 2ed41a3d070d4be78f6b4fde5ea4b8de
+timeCreated: 1687027004
\ No newline at end of file
diff --git a/Editor/Components/Molecules/SearchInput/SearchInput.cs b/Editor/Components/Molecules/SearchInput/SearchInput.cs
new file mode 100644
index 0000000..5bba3ce
--- /dev/null
+++ b/Editor/Components/Molecules/SearchInput/SearchInput.cs
@@ -0,0 +1,16 @@
+using UnityEngine.UIElements;
+
+namespace CleverCrow.Fluid.ElasticInventory.Editors {
+    public class SearchInput : ComponentBase {
+        public SearchInput (VisualElement container) : base(container) {
+        }
+
+        public void BindChange (System.Action<string> callback) {
+            _container
+                .Q<TextField>("search-input__text")
+                .RegisterValueChangedCallback(evt => {
+                    callback(evt.newValue);
+                });
+        }
+    }
+}
diff --git a/Editor/Components/Molecules/SearchInput/SearchInput.cs.meta b/Editor/Components/Molecules/SearchInput/SearchInput.cs.meta
new file mode 100644
index 0000000..849931c
--- /dev/null
+++ b/Editor/Components/Molecules/SearchInput/SearchInput.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 9c1e019e610b4760b08103ddfb46c965
+timeCreated: 1687026948
\ No newline at end of file
diff --git a/Editor/Components/Molecules/SearchInput/SearchInput.uxml b/Editor/Components/Molecules/SearchInput/SearchInput.uxml
new file mode 100644
index 0000000..5530b73
--- /dev/null
+++ b/Editor/Components/Molecules/SearchInput/SearchInput.uxml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui:UXML xmlns:ui="UnityEngine.UIElements">
+    <ui:VisualElement name="search-input" class="search-input" style="flex-direction: row;">
+        <ui:Label text="Search" style="flex-grow: 0; color: grey;" name="placeholderLabel" />
+        <ui:TextField class="search-input__text" name="search-input__text" style="width: 100px" />
+    </ui:VisualElement>
+</ui:UXML>
+
+
diff --git a/Editor/Components/Molecules/SearchInput/SearchInput.uxml.meta b/Editor/Components/Molecules/SearchInput/SearchInput.uxml.meta
new file mode 100644
index 0000000..7d3a5b0
--- /dev/null
+++ b/Editor/Components/Molecules/SearchInput/SearchInput.uxml.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 3286c8d6a80c4136b7085788ed96667c
+timeCreated: 1687027033
\ No newline at end of file
diff --git a/Editor/Components/Organisms.meta b/Editor/Components/Organisms.meta
new file mode 100644
index 0000000..be38930
--- /dev/null
+++ b/Editor/Components/Organisms.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: f0de0154cb114d03a31b3ad92e70a2b6
+timeCreated: 1685139178
\ No newline at end of file
diff --git a/Editor/Components/Organisms/ItemEntry.meta b/Editor/Components/Organisms/ItemEntry.meta
new file mode 100644
index 0000000..0c4e93b
--- /dev/null
+++ b/Editor/Components/Organisms/ItemEntry.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: c8b9f1d5d48b4d53a28e6e9b15050dd7
+timeCreated: 1685139047
\ No newline at end of file
diff --git a/Editor/Components/Organisms/ItemEntry/ItemEntry.cs b/Editor/Components/Organisms/ItemEntry/ItemEntry.cs
new file mode 100644
index 0000000..e5df704
--- /dev/null
+++ b/Editor/Components/Organisms/ItemEntry/ItemEntry.cs
@@ -0,0 +1,34 @@
+using System;
+using UnityEditor;
+using UnityEditor.UIElements;
+using UnityEngine.UIElements;
+
+namespace CleverCrow.Fluid.ElasticInventory.Editors {
+    public class ItemEntry : ComponentBase {
+        public ItemEntry (
+            VisualElement container,
+            ItemDefinitionBase definition,
+            Action<ItemDefinitionBase> deleteCallback
+        ) : base(container) {
+            var title = _container.Q<Label>("item-entry__name");
+            title.text = definition.DisplayName;
+            title.bindingPath = "_displayName";
+            title.Bind(new SerializedObject(definition));
+
+            _container.Q<Button>("item-entry__edit").clicked += () => { Selection.activeObject = definition; };
+
+            _container.Q<Button>("item-entry__delete").clicked += () => {
+                var confirm = EditorUtility.DisplayDialog(
+                    "Delete Item Definition",
+                    $"Are you sure you want to delete {definition.DisplayName}?",
+                    "Delete",
+                    "Cancel"
+                );
+                if (!confirm) return;
+
+                _container.parent.Remove(_container);
+                deleteCallback(definition);
+            };
+        }
+    }
+}
diff --git a/Editor/Components/Organisms/ItemEntry/ItemEntry.cs.meta b/Editor/Components/Organisms/ItemEntry/ItemEntry.cs.meta
new file mode 100644
index 0000000..ba77bfc
--- /dev/null
+++ b/Editor/Components/Organisms/ItemEntry/ItemEntry.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 4448e16532274b9f9a7cbb00c422b006
+timeCreated: 1685139028
\ No newline at end of file
diff --git a/Editor/Components/Organisms/ItemEntry/ItemEntry.uss b/Editor/Components/Organisms/ItemEntry/ItemEntry.uss
new file mode 100644
index 0000000..4fbb867
--- /dev/null
+++ b/Editor/Components/Organisms/ItemEntry/ItemEntry.uss
@@ -0,0 +1,19 @@
+.item-entry {
+    display: flex;
+    flex-direction: row;
+    align-items: center;
+    justify-content: space-between;
+    padding: 5px;
+    border-bottom-color: #000;
+    border-bottom-width: 1px;
+}
+
+.item-entry__section {
+    flex-direction: row;
+    align-items: center;
+}
+
+.item-entry__image {
+    width: 20px;
+    height: 20px;
+}
diff --git a/Editor/Components/Organisms/ItemEntry/ItemEntry.uss.meta b/Editor/Components/Organisms/ItemEntry/ItemEntry.uss.meta
new file mode 100644
index 0000000..9d35358
--- /dev/null
+++ b/Editor/Components/Organisms/ItemEntry/ItemEntry.uss.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 57dff7cc95e74d00926f893b900fe427
+timeCreated: 1685139113
\ No newline at end of file
diff --git a/Editor/Components/Organisms/ItemEntry/ItemEntry.uxml b/Editor/Components/Organisms/ItemEntry/ItemEntry.uxml
new file mode 100644
index 0000000..c0d160c
--- /dev/null
+++ b/Editor/Components/Organisms/ItemEntry/ItemEntry.uxml
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui:UXML xmlns:ui="UnityEngine.UIElements">
+    <Style src="./ItemEntry.uss" />
+
+    <ui:VisualElement name="item-entry" class="item-entry">
+        <ui:VisualElement class="item-entry__section">
+            <ui:Label name="item-entry__name" text="Item Name" />
+        </ui:VisualElement>
+
+        <ui:VisualElement class="item-entry__section">
+            <ui:Button name="item-entry__edit" text="Edit" />
+            <ui:Button name="item-entry__delete" text="Delete" />
+        </ui:VisualElement>
+    </ui:VisualElement>
+</ui:UXML>
diff --git a/Editor/Components/Organisms/ItemEntry/ItemEntry.uxml.meta b/Editor/Components/Organisms/ItemEntry/ItemEntry.uxml.meta
new file mode 100644
index 0000000..57a1a2d
--- /dev/null
+++ b/Editor/Components/Organisms/ItemEntry/ItemEntry.uxml.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 08ab31e3fb5343f88743b1c0e1a0f9ff
+timeCreated: 1685139064
\ No newline at end of file
diff --git a/Editor/Components/Pages.meta b/Editor/Components/Pages.meta
new file mode 100644
index 0000000..862fd9c
--- /dev/null
+++ b/Editor/Components/Pages.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 68ee094e7b1643b5ad3339a27a2e4ad8
+timeCreated: 1684875269
\ No newline at end of file
diff --git a/Editor/Components/Pages/PageItemDatabase.cs b/Editor/Components/Pages/PageItemDatabase.cs
new file mode 100644
index 0000000..cd5f8dd
--- /dev/null
+++ b/Editor/Components/Pages/PageItemDatabase.cs
@@ -0,0 +1,187 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.UIElements;
+using Object = UnityEngine.Object;
+
+namespace CleverCrow.Fluid.ElasticInventory.Editors {
+    public class PageItemDatabase : ComponentBase {
+        readonly ItemDatabase _database;
+        string _category;
+        string _search;
+        readonly VisualElement _containerParent;
+
+        public PageItemDatabase (VisualElement container, ItemDatabase database) : base(container) {
+            _database = database;
+            _containerParent = container;
+
+            CreateHeader(container, database);
+            PrintItems();
+        }
+
+        void PrintItems () {
+            ClearItems();
+
+            var definitions = _database._definitions.ToList();
+
+            // Make sure the definitions are sorted in reverse so the newest items are first
+            definitions.Reverse();
+
+            definitions.ForEach(item => {
+                if (_category != null && item.Category != _category) return;
+
+                if (_search != null && !item.DisplayName.Replace(" ", "").ToLower().Contains(_search)) {
+                    return;
+                }
+
+                AddItemElement(item);
+            });
+        }
+
+        void CreateHeader (VisualElement container, ItemDatabase database) {
+            container.Q<Label>("title").text = database.name;
+
+            // Create SearchInput
+            var searchInput = new SearchInput(container.Q<VisualElement>("search"));
+            searchInput.BindChange(search => {
+                _search = string.IsNullOrEmpty(search) ? null : search.ToLower();
+                PrintItems();
+            });
+
+            // Create dropdown add
+            var displayNameToClass = GetDefinitionDisplayNameToClass();
+            var dropdownAdd = new DropdownAdd<Type>(container.Q<VisualElement>("add"), "Add", displayNameToClass);
+            dropdownAdd.BindClick(type => { CreateItemDefinition(database, type); });
+
+            SyncCategories();
+        }
+
+        static List<KeyValuePair<string, Type>> GetDefinitionDisplayNameToClass () {
+            var allAssemblies = AppDomain.CurrentDomain.GetAssemblies();
+
+            var keyToType = new List<KeyValuePair<string, Type>>();
+            foreach (var assembly in allAssemblies) {
+                keyToType.AddRange(assembly.GetTypes()
+                    .Where(type => type.GetCustomAttribute<ItemDefinitionDetailsAttribute>() != null)
+                    .Select(type => new KeyValuePair<string, Type>(
+                        type.GetCustomAttribute<ItemDefinitionDetailsAttribute>().DisplayName,
+                        type
+                    )));
+            }
+
+            return keyToType;
+        }
+
+        void CreateItemDefinition (ItemDatabase database, Type type) {
+            if (type == null) {
+                return;
+            }
+
+            var projectWindowPath = GetSelectedFolderPath();
+            var path = EditorUtility.SaveFilePanelInProject(
+                "Create Item Definition",
+                "ItemDefinition",
+                "asset",
+                "Enter a file name for your item",
+                projectWindowPath
+            );
+
+            if (string.IsNullOrEmpty(path)) return;
+
+            var itemDefinition = ScriptableObject.CreateInstance(type);
+
+            var serializedObject = new SerializedObject(itemDefinition);
+            var fileName = System.IO.Path.GetFileNameWithoutExtension(path);
+            serializedObject.FindProperty("_displayName").stringValue = MakeSpacedWord(fileName);
+            // @TODO Duplicate IDs are inevitable due to object cloning, repair them automatically when refreshing asset references
+            serializedObject.FindProperty("_id").stringValue = Guid.NewGuid().ToString();
+            serializedObject.ApplyModifiedPropertiesWithoutUndo();
+
+            AssetDatabase.CreateAsset(itemDefinition, path);
+            database._definitions.Insert(0, itemDefinition as ItemDefinitionBase);
+            EditorUtility.SetDirty(database);
+            AssetDatabase.SaveAssets();
+            AssetDatabase.Refresh();
+
+            AddItemElement(itemDefinition as ItemDefinitionBase);
+            Selection.activeObject = itemDefinition;
+        }
+
+        private void ClearItems () {
+            var table = _container.Q<VisualElement>("table");
+            table.Clear();
+        }
+
+        private void AddItemElement (ItemDefinitionBase itemDefinition) {
+            var table = _container.Q<VisualElement>("table");
+            var item = new ItemEntry(table, itemDefinition, DeleteItemFromDatabase);
+
+            // move the item to be the first child so users don't have to hunt for it at the bottom
+            table.Remove(item.Container);
+            table.Insert(0, item.Container);
+        }
+
+        private void DeleteItemFromDatabase (ItemDefinitionBase itemDefinition) {
+            _database._definitions.Remove(itemDefinition);
+            EditorUtility.SetDirty(_database);
+
+            var path = AssetDatabase.GetAssetPath(itemDefinition);
+            AssetDatabase.DeleteAsset(path);
+
+            AssetDatabase.SaveAssets();
+            AssetDatabase.Refresh();
+        }
+
+        private static string GetSelectedFolderPath () {
+            var selectedObjects = Selection.GetFiltered(typeof(Object), SelectionMode.Assets);
+
+            if (selectedObjects.Length <= 0) return "Assets";
+            var selectedPath = AssetDatabase.GetAssetPath(selectedObjects[0]);
+
+            if (!string.IsNullOrEmpty(selectedPath) && System.IO.Directory.Exists(selectedPath)) {
+                return selectedPath;
+            }
+
+            return "Assets";
+        }
+
+        private string MakeSpacedWord (string word) {
+            var spacedWord = string.Empty;
+
+            for (var i = 0; i < word.Length; i++) {
+                if (i > 0 && char.IsUpper(word[i])) {
+                    spacedWord += " ";
+                }
+
+                spacedWord += word[i];
+            }
+
+            return spacedWord;
+        }
+
+        public void SyncCategories () {
+            _containerParent.Q<VisualElement>("category").Clear();
+
+            var dropdownCategory = new DropdownAdd<int>(
+                _containerParent.Q<VisualElement>("category"),
+                "Category",
+                _database.Categories.Select((category, index) => new KeyValuePair<string, int>(category, index + 1)).ToList(),
+                resetOnInteract: false
+            );
+
+            if (_category != null) {
+                dropdownCategory.SetValue(_database.Categories.IndexOf(_category));
+            }
+
+            dropdownCategory.BindClick(category => {
+                if (category == 0) _category = null;
+                else _category = _database.Categories[category - 1];
+
+                PrintItems();
+            });
+        }
+    }
+}
diff --git a/Editor/Components/Pages/PageItemDatabase.cs.meta b/Editor/Components/Pages/PageItemDatabase.cs.meta
new file mode 100644
index 0000000..a13ca7d
--- /dev/null
+++ b/Editor/Components/Pages/PageItemDatabase.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 7e57a7ee5b7742c98398ec4154ea8cf5
+timeCreated: 1684875309
\ No newline at end of file
diff --git a/Editor/Components/Pages/PageItemDatabase.uss b/Editor/Components/Pages/PageItemDatabase.uss
new file mode 100644
index 0000000..acd0328
--- /dev/null
+++ b/Editor/Components/Pages/PageItemDatabase.uss
@@ -0,0 +1,18 @@
+.toolbar {
+    flex-direction: row;
+    align-items: center;
+    padding: 5px;
+}
+
+.toolbar__title {
+    flex-grow: 1;
+    font-size: 20px;
+}
+
+.toolbar__search {
+    width: 100px;
+}
+
+.table {
+    padding: 5px;
+}
diff --git a/Editor/Components/Pages/PageItemDatabase.uss.meta b/Editor/Components/Pages/PageItemDatabase.uss.meta
new file mode 100644
index 0000000..5c3e3d1
--- /dev/null
+++ b/Editor/Components/Pages/PageItemDatabase.uss.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 3794f16ceb6445b582230ac3d3094757
+timeCreated: 1684875546
\ No newline at end of file
diff --git a/Editor/Components/Pages/PageItemDatabase.uxml b/Editor/Components/Pages/PageItemDatabase.uxml
new file mode 100644
index 0000000..fbc3f39
--- /dev/null
+++ b/Editor/Components/Pages/PageItemDatabase.uxml
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui:UXML xmlns:ui="UnityEngine.UIElements">
+    <Style src="./PageItemDatabase.uss" />
+
+    <ui:VisualElement class="toolbar">
+        <ui:Label name="title" class="toolbar__title" text="Lorem Ipsum" />
+        <ui:VisualElement name="search" />
+        <ui:VisualElement name="add" />
+        <ui:VisualElement name="category" />
+    </ui:VisualElement>
+
+    <ui:ScrollView>
+        <ui:VisualElement class="table" name="table" />
+    </ui:ScrollView>
+</ui:UXML>
diff --git a/Editor/Components/Pages/PageItemDatabase.uxml.meta b/Editor/Components/Pages/PageItemDatabase.uxml.meta
new file mode 100644
index 0000000..5f50219
--- /dev/null
+++ b/Editor/Components/Pages/PageItemDatabase.uxml.meta
@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 9cbe9a1cac9ea4a3687dd516e94c358c
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 13804, guid: 0000000000000000e000000000000000, type: 0}
diff --git a/Editor/Scripts.meta b/Editor/Scripts.meta
new file mode 100644
index 0000000..81c2d27
--- /dev/null
+++ b/Editor/Scripts.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 227f9e210c9c4968a2e410f2a04e3d13
+timeCreated: 1686099343
\ No newline at end of file
diff --git a/Editor/Scripts/ConfigWizard.cs b/Editor/Scripts/ConfigWizard.cs
new file mode 100644
index 0000000..020a1ae
--- /dev/null
+++ b/Editor/Scripts/ConfigWizard.cs
@@ -0,0 +1,84 @@
+using System.IO;
+using UnityEditor;
+using UnityEngine;
+
+namespace CleverCrow.Fluid.ElasticInventory.Editors {
+    public static class ConfigWizard {
+        [InitializeOnLoadMethod]
+        private static void CreateInitialDatabase () {
+            if (HasDatabase()) return;
+
+            var inventoryPath = "Assets/ElasticInventory";
+            var resourcesPath = $"{inventoryPath}/Resources";
+
+            if (!EditorUtility.DisplayDialog("Create Item Database",
+                    $"Your project is missing an Item Database. Would you like to run the wizard? This will setup your project at {inventoryPath} with everything needed to run. This is required for Elastic Inventory to work.",
+                    "Yes",
+                    "No")) {
+                return;
+            }
+
+            // Create an inventory folder if one doesn't exist
+            if (!AssetDatabase.IsValidFolder(inventoryPath)) {
+                AssetDatabase.CreateFolder("Assets", "ElasticInventory");
+            }
+
+            // Create a resources folder if one doesn't exist
+            if (!AssetDatabase.IsValidFolder(resourcesPath)) {
+                AssetDatabase.CreateFolder(inventoryPath, "Resources");
+            }
+
+            // Create the database
+            var path = $"{resourcesPath}/ItemDatabase.asset";
+            var asset = ScriptableObject.CreateInstance<ItemDatabase>();
+            AssetDatabase.CreateAsset(asset, path);
+            CreateFirstItemScript(inventoryPath);
+            AssetDatabase.SaveAssets();
+            AssetDatabase.Refresh();
+
+            // Show an alert to the user that the database was created
+            EditorUtility.DisplayDialog("Item Database Created",
+                $"An Item Database was created at {resourcesPath}/ItemDatabase. You can edit this database by selecting it in the Project window and clicking the Edit button in the inspector. Please note that this file must be in a resources folder and keep the same name.\n\nWe've also added a start sample item script for you. We recommend reviewing ItemDefinition before you start adding new definitions to your database.",
+                "OK");
+        }
+
+        private static bool HasDatabase() {
+            // @NOTE This does not work on a newly cloned project, as the asset database has not been built yet on initial load
+            var database = AssetDatabase.FindAssets("t:ItemDatabase");
+            if (database.Length > 0) return true;
+
+            // Do a hard file search for the database. Resource intensive but will only happen on initial load after cloning a project
+            // @TODO Optimize for larger projects. Should exit after finding the first file. Tricky with potential symlinks
+            var files = Directory.GetFiles(Application.dataPath, "ItemDatabase.asset", SearchOption.AllDirectories);
+            return files.Length > 0;
+        }
+
+        private static void CreateFirstItemScript(string path) {
+            path = Path.Combine(path, "ItemDefinition.cs");
+            string scriptContents = @"using UnityEngine;
+using CleverCrow.Fluid.ElasticInventory;
+
+// This is a sample item definition. You can create as many of these as you want and edit them as you see fit.
+// For customization details please visit the docs at https://github.com/ashblue/unity-elastic-inventory
+
+// @IMPORTANT You may want to add a namespace here before creating definitions to avoid potential naming conflicts
+// that could break your item definitions long term.
+
+[ItemDefinitionDetails(""Generic"")]
+public class ItemDefinition : ItemDefinitionBase {
+    [InventoryCategory]
+    [SerializeField]
+    int _category;
+
+    // You can hard set a category name here instead if you don't want it to be selectable in the inspector
+    public override string Category => GetCategoryByIndex(_category);
+}
+";
+
+            File.WriteAllText(path, scriptContents);
+
+            AssetDatabase.ImportAsset(path);
+            AssetDatabase.Refresh();
+        }
+    }
+}
diff --git a/Editor/Scripts/ConfigWizard.cs.meta b/Editor/Scripts/ConfigWizard.cs.meta
new file mode 100644
index 0000000..957de43
--- /dev/null
+++ b/Editor/Scripts/ConfigWizard.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 2a62fb429c56449f8fbf27773b97fddd
+timeCreated: 1688241350
\ No newline at end of file
diff --git a/Editor/Scripts/InventoryCategoryDrawer.cs b/Editor/Scripts/InventoryCategoryDrawer.cs
new file mode 100644
index 0000000..16fdc34
--- /dev/null
+++ b/Editor/Scripts/InventoryCategoryDrawer.cs
@@ -0,0 +1,29 @@
+using System;
+using UnityEditor;
+using UnityEngine;
+
+namespace CleverCrow.Fluid.ElasticInventory.Editors {
+    [CustomPropertyDrawer(typeof(InventoryCategory))]
+    public class InventoryCategoryDrawer : PropertyDrawer {
+        string[] _options {
+            get {
+                var database = Resources.Load<ItemDatabase>("ItemDatabase");
+                if (database == null) {
+                    Debug.LogWarning("Could not find ItemDatabase. Please create one at `Resources/ItemDatabase'.");
+                    return Array.Empty<string>();
+                }
+
+                return database.Categories.ToArray();
+            }
+        }
+
+        public override void OnGUI (Rect position, SerializedProperty property, GUIContent label) {
+            EditorGUI.BeginProperty(position, label, property);
+
+            position = EditorGUI.PrefixLabel(position, GUIUtility.GetControlID(FocusType.Passive), label);
+            property.intValue = EditorGUI.Popup(position, property.intValue, _options);
+
+            EditorGUI.EndProperty();
+        }
+    }
+}
diff --git a/Editor/Scripts/InventoryCategoryDrawer.cs.meta b/Editor/Scripts/InventoryCategoryDrawer.cs.meta
new file mode 100644
index 0000000..66cc512
--- /dev/null
+++ b/Editor/Scripts/InventoryCategoryDrawer.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: c9bad8a5d5bd4a3995571d9fc13a6363
+timeCreated: 1686883768
\ No newline at end of file
diff --git a/Editor/Scripts/InventoryHelperEditor.cs b/Editor/Scripts/InventoryHelperEditor.cs
new file mode 100644
index 0000000..11275d2
--- /dev/null
+++ b/Editor/Scripts/InventoryHelperEditor.cs
@@ -0,0 +1,23 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace CleverCrow.Fluid.ElasticInventory.Editors {
+    [CustomEditor(typeof(InventoryHelper))]
+    public class InventoryHelperEditor : Editor {
+        public override void OnInspectorGUI () {
+            DrawDefaultInspector();
+
+            if (!Application.isPlaying) return;
+            var inventoryHelper = (InventoryHelper)target;
+            if (inventoryHelper.Instance == null) return;
+
+            var allItems = inventoryHelper.Instance.GetAll();
+            EditorGUILayout.LabelField("Current Inventory:");
+
+            foreach (var item in allItems) {
+                var quantity = item.Quantity > 1 ? item.Quantity + " " : "";
+                EditorGUILayout.LabelField($"- {quantity}{item.Definition.DisplayName}");
+            }
+        }
+    }
+}
diff --git a/Editor/Scripts/InventoryHelperEditor.cs.meta b/Editor/Scripts/InventoryHelperEditor.cs.meta
new file mode 100644
index 0000000..f10a79b
--- /dev/null
+++ b/Editor/Scripts/InventoryHelperEditor.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 42a21997d71d493da051e9b6b9eacd9c
+timeCreated: 1686099383
\ No newline at end of file
diff --git a/Editor/Scripts/ItemDatabase.meta b/Editor/Scripts/ItemDatabase.meta
new file mode 100644
index 0000000..d18c983
--- /dev/null
+++ b/Editor/Scripts/ItemDatabase.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: f20b5850c65e4f148b02e123f873da01
+timeCreated: 1684799486
\ No newline at end of file
diff --git a/Editor/Scripts/ItemDatabase/ItemDatabaseEditor.cs b/Editor/Scripts/ItemDatabase/ItemDatabaseEditor.cs
new file mode 100644
index 0000000..f2dc5f2
--- /dev/null
+++ b/Editor/Scripts/ItemDatabase/ItemDatabaseEditor.cs
@@ -0,0 +1,85 @@
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+
+namespace CleverCrow.Fluid.ElasticInventory.Editors {
+    [CustomEditor(typeof(ItemDatabase))]
+    public class ItemDatabaseEditor : Editor {
+        public override void OnInspectorGUI () {
+            base.OnInspectorGUI();
+
+            EditorGUILayout.Space();
+            var database = target as ItemDatabase;
+
+            if (GUILayout.Button("Edit Database")) {
+                ItemDatabaseWindow.ShowWindow(database);
+            }
+
+            if (GUILayout.Button("Sync")) {
+                var assets = AssetDatabase.FindAssets("t:ItemDefinitionBase");
+
+                database._definitions.Clear();
+                foreach (var asset in assets) {
+                    var path = AssetDatabase.GUIDToAssetPath(asset);
+                    var definition = AssetDatabase.LoadAssetAtPath<ItemDefinitionBase>(path);
+                    database._definitions.Add(definition);
+                }
+
+                EditorUtility.SetDirty(database);
+                AssetDatabase.SaveAssets();
+                ItemDatabaseWindow.ShowWindow(database);
+
+                ItemDatabaseWindow.Dirty = true;
+            }
+
+            if (GUILayout.Button("Repair IDs")) {
+                FixDuplicateItemIds();
+            }
+        }
+
+        private void FixDuplicateItemIds () {
+            if (!EditorUtility.DisplayDialog(
+                    "Confirm Fix IDs",
+                    "Are you sure you want to fix duplicate item definition IDs? This will randomize the ID of any duplicates found and print the details to the console. This may affect save data as these IDs are used to restore inventory saves. It is highly recommended you backup your project before proceeding.",
+                    "Yes",
+                    "Cancel"
+                )) return;
+
+            var count = 0;
+            Debug.Log("BEGIN: Fixing duplicate item definition IDs.");
+
+            var ids = new HashSet<string>();
+            var itemDefinitions = AssetDatabase.FindAssets("t:ItemDefinitionBase");
+            foreach (var itemDefinition in itemDefinitions) {
+                var path = AssetDatabase.GUIDToAssetPath(itemDefinition);
+                var definition = AssetDatabase.LoadAssetAtPath<ItemDefinitionBase>(path);
+
+                if (ids.Contains(definition.Id)) {
+                    var newId = System.Guid.NewGuid().ToString();
+                    Debug.LogWarning($"Duplicate ID {definition.Id} in {path}. Randomizing the ID to {newId}.");
+
+                    var so = new SerializedObject(definition);
+                    var idField = so.FindProperty("_id");
+                    idField.stringValue = newId;
+
+                    so.ApplyModifiedProperties();
+                    EditorUtility.SetDirty(definition);
+
+                    count++;
+                } else {
+                    ids.Add(definition.Id);
+                }
+            }
+
+            if (count > 0) {
+                Debug.Log($"Fixed {count} duplicate item definition ID(s).");
+                ItemDatabaseWindow.Dirty = true;
+            } else {
+                Debug.Log("No duplicate item definition IDs found. Nothing to fix.");
+            }
+
+            Debug.Log("END: Fixing duplicate item definition IDs.");
+        }
+    }
+}
+
diff --git a/Editor/Scripts/ItemDatabase/ItemDatabaseEditor.cs.meta b/Editor/Scripts/ItemDatabase/ItemDatabaseEditor.cs.meta
new file mode 100644
index 0000000..45508a8
--- /dev/null
+++ b/Editor/Scripts/ItemDatabase/ItemDatabaseEditor.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 2dc9bfe7921e476cab7b3a40dd2dee35
+timeCreated: 1684799860
\ No newline at end of file
diff --git a/Editor/Scripts/ItemDatabase/ItemDatabaseWindow.cs b/Editor/Scripts/ItemDatabase/ItemDatabaseWindow.cs
new file mode 100644
index 0000000..bbd5845
--- /dev/null
+++ b/Editor/Scripts/ItemDatabase/ItemDatabaseWindow.cs
@@ -0,0 +1,56 @@
+using UnityEditor;
+
+namespace CleverCrow.Fluid.ElasticInventory.Editors {
+    public class ItemDatabaseWindow : EditorWindow {
+        static ItemDatabase _database;
+        static PageItemDatabase _page;
+        const string _databasePathKey = "ElasticInventoryPath";
+
+        public static bool Dirty { get; set; }
+
+        public static void ShowWindow (ItemDatabase database) {
+            _database = database;
+            var assetPath = AssetDatabase.GetAssetPath(database);
+            EditorPrefs.SetString(_databasePathKey, assetPath);
+
+            GetWindow<ItemDatabaseWindow>("Item Database");
+        }
+
+        private void OnEnable () {
+            var assetPath = EditorPrefs.GetString(_databasePathKey);
+            if (!string.IsNullOrEmpty(assetPath)) {
+                _database = AssetDatabase.LoadAssetAtPath<ItemDatabase>(assetPath);
+            }
+
+            RefreshWindow();
+        }
+
+        void OnFocus () {
+            // If the window is marked dirty rebuild it
+            if (Dirty) {
+                RefreshWindow(true);
+                Dirty = false;
+            }
+
+            // If the user edits the categories while displaying the window they get out of sync
+            // This makes sure that cannot happen
+            _page?.SyncCategories();
+        }
+
+        private void RefreshWindow (bool clear = false) {
+            var root = rootVisualElement;
+
+            // In some edge cases the database may go null
+            if (_database == null) {
+                return;
+            }
+
+            if (clear) {
+                root.Clear();
+                _page = null;
+            }
+
+            _page = new PageItemDatabase(root, _database);
+        }
+    }
+}
diff --git a/Editor/Scripts/ItemDatabase/ItemDatabaseWindow.cs.meta b/Editor/Scripts/ItemDatabase/ItemDatabaseWindow.cs.meta
new file mode 100644
index 0000000..62c9559
--- /dev/null
+++ b/Editor/Scripts/ItemDatabase/ItemDatabaseWindow.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 6ea46a866681496696525fe7edaacee0
+timeCreated: 1684799497
\ No newline at end of file
diff --git a/Editor/TinFoil.meta b/Editor/TinFoil.meta
new file mode 100644
index 0000000..be5eafc
--- /dev/null
+++ b/Editor/TinFoil.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 2897d73c5c7b4b14a4f67931115d5d2e
+timeCreated: 1684887520
\ No newline at end of file
diff --git a/Editor/TinFoil/AssetPath.cs b/Editor/TinFoil/AssetPath.cs
new file mode 100644
index 0000000..39f5fb0
--- /dev/null
+++ b/Editor/TinFoil/AssetPath.cs
@@ -0,0 +1,28 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace CleverCrow.Fluid.ElasticInventory.Editors {
+    public class AssetPath {
+        private static string _basePath;
+
+        public static string BasePath {
+            get {
+                if (_basePath != null) return _basePath;
+
+                if (AssetDatabase.IsValidFolder($"Assets/{UxmlConfig.PATH_ROOT}")) {
+                    _basePath = "Assets/";
+                    return _basePath;
+                }
+
+                if (AssetDatabase.IsValidFolder($"Packages/{UxmlConfig.PATH_ROOT}")) {
+                    _basePath = "Packages/";
+                    return _basePath;
+                }
+
+                Debug.LogError("Asset root could not be found");
+
+                return null;
+            }
+        }
+    }
+}
diff --git a/Editor/TinFoil/AssetPath.cs.meta b/Editor/TinFoil/AssetPath.cs.meta
new file mode 100644
index 0000000..f03fe5d
--- /dev/null
+++ b/Editor/TinFoil/AssetPath.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 2beec108b65146698746fb754dd775cb
+timeCreated: 1684875383
\ No newline at end of file
diff --git a/Editor/TinFoil/ComponentBase.cs b/Editor/TinFoil/ComponentBase.cs
new file mode 100644
index 0000000..a41bd1a
--- /dev/null
+++ b/Editor/TinFoil/ComponentBase.cs
@@ -0,0 +1,36 @@
+using System;
+using UnityEditor;
+using UnityEngine.UIElements;
+
+namespace CleverCrow.Fluid.ElasticInventory.Editors {
+    public abstract class ComponentBase {
+        private readonly string _path;
+        protected readonly VisualElement _container;
+
+        public VisualElement Container => _container;
+
+        protected ComponentBase (VisualElement containerParent) {
+            if (_path == null) {
+                var stackTrace = new System.Diagnostics.StackTrace(true);
+                var frame = stackTrace.GetFrame(1);
+                var path = frame.GetFileName()?.Replace("\\", "/");
+
+                if (path.Contains("/PackageCache/")) {
+                    var parts = path.Split(new[] { UxmlConfig.PACKAGE_CACHE_EDITOR_ROOT }, StringSplitOptions.None);
+                    _path = $"{AssetPath.BasePath}{UxmlConfig.PATH_ROOT}{UxmlConfig.PACKAGE_CACHE_EDITOR_ROOT}{parts[1]}"
+                        .Replace(".cs", ".uxml");
+                } else {
+                    var strings = path.Split(new[] { "/Assets/" }, StringSplitOptions.None);
+                    _path = $"{AssetPath.BasePath}/{strings[1]}"
+                        .Replace(".cs", ".uxml");
+                }
+            }
+
+            var markup = AssetDatabase.LoadAssetAtPath<VisualTreeAsset>(_path);
+            if (markup != null) {
+                markup.CloneTree(containerParent);
+                _container = containerParent[containerParent.childCount - 1];
+            }
+        }
+    }
+}
diff --git a/Editor/TinFoil/ComponentBase.cs.meta b/Editor/TinFoil/ComponentBase.cs.meta
new file mode 100644
index 0000000..53c5087
--- /dev/null
+++ b/Editor/TinFoil/ComponentBase.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 8bc14292b90c4625b6a48098ca034e46
+timeCreated: 1684875218
\ No newline at end of file
diff --git a/Editor/TinFoil/README.md b/Editor/TinFoil/README.md
new file mode 100644
index 0000000..be6b93d
--- /dev/null
+++ b/Editor/TinFoil/README.md
@@ -0,0 +1,3 @@
+# Tin Foil - A Unity3D UXML Component Micro Framework
+
+Tin Foil is a micro framework for Unity3D's UXML system. It provides a simple way to create and manage UXML components and their associated USS stylesheets.
diff --git a/Editor/TinFoil/README.md.meta b/Editor/TinFoil/README.md.meta
new file mode 100644
index 0000000..96fc7d9
--- /dev/null
+++ b/Editor/TinFoil/README.md.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 8bf4db22cfbc4d76b2a5004cba5c1838
+timeCreated: 1684887535
\ No newline at end of file
diff --git a/Editor/TinFoil/UxmlConfig.cs b/Editor/TinFoil/UxmlConfig.cs
new file mode 100644
index 0000000..bd60db2
--- /dev/null
+++ b/Editor/TinFoil/UxmlConfig.cs
@@ -0,0 +1,16 @@
+namespace CleverCrow.Fluid.ElasticInventory.Editors {
+    // @TODO Long term this should be a globally accessible overridable file
+    // that drives a micro-framework for UXML components
+    public static class UxmlConfig {
+        /// <summary>
+        /// Where your UXML files are located after the Assets/ folder
+        /// </summary>
+        public static string PATH_ROOT = "com.fluid.elastic-inventory";
+
+        /// <summary>
+        /// Declare where editor code is stored in the package cache (for loading UXML files from a package)
+        /// Value must at least be "/" to be valid
+        /// </summary>
+        public static string PACKAGE_CACHE_EDITOR_ROOT = "/Editor/";
+    }
+}
diff --git a/Editor/TinFoil/UxmlConfig.cs.meta b/Editor/TinFoil/UxmlConfig.cs.meta
new file mode 100644
index 0000000..614e779
--- /dev/null
+++ b/Editor/TinFoil/UxmlConfig.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: e6ee4efca0c44205a3ff4a3fa62c0bec
+timeCreated: 1684887233
\ No newline at end of file
diff --git a/Editor/com.fluid.elastic-inventory.Editor.asmdef b/Editor/com.fluid.elastic-inventory.Editor.asmdef
new file mode 100755
index 0000000..d9b34e7
--- /dev/null
+++ b/Editor/com.fluid.elastic-inventory.Editor.asmdef
@@ -0,0 +1,19 @@
+{
+    "name": "com.fluid.elastic-inventory.Editor",
+    "rootNamespace": "",
+    "references": [
+        "com.fluid.elastic-inventory",
+        "com.fluid.simple-settings"
+    ],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}
\ No newline at end of file
diff --git a/Editor/com.fluid.elastic-inventory.Editor.asmdef.meta b/Editor/com.fluid.elastic-inventory.Editor.asmdef.meta
new file mode 100644
index 0000000..f911da1
--- /dev/null
+++ b/Editor/com.fluid.elastic-inventory.Editor.asmdef.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 5cb9806ba7fe14d0a8c075c9bc94f1df
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/LICENSE.md b/LICENSE.md
new file mode 100755
index 0000000..08ccd1a
--- /dev/null
+++ b/LICENSE.md
@@ -0,0 +1 @@
+Edit LICENSE.md in root, contents will be replaced.
diff --git a/LICENSE.md.meta b/LICENSE.md.meta
new file mode 100644
index 0000000..745c9c6
--- /dev/null
+++ b/LICENSE.md.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 7ebdae09fa98241cdbc11ecddd5d8d5a
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/README.md b/README.md
new file mode 100755
index 0000000..2f05ff9
--- /dev/null
+++ b/README.md
@@ -0,0 +1 @@
+Edit README.md in root, contents will be replaced.
diff --git a/README.md.meta b/README.md.meta
new file mode 100644
index 0000000..4d7239b
--- /dev/null
+++ b/README.md.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 1d8415efa2169491d85401dd8209c6e4
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Runtime.meta b/Runtime.meta
new file mode 100644
index 0000000..1219a21
--- /dev/null
+++ b/Runtime.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 390a366d13e18441face4c35f8fc1ac7
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Runtime/Attributes.meta b/Runtime/Attributes.meta
new file mode 100644
index 0000000..28d88fb
--- /dev/null
+++ b/Runtime/Attributes.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 8ec18ff6e63544c6b6ef1102a313ae59
+timeCreated: 1686883498
\ No newline at end of file
diff --git a/Runtime/Attributes/InventoryCategory.cs b/Runtime/Attributes/InventoryCategory.cs
new file mode 100644
index 0000000..645d3b4
--- /dev/null
+++ b/Runtime/Attributes/InventoryCategory.cs
@@ -0,0 +1,6 @@
+using UnityEngine;
+
+namespace CleverCrow.Fluid.ElasticInventory {
+    public class InventoryCategory : PropertyAttribute {
+    }
+}
diff --git a/Runtime/Attributes/InventoryCategory.cs.meta b/Runtime/Attributes/InventoryCategory.cs.meta
new file mode 100644
index 0000000..f5674a4
--- /dev/null
+++ b/Runtime/Attributes/InventoryCategory.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 9d207915c4984666b86f2563f698f889
+timeCreated: 1686883693
\ No newline at end of file
diff --git a/Runtime/Attributes/ItemDefinitionDetailsAttribute.cs b/Runtime/Attributes/ItemDefinitionDetailsAttribute.cs
new file mode 100644
index 0000000..ea0a1af
--- /dev/null
+++ b/Runtime/Attributes/ItemDefinitionDetailsAttribute.cs
@@ -0,0 +1,12 @@
+using System;
+
+namespace CleverCrow.Fluid.ElasticInventory {
+    [AttributeUsage(AttributeTargets.Class)]
+    public class ItemDefinitionDetailsAttribute : Attribute {
+        public string DisplayName { get; private set; }
+
+        public ItemDefinitionDetailsAttribute (string displayName) {
+            DisplayName = displayName;
+        }
+    }
+}
diff --git a/Runtime/Attributes/ItemDefinitionDetailsAttribute.cs.meta b/Runtime/Attributes/ItemDefinitionDetailsAttribute.cs.meta
new file mode 100644
index 0000000..2fe73ed
--- /dev/null
+++ b/Runtime/Attributes/ItemDefinitionDetailsAttribute.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 0c24d19c2ab9474999149148409a3295
+timeCreated: 1685128962
\ No newline at end of file
diff --git a/Runtime/Databases.meta b/Runtime/Databases.meta
new file mode 100644
index 0000000..f27a080
--- /dev/null
+++ b/Runtime/Databases.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 14809139ac2749aa9ca4d969d0125924
+timeCreated: 1684789787
\ No newline at end of file
diff --git a/Runtime/Databases/IItemDatabase.cs b/Runtime/Databases/IItemDatabase.cs
new file mode 100644
index 0000000..d3acb6c
--- /dev/null
+++ b/Runtime/Databases/IItemDatabase.cs
@@ -0,0 +1,10 @@
+using System.Collections.Generic;
+
+namespace CleverCrow.Fluid.ElasticInventory {
+    public interface IItemDatabase {
+        List<string> Categories { get; }
+
+        IItemDefinition Get (string id);
+        int GetUniqueIndex ();
+    }
+}
diff --git a/Runtime/Databases/IItemDatabase.cs.meta b/Runtime/Databases/IItemDatabase.cs.meta
new file mode 100644
index 0000000..24a8ea5
--- /dev/null
+++ b/Runtime/Databases/IItemDatabase.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b921af7a08d884b93b4163ef3eb7d1a8
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Runtime/Databases/ItemDatabase.cs b/Runtime/Databases/ItemDatabase.cs
new file mode 100644
index 0000000..e41b258
--- /dev/null
+++ b/Runtime/Databases/ItemDatabase.cs
@@ -0,0 +1,114 @@
+using System.Collections.Generic;
+using System.Linq;
+using CleverCrow.Fluid.Databases;
+using CleverCrow.Fluid.SimpleSettings;
+using UnityEngine;
+
+namespace CleverCrow.Fluid.ElasticInventory {
+    /// <summary>
+    /// The item database manages all of your item definitions. It's important to know that it needs to be saved
+    /// and loaded between sessions. This is because it generates unique IDs for each item definition. If you don't
+    /// items will get incorrect created at and modified at indices.
+    ///
+    /// Note that when initially called with ItemDatabase.Current, it will automatically generate a new instance at runtime
+    /// if one doesn't already exist
+    /// </summary>
+    [CreateAssetMenu(fileName = "ItemDatabase", menuName = "Elastic Inventory/Item Database")]
+    public class ItemDatabase : SettingsBase<ItemDatabase>, IItemDatabase {
+        ItemDatabaseInternal _internal;
+
+        [Tooltip("Automatically load save data from the global database manager at initial creation. Should only disable if you want to implement your own save and load system for items")]
+        [SerializeField]
+        bool _autoLoad = true;
+
+        [Tooltip("DO NOT edit this directly. Must be public for Unity serialization purposes")]
+        public List<ItemDefinitionBase> _definitions = new();
+
+        [Tooltip("Add new categories here. You can also use this to filter items in the inventory UI")]
+        [SerializeField]
+        List<string> _categories = new() {
+            "Default",
+        };
+
+        public List<string> Categories => _categories;
+
+        protected override void OnSetup () {
+            _internal = new ItemDatabaseInternal(_definitions.Cast<IItemDefinition>().ToList());
+            if (_autoLoad) Load();
+        }
+
+        public IItemDefinition Get (string id) {
+            return _internal.Get(id);
+        }
+
+        /// <summary>
+        /// Generates a unique index every time it's called incrementing by 1. This is used to generate new index IDs on the fly
+        /// </summary>
+        public int GetUniqueIndex () {
+            return _internal.GetUniqueIndex();
+        }
+
+        /// <summary>
+        /// Helper method to save to the global database manager
+        /// </summary>
+        public void Save () {
+            var save = SaveManual();
+            GlobalDatabaseManager.Instance.Database.Strings.Set("ItemDatabase", save);
+        }
+
+        /// <summary>
+        /// Save method so you can handle the save data however you want
+        /// </summary>
+        public string SaveManual () {
+            return _internal.Save();
+        }
+
+        /// <summary>
+        /// Helper method to load from the global database manager
+        /// </summary>
+        public void Load () {
+            var save = GlobalDatabaseManager.Instance.Database.Strings.Get("ItemDatabase");
+            if (save != null) LoadManual(save);
+        }
+
+        /// <summary>
+        /// Load method so you can inject save data manually
+        /// </summary>
+        public void LoadManual (string save) {
+            _internal.Load(save);
+        }
+    }
+
+
+    public class ItemDatabaseInternal {
+        readonly Dictionary<string, IItemDefinition> _idToDefinition;
+        int _idIndex;
+
+        public ItemDatabaseInternal (List<IItemDefinition> definitions) {
+            _idToDefinition = definitions.ToDictionary(d => d.Id);
+        }
+
+        public int GetUniqueIndex () {
+            var currentIndex = _idIndex;
+            _idIndex++;
+            return currentIndex;
+        }
+
+        public string Save () {
+            return JsonUtility.ToJson(new ItemDatabaseSaveData {
+                idIndex = _idIndex
+            });
+        }
+
+        public void Load (string save) {
+            var data = JsonUtility.FromJson<ItemDatabaseSaveData>(save);
+            _idIndex = data.idIndex;
+        }
+
+        public IItemDefinition Get (string id) {
+            if (!_idToDefinition.ContainsKey(id)) return null;
+
+            return _idToDefinition[id];
+        }
+    }
+}
diff --git a/Runtime/Databases/ItemDatabase.cs.meta b/Runtime/Databases/ItemDatabase.cs.meta
new file mode 100644
index 0000000..59e8b5a
--- /dev/null
+++ b/Runtime/Databases/ItemDatabase.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: a600bc502ed14cf5980ca274873f182a
+timeCreated: 1684798440
\ No newline at end of file
diff --git a/Runtime/Databases/ItemDatabaseSaveData.cs b/Runtime/Databases/ItemDatabaseSaveData.cs
new file mode 100644
index 0000000..0f87865
--- /dev/null
+++ b/Runtime/Databases/ItemDatabaseSaveData.cs
@@ -0,0 +1,5 @@
+namespace CleverCrow.Fluid.ElasticInventory {
+    public class ItemDatabaseSaveData {
+        public int idIndex;
+    }
+}
diff --git a/Runtime/Databases/ItemDatabaseSaveData.cs.meta b/Runtime/Databases/ItemDatabaseSaveData.cs.meta
new file mode 100644
index 0000000..1be4655
--- /dev/null
+++ b/Runtime/Databases/ItemDatabaseSaveData.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 7a324dfafe754a7bbb61b9dc96544d63
+timeCreated: 1688403290
\ No newline at end of file
diff --git a/Runtime/Inventory.meta b/Runtime/Inventory.meta
new file mode 100644
index 0000000..7987e8a
--- /dev/null
+++ b/Runtime/Inventory.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: b6403f78310ee4b43b5abc41a12030c8
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Runtime/Inventory/IInventoryInstance.cs b/Runtime/Inventory/IInventoryInstance.cs
new file mode 100644
index 0000000..04402e8
--- /dev/null
+++ b/Runtime/Inventory/IInventoryInstance.cs
@@ -0,0 +1,38 @@
+using System.Collections.Generic;
+
+namespace CleverCrow.Fluid.ElasticInventory {
+    public interface IInventoryInstance {
+        IInventoryEvents Events { get; }
+
+        IItemEntryReadOnly Get (IItemDefinition item);
+        IItemEntryReadOnly Get (string definitionId);
+        IItemEntryReadOnly GetEntry (string entryId);
+
+        List<IItemEntryReadOnly> GetAll (System.Type definitionType = null, string category = null);
+        List<T> GetAll<T> (System.Type definitionType = null, string category = null) where T : IItemEntryReadOnly;
+
+        IItemEntryReadOnly Add (IItemDefinition item, int quantity = 1);
+        IItemEntryReadOnly Add (string definitionId, int quantity = 1);
+        IItemEntryReadOnly AddEntry (IItemEntryReadOnly entry);
+
+        bool Has (IItemDefinition item, int quantity = 1);
+        bool Has (string definitionId, int quantity = 1);
+        bool HasEntry (string entryId, int quantity = 1);
+
+        void Remove (IItemDefinition item, int quantity = 1);
+        void Remove (string definitionId, int quantity = 1);
+        void RemoveEntry (string entryId, int quantity = 1);
+
+        void Sort (
+            List<IItemEntryReadOnly> items,
+            ItemSort sort = ItemSort.CreatedAt,
+            ItemOrder order = ItemOrder.Ascending,
+            ItemSort sortSecondary = ItemSort.Alphabetical,
+            ItemOrder orderSecondary = ItemOrder.Ascending,
+            List<CategorySort> customCategory = null
+        );
+
+        string Save ();
+        void Load (string save);
+    }
+}
diff --git a/Runtime/Inventory/IInventoryInstance.cs.meta b/Runtime/Inventory/IInventoryInstance.cs.meta
new file mode 100644
index 0000000..e34b22f
--- /dev/null
+++ b/Runtime/Inventory/IInventoryInstance.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 21272662324204e2b9277c3d5dfd9cf3
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Runtime/Inventory/InventoryEvents.cs b/Runtime/Inventory/InventoryEvents.cs
new file mode 100644
index 0000000..67eb14e
--- /dev/null
+++ b/Runtime/Inventory/InventoryEvents.cs
@@ -0,0 +1,15 @@
+using CleverCrow.Fluid.Utilities.UnityEvents;
+
+namespace CleverCrow.Fluid.ElasticInventory {
+    public interface IInventoryEvents {
+        IUnityEvent<IItemEntryReadOnly> ItemAdded { get; }
+        IUnityEvent<IItemEntryReadOnly> ItemRemoved { get; }
+        IUnityEvent<IItemEntryReadOnly> ItemChanged { get; }
+    }
+
+    public class InventoryEvents : IInventoryEvents {
+        public IUnityEvent<IItemEntryReadOnly> ItemAdded { get; } = new UnityEventPlus<IItemEntryReadOnly>();
+        public IUnityEvent<IItemEntryReadOnly> ItemRemoved { get; } = new UnityEventPlus<IItemEntryReadOnly>();
+        public IUnityEvent<IItemEntryReadOnly> ItemChanged { get; } = new UnityEventPlus<IItemEntryReadOnly>();
+    }
+}
diff --git a/Runtime/Inventory/InventoryEvents.cs.meta b/Runtime/Inventory/InventoryEvents.cs.meta
new file mode 100644
index 0000000..94e3f95
--- /dev/null
+++ b/Runtime/Inventory/InventoryEvents.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 174811bd96204dc984b142e68a561871
+timeCreated: 1686790436
\ No newline at end of file
diff --git a/Runtime/Inventory/InventoryHelper.cs b/Runtime/Inventory/InventoryHelper.cs
new file mode 100644
index 0000000..0c3f22b
--- /dev/null
+++ b/Runtime/Inventory/InventoryHelper.cs
@@ -0,0 +1,70 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using CleverCrow.Fluid.Databases;
+using UnityEngine;
+
+namespace CleverCrow.Fluid.ElasticInventory {
+    /// <summary>
+    /// This wrapper class automatically manages a simple implementation of an inventory instance for you with a lazy loaded [database](https://github.com/ashblue/fluid-database).
+    /// It's designed to only include the minimal logic required to get an inventory up and running. If you need more control, it's
+    /// recommended to re-implement this instead of overriding it
+    /// </summary>
+    public class InventoryHelper : MonoBehaviour {
+        InventoryHelperInternal _internal;
+
+        [SerializeField]
+        string _id = Guid.NewGuid().ToString();
+
+        [SerializeField]
+        List<ItemEntryData> _startingItems;
+
+        public IInventoryInstance Instance => _internal?.Instance;
+
+        void Awake () {
+            _internal = new InventoryHelperInternal(_id, _startingItems.ToList<IItemEntryReadOnly>(),
+                ItemDatabase.Current, GlobalDatabaseManager.Instance.Database);
+        }
+
+        public void Save () {
+            _internal.Save();
+        }
+    }
+
+    public class InventoryHelperInternal {
+        readonly string _id;
+        readonly IDatabaseInstance _globalDatabase;
+        public IInventoryInstance Instance { get; }
+
+        public InventoryHelperInternal (string id, List<IItemEntryReadOnly> startingItems, IItemDatabase itemDatabase,
+            IDatabaseInstance globalDatabase) {
+            _id = id;
+            _globalDatabase = globalDatabase;
+            Instance = new InventoryInstance(itemDatabase);
+
+            var save = globalDatabase.Strings.Get(id);
+            if (!string.IsNullOrEmpty(save)) {
+                Instance.Load(save);
+            } else {
+                // Reverse the items so the first item in the list is the last item added. This is to ensure that lists
+                // sorted by last modified descending will be correct
+                var flippedItems = startingItems.ToList();
+                flippedItems.Reverse();
+
+                flippedItems.ForEach(i => {
+                    if (i.Definition.Unique) {
+                        for (var j = 0; j < i.Quantity; j++) {
+                            Instance.Add(i.Definition);
+                        }
+                    } else {
+                        Instance.Add(i.Definition, i.Quantity);
+                    }
+                });
+            }
+        }
+
+        public void Save () {
+            _globalDatabase.Strings.Set(_id, Instance.Save());
+        }
+    }
+}
diff --git a/Runtime/Inventory/InventoryHelper.cs.meta b/Runtime/Inventory/InventoryHelper.cs.meta
new file mode 100644
index 0000000..fc80261
--- /dev/null
+++ b/Runtime/Inventory/InventoryHelper.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: b350877d51674b3193e6c53afd7be4a6
+timeCreated: 1686011574
\ No newline at end of file
diff --git a/Runtime/Inventory/InventoryInstance.cs b/Runtime/Inventory/InventoryInstance.cs
new file mode 100644
index 0000000..f592324
--- /dev/null
+++ b/Runtime/Inventory/InventoryInstance.cs
@@ -0,0 +1,209 @@
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+
+namespace CleverCrow.Fluid.ElasticInventory {
+    public partial class InventoryInstance : IInventoryInstance {
+        private readonly Dictionary<string, IItemEntry> _idToEntry = new();
+        private readonly Dictionary<IItemDefinition, IItemEntry> _entries = new();
+        private readonly List<IItemEntry> _uniqueEntries = new();
+        private readonly IItemDatabase _database;
+
+        public IInventoryEvents Events { get; } = new InventoryEvents();
+
+        public InventoryInstance (IItemDatabase database) {
+            _database = database;
+        }
+
+        public IItemEntryReadOnly Get(IItemDefinition item) {
+            _entries.TryGetValue(item, out var entry);
+            return entry ?? _uniqueEntries.FirstOrDefault(e => e.Definition == item);
+        }
+
+        public IItemEntryReadOnly Get (string definitionId) {
+            var definition = _database.Get(definitionId);
+            return definition == null ? null : Get(definition);
+        }
+
+        public IItemEntryReadOnly GetEntry(string entryId) {
+            return _idToEntry.TryGetValue(entryId, out var entry) ? entry : null;
+        }
+
+        public IItemEntryReadOnly Add(IItemDefinition item, int quantity = 1) {
+            if (item == null || quantity < 1) return null;
+
+            IItemEntryReadOnly entry;
+            if (item.Unique) {
+                entry = item.CreateItemEntry(_database);
+                AddEntry((IItemEntry)entry);
+            } else if (_entries.TryGetValue(item, out var existingEntry)) {
+                existingEntry.SetQuantity(existingEntry.Quantity + quantity);
+                entry = existingEntry;
+            } else {
+                entry = item.CreateItemEntry(_database, quantity);
+                AddEntry((IItemEntry)entry);
+            }
+
+            Events.ItemAdded.Invoke(entry);
+            Events.ItemChanged.Invoke(entry);
+
+            return entry;
+        }
+
+        public IItemEntryReadOnly Add (string definitionId, int quantity = 1) {
+            var definition = _database.Get(definitionId);
+            return definition == null ? null : Add(definition, quantity);
+        }
+
+        public IItemEntryReadOnly AddEntry(IItemEntryReadOnly entry) {
+            if (entry == null) return null;
+
+            // Unique items and items without existing quantities can be added directly
+            if (entry.Definition.Unique || !Has(entry.Definition)) {
+                AddEntry(entry as IItemEntry);
+                entry.UpdateTimeLogs();
+                return entry;
+            }
+
+            return Add(entry.Definition, entry.Quantity);
+        }
+
+        private void AddEntry (IItemEntry entry) {
+            if (entry.Definition.Unique) {
+                _uniqueEntries.Add(entry);
+            } else {
+                _entries.Add(entry.Definition, entry);
+            }
+
+            _idToEntry.Add(entry.Id, entry);
+        }
+
+        public bool Has (IItemDefinition item, int quantity = 1) {
+            var entry = Get(item);
+            return entry != null && entry.Quantity >= quantity;
+        }
+
+        public bool Has (string definitionId, int quantity = 1) {
+            var definition = _database.Get(definitionId);
+            return definition != null && Has(definition, quantity);
+        }
+
+        public bool HasEntry (string entryId, int quantity = 1) {
+            var entry = GetEntry(entryId);
+            if (entry == null) return false;
+            if (!entry.Definition.Unique) return Has(entry.Definition, quantity);
+
+            return true;
+        }
+
+        public void Remove (IItemDefinition item, int quantity = 1) {
+            if (item.Unique) throw new System.ArgumentException("Unique items cannot be removed by definition. Use an ID instead");
+
+            var entry = _entries[item];
+            entry.SetQuantity(entry.Quantity - quantity);
+
+            if (entry.Quantity <= 0) {
+                _entries.Remove(item);
+                _idToEntry.Remove(entry.Id);
+            }
+
+            Events.ItemRemoved.Invoke(entry);
+            Events.ItemChanged.Invoke(entry);
+        }
+
+        public void Remove (string definitionId, int quantity = 1) {
+            var definition = _database.Get(definitionId);
+            if (definition == null) return;
+
+            Remove(definition, quantity);
+        }
+
+        /// <summary>
+        /// Remove an item entry by its unique ID
+        /// </summary>
+        /// <param name="entryId"></param>
+        /// <param name="quantity">Please note this will not remove multiple unique items. You must manually pass in the IDs for each one</param>
+        public void RemoveEntry (string entryId, int quantity = 1) {
+            var entry = _idToEntry[entryId];
+
+            // Leave the implementation up to the remove method
+            if (!entry.Definition.Unique) {
+                Remove(entry.Definition, quantity);
+                return;
+            }
+
+            _uniqueEntries.Remove(entry);
+            _idToEntry.Remove(entry.Id);
+
+            Events.ItemRemoved.Invoke(entry);
+            Events.ItemChanged.Invoke(entry);
+        }
+
+        public string Save () {
+            var data = new InventorySaveData {
+                items = GetAll<IItemEntry>()
+                    .Select(e => e.Definition.DataResolver.Save(e))
+                    .ToList(),
+            };
+
+            return JsonUtility.ToJson(data);
+        }
+
+        public void Load (string save) {
+            var data = JsonUtility.FromJson<InventorySaveData>(save);
+
+            // Create a fake data resolver so we can pull out the definition from the raw JSON
+            var resolver = new ItemEntryDataResolver();
+
+            data.items.ForEach(json => {
+                // Create a fake object so we can get to the definition from the save data
+                var tmpEntry = resolver.Load(json, _database);
+                var entry = tmpEntry.Definition.DataResolver.Load(json, _database);
+
+                AddEntry(entry);
+            });
+        }
+
+        /// <summary>
+        /// Get all item entries of the specified criteria
+        /// </summary>
+        /// <param name="definitionType">
+        /// Use this to retrieve only items created from a specific definition type (Weapons, Armor, etc)
+        /// </param>
+        /// <param name="category">
+        /// Only return items from a specific category
+        /// </param>
+        /// <typeparam name="T">
+        /// Declare a custom item entry type to be returned. Useful for items that have an editable state
+        /// </typeparam>
+        /// <returns></returns>
+        public List<T> GetAll<T> (
+            System.Type definitionType = null,
+            string category = null
+        ) where T : IItemEntryReadOnly {
+            var allEntries = new List<T>();
+            allEntries.AddRange(_uniqueEntries.Cast<T>());
+            allEntries.AddRange(_entries.Values.Cast<T>());
+
+            if (definitionType != null) {
+                allEntries = allEntries.Where(e => definitionType.IsInstanceOfType(e.Definition)).ToList();
+            }
+
+            if (category != null) {
+                allEntries = allEntries.Where(e => e.Definition.Category == category).ToList();
+            }
+
+            return allEntries;
+        }
+
+        /// <summary>
+        /// Simplified wrapper for GetAll that returns a non-editable item entry. See GetAll with generic type for full documentation
+        /// </summary>
+        public List<IItemEntryReadOnly> GetAll (
+            System.Type definitionType = null,
+            string category = null
+        ) {
+            return GetAll<IItemEntryReadOnly>(definitionType, category);
+        }
+    }
+}
diff --git a/Runtime/Inventory/InventoryInstance.cs.meta b/Runtime/Inventory/InventoryInstance.cs.meta
new file mode 100644
index 0000000..d1ee0f4
--- /dev/null
+++ b/Runtime/Inventory/InventoryInstance.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2101652a3a6824f5bb461395334b9144
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Runtime/Inventory/InventoryInstanceSorting.cs b/Runtime/Inventory/InventoryInstanceSorting.cs
new file mode 100644
index 0000000..e1468fa
--- /dev/null
+++ b/Runtime/Inventory/InventoryInstanceSorting.cs
@@ -0,0 +1,103 @@
+using System;
+using System.Collections.Generic;
+
+namespace CleverCrow.Fluid.ElasticInventory {
+    public enum ItemOrder {
+        Ascending,
+        Descending,
+    }
+
+    public enum ItemSort {
+        // Skip sorting
+        None,
+
+        // Uses the entry's date created field
+        CreatedAt,
+
+        // Uses the entry's date updated field
+        UpdatedAt,
+
+        // Sorts by display name
+        Alphabetical,
+
+        // Sort by category name, override with the customCategory field to assign categories to specific sort orders
+        Category,
+    }
+
+    public class CategorySort {
+        public string Category { get; }
+        public int Order { get; }
+
+        public CategorySort (string category, int order) {
+            Category = category;
+            Order = order;
+        }
+    }
+
+    public partial class InventoryInstance {
+        /// <summary>
+        /// Optimally sorts the passed list of items in place. Defaults to sorting by date created then alphabetical in ascending order.
+        /// This is so matching date timestamps never get out of order.
+        /// </summary>
+        /// <param name="items">What should be sorted</param>
+        /// <param name="sort">Primary sorting order</param>
+        /// <param name="order">Ascending or descending</param>
+        /// <param name="sortSecondary">Perform extra sorting on matching items with a matching sort key</param>
+        /// <param name="orderSecondary">Ascending or descending</param>
+        /// <param name="customCategory">Allows you to provide a custom configuration for sorting categories. Providing this will override all usage of the ItemSort.Category usage</param>
+        public void Sort (
+            List<IItemEntryReadOnly> items,
+            ItemSort sort = ItemSort.CreatedAt,
+            ItemOrder order = ItemOrder.Ascending,
+            ItemSort sortSecondary = ItemSort.Alphabetical,
+            ItemOrder orderSecondary = ItemOrder.Ascending,
+            List<CategorySort> customCategory = null
+        ) {
+            items.Sort((a, b) => {
+                var compare = QuickCompare(a, b, sort, order, customCategory);
+                if (compare == 0) {
+                    return QuickCompare(a, b, sortSecondary, orderSecondary, customCategory);
+                }
+
+                return compare;
+            });
+        }
+
+        private int QuickCompare (
+            IItemEntryReadOnly a,
+            IItemEntryReadOnly b,
+            ItemSort sort,
+            ItemOrder order,
+            List<CategorySort> customCategory
+        ) {
+            int result;
+            switch (sort) {
+                case ItemSort.CreatedAt:
+                    result = a.CreatedAt.CompareTo(b.CreatedAt);
+                    break;
+                case ItemSort.UpdatedAt:
+                    result = a.UpdatedAt.CompareTo(b.UpdatedAt);
+                    break;
+                case ItemSort.Alphabetical:
+                    result = string.Compare(a.Definition.DisplayName, b.Definition.DisplayName,
+                        StringComparison.Ordinal);
+                    break;
+                case ItemSort.Category:
+                    if (customCategory != null) {
+                        var aCategory = customCategory.FindIndex(c => c.Category == a.Definition.Category);
+                        var bCategory = customCategory.FindIndex(c => c.Category == b.Definition.Category);
+                        result = aCategory.CompareTo(bCategory);
+                        break;
+                    }
+
+                    result = string.Compare(a.Definition.Category, b.Definition.Category, StringComparison.Ordinal);
+                    break;
+                default:
+                    result = 0;
+                    break;
+            }
+
+            return order == ItemOrder.Ascending ? result : -result;
+        }
+    }
+}
diff --git a/Runtime/Inventory/InventoryInstanceSorting.cs.meta b/Runtime/Inventory/InventoryInstanceSorting.cs.meta
new file mode 100644
index 0000000..d735ff8
--- /dev/null
+++ b/Runtime/Inventory/InventoryInstanceSorting.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 688d5e430fed41f594d1baa1a8bb64c9
+timeCreated: 1687392414
\ No newline at end of file
diff --git a/Runtime/Inventory/InventorySaveData.cs b/Runtime/Inventory/InventorySaveData.cs
new file mode 100644
index 0000000..d8b1b0c
--- /dev/null
+++ b/Runtime/Inventory/InventorySaveData.cs
@@ -0,0 +1,8 @@
+using System.Collections.Generic;
+
+namespace CleverCrow.Fluid.ElasticInventory {
+    [System.Serializable]
+    public class InventorySaveData {
+        public List<string> items;
+    }
+}
diff --git a/Runtime/Inventory/InventorySaveData.cs.meta b/Runtime/Inventory/InventorySaveData.cs.meta
new file mode 100644
index 0000000..9d21d01
--- /dev/null
+++ b/Runtime/Inventory/InventorySaveData.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f03cfb18d293e4db29badc746c24a2f5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Runtime/Items.meta b/Runtime/Items.meta
new file mode 100644
index 0000000..212b413
--- /dev/null
+++ b/Runtime/Items.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 4514492dbef7a4546a756c7a1e1b23aa
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Runtime/Items/Entries.meta b/Runtime/Items/Entries.meta
new file mode 100644
index 0000000..4365a2d
--- /dev/null
+++ b/Runtime/Items/Entries.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 7357dcf2eef164423bb3e25998cbd55c
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Runtime/Items/Entries/IItemEntry.cs b/Runtime/Items/Entries/IItemEntry.cs
new file mode 100644
index 0000000..b27580c
--- /dev/null
+++ b/Runtime/Items/Entries/IItemEntry.cs
@@ -0,0 +1,31 @@
+namespace CleverCrow.Fluid.ElasticInventory {
+    /// <summary>
+    /// A read only safe interface wrapper to prevent accidentally editing item entries outside of inventory instances
+    /// </summary>
+    public interface IItemEntryReadOnly {
+        string Id { get; }
+        IItemDefinition Definition { get; }
+        int Quantity { get; }
+        int CreatedAt { get; }
+        int UpdatedAt { get; }
+
+        void UpdateTimeLogs ();
+    }
+
+    public interface IItemEntry : IItemEntryReadOnly {
+        /// <summary>
+        /// Only called once for you automatically. DO NOT call this for any reason in your code. The sky will fall.
+        /// </summary>
+        void Setup (
+            IItemDatabase database,
+            IItemDefinition definition,
+            int quantity = 1,
+            string id = null,
+            int? createdAt = null,
+            int? updatedAt = null
+        );
+
+        T GetDefinition<T> () where T : IItemDefinition;
+        void SetQuantity (int quantity);
+    }
+}
diff --git a/Runtime/Items/Entries/IItemEntry.cs.meta b/Runtime/Items/Entries/IItemEntry.cs.meta
new file mode 100644
index 0000000..91d50f8
--- /dev/null
+++ b/Runtime/Items/Entries/IItemEntry.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b3e98abe010a0451bba0b935e79d3b6d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Runtime/Items/Entries/ItemEntry.cs b/Runtime/Items/Entries/ItemEntry.cs
new file mode 100644
index 0000000..be9384b
--- /dev/null
+++ b/Runtime/Items/Entries/ItemEntry.cs
@@ -0,0 +1,4 @@
+namespace CleverCrow.Fluid.ElasticInventory {
+    public class ItemEntry : ItemEntryBase {
+    }
+}
diff --git a/Runtime/Items/Entries/ItemEntry.cs.meta b/Runtime/Items/Entries/ItemEntry.cs.meta
new file mode 100644
index 0000000..5320b81
--- /dev/null
+++ b/Runtime/Items/Entries/ItemEntry.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: fce646d60bf4148379268436a4f8c84c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Runtime/Items/Entries/ItemEntryBase.cs b/Runtime/Items/Entries/ItemEntryBase.cs
new file mode 100644
index 0000000..e39b5d9
--- /dev/null
+++ b/Runtime/Items/Entries/ItemEntryBase.cs
@@ -0,0 +1,48 @@
+namespace CleverCrow.Fluid.ElasticInventory {
+    public abstract class ItemEntryBase : IItemEntry {
+        IItemDatabase _database;
+
+        public IItemDefinition Definition { get; private set; }
+        public int Quantity { get; private set; }
+        public int CreatedAt { get; private set; }
+        public string Id { get; private set; }
+        public int UpdatedAt { get; private set; }
+
+        public void Setup (
+            IItemDatabase database,
+            IItemDefinition definition,
+            int quantity = 1,
+            string id = null,
+            int? createdAt = null,
+            int? lastUpdatedAt = null
+        ) {
+            _database = database;
+            Id = id ?? System.Guid.NewGuid().ToString();
+            Definition = definition;
+            Quantity = quantity;
+            CreatedAt = createdAt ?? database.GetUniqueIndex();
+            UpdatedAt = lastUpdatedAt ?? database.GetUniqueIndex();
+        }
+
+        public void SetQuantity(int quantity) {
+            Quantity = quantity;
+            UpdateTimeLogs();
+        }
+
+        /// <summary>
+        /// Helper method to retrieve a definition as the expected type
+        /// </summary>
+        public T GetDefinition<T> () where T : IItemDefinition {
+            // @NOTE Should be able to automatically cast this via generic class type,
+            // but it creates a reciprocal reference loop with the definition
+            return (T)Definition;
+        }
+
+        /// <summary>
+        /// Manually call this whenever you change you change any values on a custom entry to update timestamps
+        /// </summary>
+        public void UpdateTimeLogs () {
+            UpdatedAt = _database.GetUniqueIndex();
+        }
+    }
+}
diff --git a/Runtime/Items/Entries/ItemEntryBase.cs.meta b/Runtime/Items/Entries/ItemEntryBase.cs.meta
new file mode 100644
index 0000000..41445cc
--- /dev/null
+++ b/Runtime/Items/Entries/ItemEntryBase.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: a0bc6a9568f948808ebf1b3a432d4f1c
+timeCreated: 1686617011
\ No newline at end of file
diff --git a/Runtime/Items/Entries/ItemEntryData.cs b/Runtime/Items/Entries/ItemEntryData.cs
new file mode 100644
index 0000000..b671e4e
--- /dev/null
+++ b/Runtime/Items/Entries/ItemEntryData.cs
@@ -0,0 +1,27 @@
+using UnityEngine;
+
+namespace CleverCrow.Fluid.ElasticInventory {
+    /// <summary>
+    /// A re-usable class for visually representing item entries in the inspector
+    /// </summary>
+    [System.Serializable]
+    public class ItemEntryData : IItemEntryReadOnly {
+        [SerializeField]
+        private ItemDefinitionBase _definition;
+
+        [SerializeField]
+        private int _quantity = 1;
+
+        public IItemDefinition Definition => _definition;
+
+        public string Id => null;
+        // This should never be less than zero. The minimum value will always be 1
+        public int Quantity => _quantity < 1 ? 1 : _quantity;
+        public int CreatedAt => 0;
+        public int UpdatedAt => 0;
+
+        public void UpdateTimeLogs () {
+            throw new System.NotImplementedException();
+        }
+    }
+}
diff --git a/Runtime/Items/Entries/ItemEntryData.cs.meta b/Runtime/Items/Entries/ItemEntryData.cs.meta
new file mode 100644
index 0000000..bdf6528
--- /dev/null
+++ b/Runtime/Items/Entries/ItemEntryData.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 9558693a9bbb144c78443e17e7763678
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Runtime/Items/Entries/ItemEntryDataResolver.cs b/Runtime/Items/Entries/ItemEntryDataResolver.cs
new file mode 100644
index 0000000..61f057e
--- /dev/null
+++ b/Runtime/Items/Entries/ItemEntryDataResolver.cs
@@ -0,0 +1,5 @@
+namespace CleverCrow.Fluid.ElasticInventory {
+    [System.Serializable]
+    public class ItemEntryDataResolver : ItemEntryDataResolverBase<IItemEntryReadOnly> {
+    }
+}
diff --git a/Runtime/Items/Entries/ItemEntryDataResolver.cs.meta b/Runtime/Items/Entries/ItemEntryDataResolver.cs.meta
new file mode 100644
index 0000000..8b96aad
--- /dev/null
+++ b/Runtime/Items/Entries/ItemEntryDataResolver.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: b8695d461add476eb8ce4cbb02d4de7d
+timeCreated: 1686701430
\ No newline at end of file
diff --git a/Runtime/Items/Entries/ItemEntryDataResolverBase.cs b/Runtime/Items/Entries/ItemEntryDataResolverBase.cs
new file mode 100644
index 0000000..691d0f2
--- /dev/null
+++ b/Runtime/Items/Entries/ItemEntryDataResolverBase.cs
@@ -0,0 +1,65 @@
+using System;
+using System.Globalization;
+using UnityEngine;
+
+namespace CleverCrow.Fluid.ElasticInventory {
+    /// <summary>
+    /// A universal interface to handle saving and loading item entries
+    /// </summary>
+    public interface IItemEntryDataResolver {
+        string Save (IItemEntryReadOnly entry);
+        IItemEntry Load (string json, IItemDatabase database);
+    }
+
+    public abstract class ItemEntryDataResolverBase<T> : IItemEntryDataResolver where T : IItemEntryReadOnly {
+        public string definitionId;
+        public string uniqueId;
+        public int quantity;
+        public int createdAt;
+        public int updatedAt;
+
+        public string Save (IItemEntryReadOnly entry) {
+            Reset();
+
+            definitionId = entry.Definition.Id;
+            uniqueId = entry.Id;
+            quantity = entry.Quantity;
+            createdAt = entry.CreatedAt;
+            updatedAt = entry.UpdatedAt;
+
+            OnSave((T)entry);
+
+            return JsonUtility.ToJson(this);
+        }
+
+        public IItemEntry Load (string json, IItemDatabase database) {
+            Reset();
+            JsonUtility.FromJsonOverwrite(json, this);
+
+            var entry = database.Get(definitionId).CreateItemEntry(database, quantity, uniqueId, createdAt, updatedAt);
+
+            OnLoad((T)entry);
+
+            return entry;
+        }
+
+        private void Reset () {
+            definitionId = null;
+            uniqueId = null;
+            quantity = 0;
+            createdAt = 0;
+            updatedAt = 0;
+
+            OnReset();
+        }
+
+        protected virtual void OnSave (T entry) {
+        }
+
+        protected virtual void OnLoad (T entry) {
+        }
+
+        protected virtual void OnReset () {
+        }
+    }
+}
diff --git a/Runtime/Items/Entries/ItemEntryDataResolverBase.cs.meta b/Runtime/Items/Entries/ItemEntryDataResolverBase.cs.meta
new file mode 100644
index 0000000..4775b8f
--- /dev/null
+++ b/Runtime/Items/Entries/ItemEntryDataResolverBase.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: e3387a7424314072ad0601316f861e38
+timeCreated: 1684782238
\ No newline at end of file
diff --git a/Runtime/Items/IItemDefinition.cs b/Runtime/Items/IItemDefinition.cs
new file mode 100644
index 0000000..0f982ae
--- /dev/null
+++ b/Runtime/Items/IItemDefinition.cs
@@ -0,0 +1,28 @@
+namespace CleverCrow.Fluid.ElasticInventory {
+    public interface IItemDefinition {
+        /// <summary>
+        /// A unique ID generated at the creation of this entry. It will persist on save and load.
+        /// </summary>
+        string Id { get; }
+
+        string DisplayName { get; }
+
+        string Category { get; }
+
+        /// <summary>
+        /// Unique items will always have their own unique entry with a quantity of 1. Please note
+        /// you cannot stack or adjust the quantity of these items
+        /// </summary>
+        bool Unique { get; }
+
+        IItemEntryDataResolver DataResolver { get; }
+
+        IItemEntry CreateItemEntry (
+            IItemDatabase database,
+            int quantity = 1,
+            string id = null,
+            int? createdAt = null,
+            int? updatedAt = null
+        );
+    }
+}
diff --git a/Runtime/Items/IItemDefinition.cs.meta b/Runtime/Items/IItemDefinition.cs.meta
new file mode 100644
index 0000000..3e8a0de
--- /dev/null
+++ b/Runtime/Items/IItemDefinition.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 40f5059f829a34bcd8f01e9f61966d3e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Runtime/Items/ItemDefinitionBase.cs b/Runtime/Items/ItemDefinitionBase.cs
new file mode 100644
index 0000000..a9c879d
--- /dev/null
+++ b/Runtime/Items/ItemDefinitionBase.cs
@@ -0,0 +1,55 @@
+using UnityEngine;
+
+namespace CleverCrow.Fluid.ElasticInventory {
+    public abstract class ItemDefinitionBase : ScriptableObject, IItemDefinition {
+        [SerializeField]
+        string _id;
+
+        [SerializeField]
+        string _displayName;
+
+        public string Id => _id;
+        public string DisplayName => _displayName;
+        public virtual bool Unique => false;
+        public virtual IItemEntryDataResolver DataResolver { get; } = new ItemEntryDataResolver();
+        public abstract string Category { get; }
+
+        public virtual IItemEntry CreateItemEntry (IItemDatabase database, int quantity = 1, string id = null, int? createdAt = null, int? updatedAt = null) {
+            var entry = new ItemEntry();
+            entry.Setup(database, this, quantity, id, createdAt, updatedAt);
+
+            return entry;
+        }
+
+        /// <summary>
+        /// Maps the category index to the database category list. Works with the editor and runtime.
+        ///
+        /// Categories on generic items are saved using an index that maps to the database category list. If you change the name of the corresponding category index it will change the category name of every associated item.
+        /// </summary>
+        protected string GetCategoryByIndex (int index) {
+            IItemDatabase database = null;
+
+            if (Application.isPlaying) {
+                database = ItemDatabase.Current;
+            }
+
+#if UNITY_EDITOR
+            if (!Application.isPlaying) {
+                database = Resources.Load<ItemDatabase>("ItemDatabase");
+
+                if (database == null) {
+                    Debug.LogWarning("Could not find ItemDatabase. Please create one at `Resources/ItemDatabase'.");
+                    return "Default";
+                }
+            }
+#endif
+
+            if (database.Categories.Count <= index) {
+                Debug.LogWarning($"Category index {index} is out of range. Please check your database. Returning `Default' category.");
+                return "Default";
+            }
+
+            return database.Categories[index];
+        }
+    }
+}
diff --git a/Runtime/Items/ItemDefinitionBase.cs.meta b/Runtime/Items/ItemDefinitionBase.cs.meta
new file mode 100644
index 0000000..9151c23
--- /dev/null
+++ b/Runtime/Items/ItemDefinitionBase.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6dfa55dd8fae14f1f90efad99f96a4cb
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Runtime/com.fluid.elastic-inventory.asmdef b/Runtime/com.fluid.elastic-inventory.asmdef
new file mode 100755
index 0000000..34ac8d1
--- /dev/null
+++ b/Runtime/com.fluid.elastic-inventory.asmdef
@@ -0,0 +1,19 @@
+{
+    "name": "com.fluid.elastic-inventory",
+    "rootNamespace": "",
+    "references": [
+        "GUID:384c6e7b6222f064b93d685dcbd43f93",
+        "GUID:de83a3ca544d84ef3837e878896f66e9",
+        "GUID:5d226a1776aa442e788ca15f9d2a42d0",
+        "GUID:424539e03b77bb047a96fa8c6ab1fe20"
+    ],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}
\ No newline at end of file
diff --git a/Runtime/com.fluid.elastic-inventory.asmdef.meta b/Runtime/com.fluid.elastic-inventory.asmdef.meta
new file mode 100644
index 0000000..6f4c5c7
--- /dev/null
+++ b/Runtime/com.fluid.elastic-inventory.asmdef.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: a77962bdfeb434239910e461749248c6
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Tests.meta b/Tests.meta
new file mode 100644
index 0000000..b855a74
--- /dev/null
+++ b/Tests.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 3ee2ecf92fe594b8984e19b28014c228
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Tests/Editor.meta b/Tests/Editor.meta
new file mode 100644
index 0000000..d5d8e4b
--- /dev/null
+++ b/Tests/Editor.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 273b88efa9bb4421cbe1755e1ee111c7
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Tests/Editor/Scripts.meta b/Tests/Editor/Scripts.meta
new file mode 100644
index 0000000..cfa52ac
--- /dev/null
+++ b/Tests/Editor/Scripts.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: b17f5262db91c429f88617e118187a22
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Tests/Editor/Scripts/InventoryHelperTest.cs b/Tests/Editor/Scripts/InventoryHelperTest.cs
new file mode 100644
index 0000000..3b71b71
--- /dev/null
+++ b/Tests/Editor/Scripts/InventoryHelperTest.cs
@@ -0,0 +1,117 @@
+using System.Collections.Generic;
+using CleverCrow.Fluid.Databases;
+using NSubstitute;
+using NUnit.Framework;
+
+namespace CleverCrow.Fluid.ElasticInventory.Testing {
+    public class InventoryHelperTest {
+        private InventoryHelperInternal Setup (
+            string id = "id",
+            List<IItemEntryReadOnly> startingItems = null,
+            IItemDatabase itemDatabase = null,
+            IDatabaseInstance globalDatabase = null
+        ) {
+            if (startingItems == null) startingItems = new List<IItemEntryReadOnly>();
+            if (itemDatabase == null) itemDatabase = Substitute.For<IItemDatabase>();
+            if (globalDatabase == null) globalDatabase = Substitute.For<IDatabaseInstance>();
+
+            return new InventoryHelperInternal(id, startingItems, itemDatabase, globalDatabase);
+        }
+
+        public class Init : InventoryHelperTest {
+            [Test]
+            public void It_should_add_a_list_of_item_entries_to_the_an_inventory_instance () {
+                var startingItems = new List<IItemEntryReadOnly> {
+                    A.ItemEntryReadOnly().Build(),
+                    A.ItemEntryReadOnly().Build(),
+                    A.ItemEntryReadOnly().Build(),
+                };
+
+                var helper = Setup(startingItems: startingItems);
+                var inventory = helper.Instance;
+
+                Assert.AreEqual(3, inventory.GetAll().Count);
+
+                foreach (var item in startingItems) {
+                    Assert.AreEqual(item.Definition, inventory.Get(item.Definition).Definition);
+                    Assert.AreEqual(item.Quantity, inventory.Get(item.Definition).Quantity);
+                }
+            }
+
+            [Test]
+            public void It_should_overwrite_items_if_data_exists_in_the_global_database () {
+                var instanceId = "inventory_instance";
+
+                var item = A.ItemDefinition().Build();
+                var itemDatabase = Substitute.For<IItemDatabase>();
+                itemDatabase.Get(item.Id).Returns(item);
+
+                var existingInventory = new InventoryInstance(itemDatabase);
+                existingInventory.Add(item);
+                var save = existingInventory.Save();
+
+                var globalDatabase = Substitute.For<IDatabaseInstance>();
+                globalDatabase.Strings.Get(instanceId).Returns(save);
+
+                var helper = Setup(id: instanceId, itemDatabase: itemDatabase, globalDatabase: globalDatabase);
+
+                Assert.AreEqual(1, helper.Instance.GetAll().Count);
+                Assert.AreEqual(item, helper.Instance.Get(item).Definition);
+            }
+
+            [Test]
+            public void It_should_not_load_items_on_top_of_existing_items () {
+                var instanceId = "inventory_instance";
+                var startingItems = new List<IItemEntryReadOnly> {
+                    A.ItemEntryReadOnly().Build(),
+                };
+
+                var item = A.ItemDefinition().Build();
+                var itemDatabase = Substitute.For<IItemDatabase>();
+                itemDatabase.Get(item.Id).Returns(item);
+
+                var existingInventory = new InventoryInstance(itemDatabase);
+                existingInventory.Add(item);
+                var save = existingInventory.Save();
+
+                var globalDatabase = Substitute.For<IDatabaseInstance>();
+                globalDatabase.Strings.Get(instanceId).Returns(save);
+
+                var helper = Setup(id: instanceId, startingItems: startingItems, itemDatabase: itemDatabase, globalDatabase: globalDatabase);
+
+                Assert.AreEqual(1, helper.Instance.GetAll().Count);
+                Assert.AreEqual(item, helper.Instance.Get(item).Definition);
+            }
+
+            [Test]
+            public void It_should_create_multiple_unique_item_entries () {
+                var definition = A.ItemDefinition().WithUnique(true).Build();
+                var startingItems = new List<IItemEntryReadOnly> {
+                    A.ItemEntryReadOnly().WithDefinition(definition).WithQuantity(2).Build(),
+                };
+
+                var helper = Setup(startingItems: startingItems);
+                var inventory = helper.Instance;
+
+                Assert.AreEqual(2, inventory.GetAll().Count);
+            }
+        }
+
+        public class SaveMethod : InventoryHelperTest {
+            [Test]
+            public void It_should_save_the_current_inventory_data_to_the_database () {
+                var instanceId = "inventory_instance";
+                var globalDatabase = Substitute.For<IDatabaseInstance>();
+                var item = A.ItemDefinition().Build();
+                var itemDatabase = Substitute.For<IItemDatabase>();
+                itemDatabase.Get(item.Id).Returns(item);
+
+                var helper = Setup(id: instanceId, itemDatabase: itemDatabase, globalDatabase: globalDatabase);
+                helper.Instance.Add(item);
+                helper.Save();
+
+                globalDatabase.Strings.Received(1).Set(instanceId, helper.Instance.Save());
+            }
+        }
+    }
+}
diff --git a/Tests/Editor/Scripts/InventoryHelperTest.cs.meta b/Tests/Editor/Scripts/InventoryHelperTest.cs.meta
new file mode 100644
index 0000000..522e5d2
--- /dev/null
+++ b/Tests/Editor/Scripts/InventoryHelperTest.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 5917e3dfc39343f986a2359e6eaf1c11
+timeCreated: 1686011930
\ No newline at end of file
diff --git a/Tests/Editor/Scripts/InventoryInstanceTest.cs b/Tests/Editor/Scripts/InventoryInstanceTest.cs
new file mode 100644
index 0000000..5b3621f
--- /dev/null
+++ b/Tests/Editor/Scripts/InventoryInstanceTest.cs
@@ -0,0 +1,693 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+using NUnit.Framework;
+using NSubstitute;
+
+namespace CleverCrow.Fluid.ElasticInventory.Testing {
+    public class InventoryInstanceTest {
+        private InventoryInstance Setup(IItemDatabase database = null) {
+            if (database == null) {
+                database = Substitute.For<IItemDatabase>();
+            }
+
+            return new InventoryInstance(database);
+        }
+
+        public class Get_Method {
+            public class DefaultItems : InventoryInstanceTest {
+                [Test]
+                public void It_should_get_the_item_entry_after_adding_it () {
+                    var item = A.ItemDefinition().Build();
+                    var inventory = Setup();
+
+                    inventory.Add(item);
+                    var entry = inventory.Get(item);
+
+                    Assert.AreEqual(item, entry.Definition);
+                }
+
+                [Test]
+                public void It_should_get_the_item_quantity_of_2_after_adding_it_twice () {
+                    var item = A.ItemDefinition().Build();
+                    var inventory = Setup();
+
+                    inventory.Add(item);
+                    inventory.Add(item);
+                    var entry = inventory.Get(item);
+
+                    Assert.AreEqual(item, entry.Definition);
+                }
+
+                [Test]
+                public void It_should_get_the_item_quantity_of_1_after_adding_it () {
+                    var item = A.ItemDefinition().Build();
+                    var inventory = Setup();
+
+                    inventory.Add(item);
+                    var entry = inventory.Get(item);
+
+                    Assert.AreEqual(1, entry.Quantity);
+                }
+
+                [Test]
+                public void It_should_not_fail_when_getting_a_missing_entry () {
+                    var item = A.ItemDefinition().Build();
+                    var inventory = Setup();
+
+                    var entry = inventory.Get(item);
+
+                    Assert.IsNull(entry);
+                }
+            }
+
+            public class UniqueItems : InventoryInstanceTest {
+                [Test]
+                public void It_should_return_an_item_instance_by_id_after_adding_it () {
+                    var item = A.ItemDefinition().WithUnique(true).Build();
+                    var inventory = Setup();
+
+                    var instance = inventory.Add(item);
+                    var result = inventory.GetEntry(instance.Id);
+
+                    Assert.AreEqual(instance, result);
+                }
+
+                [Test]
+                public void It_should_return_an_item_instance_by_definition_after_adding_it () {
+                    var item = A.ItemDefinition().WithUnique(true).Build();
+                    var inventory = Setup();
+
+                    var instance = inventory.Add(item);
+                    var result = inventory.Get(item);
+
+                    Assert.AreEqual(instance, result);
+                }
+            }
+        }
+
+        public class Add_Method {
+            public class Default_Inventory_Items : InventoryInstanceTest {
+                [Test]
+                public void It_should_not_error_if_null () {
+                    var inventory = Setup();
+
+                    Assert.DoesNotThrow(() => {
+                        inventory.AddEntry(null);
+                    });
+                }
+
+                [Test]
+                public void It_should_not_add_items_with_zero_quantity () {
+                    var item = A.ItemDefinition().Build();
+                    var inventory = Setup();
+
+                    inventory.Add(item, 0);
+
+                    Assert.IsFalse(inventory.Has(item));
+                }
+
+                [Test]
+                public void It_should_add_an_item_entry_returned_from_the_definition_create_item_entry_method () {
+                    var itemEntry = Substitute.For<IItemEntry>();
+                    var item = A.ItemDefinition().WithItemEntry(itemEntry).Build();
+
+                    var inventory = Setup();
+                    inventory.Add(item);
+                    var result = inventory.Get(item);
+
+                    Assert.AreEqual(itemEntry, result);
+                }
+
+                [Test]
+                public void It_should_call_create_item_entry_with_the_passed_quantity () {
+                    var item = A.ItemDefinition().Build();
+                    var database = A.ItemDatabase().Build();
+
+                    var inventory = Setup(database);
+                    inventory.Add(item, 2);
+
+                    item.Received().CreateItemEntry(database, 2);
+                }
+
+                [Test]
+                public void Adding_zero_items_should_not_add_any_items () {
+                    var item = A.ItemDefinition().Build();
+                    var inventory = Setup();
+
+                    var instance = inventory.Add(item, 0);
+
+                    Assert.IsNull(instance);
+                }
+
+                [Test]
+                public void It_should_add_an_item_entry_object () {
+                    var entry = A.ItemEntry().WithQuantity(2).Build();
+
+                    var inventory = Setup();
+                    inventory.AddEntry(entry);
+                    var result = inventory.Get(entry.Definition);
+
+                    Assert.AreEqual(entry.Quantity, result.Quantity);
+                }
+            }
+
+            public class Unique_Items : InventoryInstanceTest {
+                [Test]
+                public void It_should_add_two_unique_items_as_individual_entries () {
+                    var definition = A.ItemDefinition().WithUnique(true).Build();
+                    var inventory = Setup();
+
+                    inventory.Add(definition);
+                    inventory.Add(definition);
+
+                    Assert.AreEqual(2, inventory.GetAll().Count);
+                }
+
+                [Test]
+                public void It_should_add_a_unique_item_entry_as_an_individual_entry () {
+                    var definition = A.ItemDefinition().WithUnique(true).Build();
+                    var entry = A.ItemEntry().WithDefinition(definition).Build();
+                    var inventory = Setup();
+
+                    inventory.AddEntry(entry);
+                    var result = inventory.GetEntry(entry.Id);
+
+                    Assert.AreEqual(entry, result);
+                }
+            }
+
+            public class Events : InventoryInstanceTest {
+                [Test]
+                public void It_should_trigger_an_event_with_the_item_entry_when_an_item_is_added () {
+                    var item = A.ItemDefinition().Build();
+                    var inventory = Setup();
+                    var eventTriggered = false;
+
+                    inventory.Events.ItemAdded.AddListener((entry) => {
+                        eventTriggered = true;
+                        Assert.AreEqual(item, entry.Definition);
+                    });
+
+                    inventory.Add(item);
+
+                    Assert.IsTrue(eventTriggered);
+                }
+
+                [Test]
+                public void It_should_trigger_an_event_when_a_unique_item_is_added () {
+                    var item = A.ItemDefinition().WithUnique(true).Build();
+                    var inventory = Setup();
+                    var eventTriggered = false;
+
+                    inventory.Events.ItemAdded.AddListener((entry) => {
+                        eventTriggered = true;
+                        Assert.AreEqual(item, entry.Definition);
+                    });
+
+                    inventory.Add(item);
+
+                    Assert.IsTrue(eventTriggered);
+                }
+
+                [Test]
+                public void It_should_trigger_an_event_when_items_are_added_to_an_existing_entry () {
+                    var item = A.ItemDefinition().Build();
+                    var inventory = Setup();
+                    var eventTriggered = false;
+
+                    inventory.Add(item);
+                    inventory.Events.ItemAdded.AddListener((entry) => {
+                        eventTriggered = true;
+                        Assert.AreEqual(item, entry.Definition);
+                    });
+
+                    inventory.Add(item);
+
+                    Assert.IsTrue(eventTriggered);
+                }
+            }
+        }
+
+        public class Has_Method {
+            public class DefaultItems : InventoryInstanceTest {
+                [Test]
+                public void It_should_return_true_if_the_item_is_in_the_inventory () {
+                    var item = A.ItemDefinition().Build();
+                    var inventory = Setup();
+
+                    inventory.Add(item);
+                    var result = inventory.Has(item);
+
+                    Assert.IsTrue(result);
+                }
+
+                [Test]
+                public void It_should_return_false_if_the_item_is_not_in_the_inventory () {
+                    var item = A.ItemDefinition().Build();
+                    var inventory = Setup();
+
+                    var result = inventory.Has(item);
+
+                    Assert.IsFalse(result);
+                }
+
+                [Test]
+                public void It_should_return_false_if_the_item_quantity_is_not_in_the_inventory () {
+                    var item = A.ItemDefinition().Build();
+                    var quantity = 2;
+                    var inventory = Setup();
+
+                    inventory.Add(item);
+                    var result = inventory.Has(item, quantity);
+
+                    Assert.IsFalse(result);
+                }
+            }
+
+            public class UniqueItems : InventoryInstanceTest {
+                [Test]
+                public void It_should_return_true_if_the_item_is_in_the_inventory () {
+                    var item = A.ItemDefinition().WithUnique(true).Build();
+                    var inventory = Setup();
+
+                    var entry = inventory.Add(item);
+                    var result = inventory.HasEntry(entry.Id);
+
+                    Assert.IsTrue(result);
+                }
+
+                [Test]
+                public void It_should_return_true_if_the_item_is_in_the_inventory_by_definition () {
+                    var item = A.ItemDefinition().WithUnique(true).Build();
+                    var inventory = Setup();
+
+                    inventory.Add(item);
+                    var result = inventory.Has(item);
+
+                    Assert.IsTrue(result);
+                }
+            }
+        }
+
+        public class Remove_Method {
+            public class DefaultItems : InventoryInstanceTest {
+                [Test]
+                public void It_should_remove_the_item_entry () {
+                    var item = A.ItemDefinition().Build();
+                    var inventory = Setup();
+
+                    inventory.Add(item);
+                    inventory.Remove(item);
+
+                    Assert.IsFalse(inventory.Has(item));
+                }
+
+                [Test]
+                public void It_should_reduce_the_item_count_when_removing_two () {
+                    var item = A.ItemDefinition().Build();
+                    var inventory = Setup();
+
+                    inventory.Add(item, 2);
+                    inventory.Remove(item);
+
+                    Assert.IsTrue(inventory.Has(item));
+                }
+
+                [Test]
+                public void It_should_remove_multiple_items () {
+                    var item = A.ItemDefinition().Build();
+                    var inventory = Setup();
+
+                    inventory.Add(item, 2);
+                    inventory.Remove(item, 2);
+
+                    Assert.IsFalse(inventory.Has(item));
+                }
+
+                [Test]
+                public void It_should_remove_the_item_entry_when_removing_all_items_of_two_quantity () {
+                    var item = A.ItemDefinition().Build();
+                    var inventory = Setup();
+
+                    inventory.Add(item, 2);
+                    inventory.Remove(item, 2);
+
+                    Assert.IsFalse(inventory.Has(item, 0));
+                }
+            }
+
+            public class UniqueItems : InventoryInstanceTest {
+                [Test]
+                public void It_should_remove_the_item_by_entry_id () {
+                    var definition = A.ItemDefinition().WithUnique(true).Build();
+                    var inventory = Setup();
+
+                    var instance = inventory.Add(definition);
+                    inventory.RemoveEntry(instance.Id);
+
+                    Assert.IsFalse(inventory.HasEntry(instance.Id));
+                }
+
+                [Test]
+                public void It_should_throw_an_error_if_you_try_to_remove_a_unique_item_by_definition () {
+                    var definition = A.ItemDefinition().WithUnique(true).Build();
+                    var inventory = Setup();
+
+                    Assert.Throws<ArgumentException>(() => inventory.Remove(definition));
+                }
+            }
+
+            public class Events : InventoryInstanceTest {
+                [Test]
+                public void It_should_trigger_a_remove_event_when_removing_an_item () {
+                    var item = A.ItemDefinition().Build();
+                    var inventory = Setup();
+                    var eventTriggered = false;
+
+                    inventory.Events.ItemRemoved.AddListener((entry) => {
+                        eventTriggered = true;
+                        Assert.AreEqual(item, entry.Definition);
+                    });
+
+                    inventory.Add(item);
+                    inventory.Remove(item);
+
+                    Assert.IsTrue(eventTriggered);
+                }
+
+                [Test]
+                public void It_should_trigger_a_remove_event_when_removing_a_single_item_in_a_stack () {
+                    var item = A.ItemDefinition().Build();
+                    var inventory = Setup();
+                    var eventTriggered = false;
+
+                    inventory.Events.ItemRemoved.AddListener((entry) => {
+                        eventTriggered = true;
+                        Assert.AreEqual(item, entry.Definition);
+                    });
+
+                    inventory.Add(item, 10);
+                    inventory.Remove(item, 1);
+
+                    Assert.IsTrue(eventTriggered);
+                }
+
+                [Test]
+                public void It_should_trigger_a_remove_event_when_removing_a_unique_item () {
+                    var item = A.ItemDefinition().WithUnique(true).Build();
+                    var inventory = Setup();
+                    var eventTriggered = false;
+
+                    inventory.Events.ItemRemoved.AddListener((entry) => {
+                        eventTriggered = true;
+                        Assert.AreEqual(item, entry.Definition);
+                    });
+
+                    var instance = inventory.Add(item);
+                    inventory.RemoveEntry(instance.Id);
+
+                    Assert.IsTrue(eventTriggered);
+                }
+            }
+        }
+
+        public class GetAll_Method : InventoryInstanceTest {
+            [Test]
+            public void It_should_return_all_added_item_entries () {
+                var definition = A.ItemDefinition().Build();
+                var inventory = Setup();
+
+                inventory.Add(definition);
+                var entries = inventory.GetAll();
+
+                Assert.AreEqual(1, entries.Count);
+            }
+
+            [Test]
+            public void It_should_get_all_items_by_definition_type () {
+                var definition = A.ItemDefinition().Build();
+                var inventory = Setup();
+
+                inventory.Add(definition);
+                var entries = inventory.GetAll(typeof(IItemDefinition));
+
+                Assert.AreEqual(1, entries.Count);
+            }
+
+            [Test]
+            public void It_should_get_all_items_by_category () {
+                var category = "Weapon";
+                var definitionA = A.ItemDefinition().WithCategory(category).Build();
+                var definitionB = A.ItemDefinition().Build();
+                var inventory = Setup();
+
+                inventory.Add(definitionA);
+                inventory.Add(definitionB);
+                var entries = inventory.GetAll(category: category);
+
+                Assert.AreEqual(1, entries.Count);
+                Assert.AreEqual(definitionA, entries[0].Definition);
+            }
+        }
+
+        public class Sort_Method : InventoryInstanceTest {
+            [Test]
+            public void It_should_sort_the_items_by_date_added_from_most_recent_to_latest () {
+                var entryA = A.ItemEntry().WithCreatedAt(0).Build();
+                var entryB = A.ItemEntry().WithCreatedAt(1).Build();
+                var order = ItemOrder.Descending;
+                var sort = ItemSort.CreatedAt;
+
+                var inventory = Setup();
+                inventory.AddEntry(entryA);
+                inventory.AddEntry(entryB);
+                var items = inventory.GetAll();
+                inventory.Sort(items, sort, order);
+
+                Assert.AreEqual(entryB, items[0]);
+                Assert.AreEqual(entryA, items[1]);
+            }
+
+            [Test]
+            public void It_should_sort_the_items_alphabetically_by_definition_name () {
+                var definitionA = A.ItemDefinition().WithDisplayName("A").Build();
+                var entryA = A.ItemEntry().WithDefinition(definitionA).Build();
+
+                var definitionB = A.ItemDefinition().WithDisplayName("B").Build();
+                var entryB = A.ItemEntry().WithDefinition(definitionB).Build();
+
+                var order = ItemOrder.Ascending;
+                var sort = ItemSort.Alphabetical;
+
+                var inventory = Setup();
+                inventory.AddEntry(entryA);
+                inventory.AddEntry(entryB);
+                var items = inventory.GetAll();
+                inventory.Sort(items, sort, order);
+
+                Assert.AreEqual(entryA, items[0]);
+                Assert.AreEqual(entryB, items[1]);
+            }
+
+            [Test]
+            public void It_should_sort_items_by_category () {
+                var categoryA = "B";
+                var definitionA = A.ItemDefinition().WithCategory(categoryA).Build();
+                var entryA = A.ItemEntry().WithDefinition(definitionA).Build();
+
+                var categoryB = "A";
+                var definitionB = A.ItemDefinition().WithCategory(categoryB).Build();
+                var entryB = A.ItemEntry().WithDefinition(definitionB).Build();
+
+                var order = ItemOrder.Ascending;
+                var sort = ItemSort.Category;
+
+                var inventory = Setup();
+                inventory.AddEntry(entryA);
+                inventory.AddEntry(entryB);
+                var items = inventory.GetAll();
+                inventory.Sort(items, sort, order);
+
+                Assert.AreEqual(entryA, items[1]);
+                Assert.AreEqual(entryB, items[0]);
+            }
+
+            [Test]
+            public void It_should_sort_by_category_then_alphabetically () {
+                var category = "A";
+                var definitionA = A.ItemDefinition().WithCategory(category).WithDisplayName("B").Build();
+                var entryA = A.ItemEntry().WithDefinition(definitionA).Build();
+
+                var definitionB = A.ItemDefinition().WithCategory(category).WithDisplayName("A").Build();
+                var entryB = A.ItemEntry().WithDefinition(definitionB).Build();
+
+                var order = ItemOrder.Ascending;
+                var sort = ItemSort.Category;
+                var sortSecondary = ItemSort.Alphabetical;
+                var orderSecondary = ItemOrder.Ascending;
+
+                var inventory = Setup();
+                inventory.AddEntry(entryA);
+                inventory.AddEntry(entryB);
+                var items = inventory.GetAll();
+                inventory.Sort(items, sort, order, sortSecondary, orderSecondary);
+
+                Assert.AreEqual(entryA, items[1]);
+                Assert.AreEqual(entryB, items[0]);
+            }
+
+            [Test]
+            public void It_should_handle_a_custom_category_order_when_sorting () {
+                var categoryA = "A";
+                var definitionA = A.ItemDefinition().WithCategory(categoryA).Build();
+                var entryA = A.ItemEntry().WithDefinition(definitionA).Build();
+
+                var categoryB = "B";
+                var definitionB = A.ItemDefinition().WithCategory(categoryB).Build();
+                var entryB = A.ItemEntry().WithDefinition(definitionB).Build();
+
+                var customCategorySort = new List<CategorySort> {
+                    new(categoryA, 1),
+                    new(categoryB, 0),
+                };
+
+                var order = ItemOrder.Ascending;
+                var sort = ItemSort.Category;
+                var sortSecondary = ItemSort.Alphabetical;
+                var orderSecondary = ItemOrder.Ascending;
+
+                var inventory = Setup();
+                inventory.AddEntry(entryA);
+                inventory.AddEntry(entryB);
+                var items = inventory.GetAll();
+                inventory.Sort(items, sort, order, sortSecondary, orderSecondary, customCategorySort);
+            }
+
+            [Test]
+            public void It_should_sort_items_by_updated_at () {
+                var entryA = A.ItemEntry().WithUpdatedAt(0).Build();
+                var entryB = A.ItemEntry().WithUpdatedAt(1).Build();
+                var order = ItemOrder.Descending;
+                var sort = ItemSort.UpdatedAt;
+
+                var inventory = Setup();
+                inventory.AddEntry(entryA);
+                inventory.AddEntry(entryB);
+                var items = inventory.GetAll();
+                inventory.Sort(items, sort, order);
+
+                Assert.AreEqual(entryB, items[0]);
+                Assert.AreEqual(entryA, items[1]);
+            }
+        }
+
+        public class Save_Method : InventoryInstanceTest {
+            [Test]
+            public void It_should_save_the_inventory_entries_to_a_string () {
+                var id = "a";
+                var quantity = 1;
+                var definition = A.ItemDefinition().WithId(id).Build();
+
+                var inventory = Setup();
+                var entry = inventory.Add(definition, quantity);
+                var save = inventory.Save();
+
+                // Must be below the add due to the unique ID
+                var expectedSaveData = new InventorySaveData {
+                    items = new List<string> {
+                        entry.Definition.DataResolver.Save(entry),
+                    },
+                };
+                var expectedSave = JsonUtility.ToJson(expectedSaveData);
+
+                Assert.IsNotEmpty(save);
+                Assert.AreEqual(expectedSave, save);
+            }
+        }
+
+        public class Load_Method : InventoryInstanceTest {
+            [Test]
+            public void It_should_load_inventory_items_from_a_save () {
+                var id = "a";
+                var definition = A.ItemDefinition().WithId(id).Build();
+
+                var database = Substitute.For<IItemDatabase>();
+                database.Get(id).Returns(definition);
+
+                var inventory = Setup(database);
+                inventory.Add(definition);
+                var save = inventory.Save();
+
+                var newInventory = Setup(database);
+                newInventory.Load(save);
+
+                Assert.IsTrue(newInventory.Has(definition));
+            }
+
+            [Test]
+            public void It_should_load_unique_inventory_items_from_a_save () {
+                var id = "a";
+                var definition = A.ItemDefinition().WithUnique(true).WithId(id).Build();
+
+                var database = Substitute.For<IItemDatabase>();
+                database.Get(id).Returns(definition);
+
+                var inventory = Setup(database);
+                var oldItem = inventory.Add(definition);
+                var save = inventory.Save();
+
+                var newInventory = Setup(database);
+                newInventory.Load(save);
+
+                Assert.IsNotNull(newInventory.GetEntry(oldItem.Id));
+            }
+
+            [Test]
+            public void It_should_restore_multiple_unique_entries () {
+                var id = "a";
+                var definition = A.ItemDefinition().WithUnique(true).WithId(id).Build();
+
+                var database = Substitute.For<IItemDatabase>();
+                database.Get(id).Returns(definition);
+
+                var inventory = Setup(database);
+                var oldItem = inventory.Add(definition);
+                var oldItem2 = inventory.Add(definition);
+                var save = inventory.Save();
+
+                var newInventory = Setup(database);
+                newInventory.Load(save);
+
+                Assert.IsNotNull(newInventory.GetEntry(oldItem.Id));
+                Assert.IsNotNull(newInventory.GetEntry(oldItem2.Id));
+            }
+
+            [Test]
+            public void It_should_restore_entry_CreatedAt_timestamps () {
+                var id = "a";
+
+                var definition = A.ItemDefinition().Build();
+                var entry = A.ItemEntry()
+                    .WithId(id)
+                    .WithCreatedAt(-1)
+                    .WithDefinition(definition)
+                    .Build();
+
+                var database = Substitute.For<IItemDatabase>();
+                database.Get(definition.Id).Returns(definition);
+
+                var inventory = Setup(database);
+                inventory.AddEntry(entry);
+                var save = inventory.Save();
+
+                var newInventory = Setup(database);
+                newInventory.Load(save);
+                var loadedEntry = newInventory.GetEntry(id);
+
+                Assert.AreEqual(entry.CreatedAt.ToString(), loadedEntry.CreatedAt.ToString());
+            }
+        }
+    }
+}
+
diff --git a/Tests/Editor/Scripts/InventoryInstanceTest.cs.meta b/Tests/Editor/Scripts/InventoryInstanceTest.cs.meta
new file mode 100644
index 0000000..b796853
--- /dev/null
+++ b/Tests/Editor/Scripts/InventoryInstanceTest.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b0c304fcb917e48ac8fec79740608cd3
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Tests/Editor/Scripts/ItemDatabaseTest.cs b/Tests/Editor/Scripts/ItemDatabaseTest.cs
new file mode 100644
index 0000000..055afaf
--- /dev/null
+++ b/Tests/Editor/Scripts/ItemDatabaseTest.cs
@@ -0,0 +1,74 @@
+using System.Collections.Generic;
+using NUnit.Framework;
+using UnityEngine;
+
+namespace CleverCrow.Fluid.ElasticInventory.Testing {
+    public class ItemDatabaseTest {
+        private ItemDatabaseInternal Setup (List<IItemDefinition> definitions = null) {
+            if (definitions == null) definitions = new List<IItemDefinition>();
+            var database = new ItemDatabaseInternal(definitions);
+
+            return database;
+        }
+
+        public class Get_Method : ItemDatabaseTest {
+            [Test]
+            public void It_should_return_the_expected_item () {
+                var definition = A.ItemDefinition().Build();
+
+                var database = Setup(definitions: new List<IItemDefinition> { definition });
+                var result = database.Get(definition.Id);
+
+                Assert.AreEqual(definition, result);
+            }
+
+            [Test]
+            public void It_should_not_error_if_the_item_is_not_found () {
+                var database = Setup();
+                var item = database.Get("test");
+
+                Assert.IsNull(item);
+            }
+        }
+
+        public class GetUniqueIndex_Method : ItemDatabaseTest {
+            [Test]
+            public void It_should_return_a_unique_index () {
+                var database = Setup();
+                var id1 = database.GetUniqueIndex();
+                var id2 = database.GetUniqueIndex();
+
+                Assert.AreNotEqual(id1, id2);
+            }
+        }
+
+        public class Save_Method : ItemDatabaseTest {
+            [Test]
+            public void It_should_save_the_database () {
+                var expected = JsonUtility.ToJson(new ItemDatabaseSaveData {
+                    idIndex = 1
+                });
+
+                var database = Setup();
+                database.GetUniqueIndex();
+                var save = database.Save();
+
+                Assert.AreEqual(expected, save);
+            }
+        }
+
+        public class Load_Method : ItemDatabaseTest {
+            [Test]
+            public void It_should_restore_a_saved_database () {
+                var database = Setup();
+                database.GetUniqueIndex();
+                var save = database.Save();
+
+                var database2 = Setup();
+                database2.Load(save);
+
+                Assert.AreEqual(database.GetUniqueIndex(), database2.GetUniqueIndex());
+            }
+        }
+    }
+}
diff --git a/Tests/Editor/Scripts/ItemDatabaseTest.cs.meta b/Tests/Editor/Scripts/ItemDatabaseTest.cs.meta
new file mode 100644
index 0000000..3d0f459
--- /dev/null
+++ b/Tests/Editor/Scripts/ItemDatabaseTest.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 41d59af00f6e4041bd7b7d819ed58161
+timeCreated: 1688403075
\ No newline at end of file
diff --git a/Tests/Editor/Utilities.meta b/Tests/Editor/Utilities.meta
new file mode 100644
index 0000000..a718596
--- /dev/null
+++ b/Tests/Editor/Utilities.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 76277476bf2b04303b3e4e8385f028ca
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Tests/Editor/Utilities/Builders.meta b/Tests/Editor/Utilities/Builders.meta
new file mode 100644
index 0000000..4fa771d
--- /dev/null
+++ b/Tests/Editor/Utilities/Builders.meta
@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 921b082d8cf3f453c92ec8eca37b7908
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Tests/Editor/Utilities/Builders/A.cs b/Tests/Editor/Utilities/Builders/A.cs
new file mode 100644
index 0000000..a2546e6
--- /dev/null
+++ b/Tests/Editor/Utilities/Builders/A.cs
@@ -0,0 +1,19 @@
+namespace CleverCrow.Fluid.ElasticInventory.Testing {
+    public static class A {
+        public static ItemDefinitionBuilder ItemDefinition () {
+            return new ItemDefinitionBuilder();
+        }
+
+        public static ItemEntryReadOnlyBuilder ItemEntryReadOnly () {
+            return new ItemEntryReadOnlyBuilder();
+        }
+
+        public static ItemEntryBuilder ItemEntry () {
+            return new ItemEntryBuilder();
+        }
+
+        public static ItemDatabaseBuilder ItemDatabase () {
+            return new ItemDatabaseBuilder();
+        }
+    }
+}
diff --git a/Tests/Editor/Utilities/Builders/A.cs.meta b/Tests/Editor/Utilities/Builders/A.cs.meta
new file mode 100644
index 0000000..6b8b070
--- /dev/null
+++ b/Tests/Editor/Utilities/Builders/A.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e4ee55c35146f4c60b0fa89e077995d9
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Tests/Editor/Utilities/Builders/ItemDatabaseBuilder.cs b/Tests/Editor/Utilities/Builders/ItemDatabaseBuilder.cs
new file mode 100644
index 0000000..89b805d
--- /dev/null
+++ b/Tests/Editor/Utilities/Builders/ItemDatabaseBuilder.cs
@@ -0,0 +1,9 @@
+using NSubstitute;
+
+namespace CleverCrow.Fluid.ElasticInventory.Testing {
+    public class ItemDatabaseBuilder {
+        public IItemDatabase Build () {
+            return Substitute.For<IItemDatabase>();
+        }
+    }
+}
diff --git a/Tests/Editor/Utilities/Builders/ItemDatabaseBuilder.cs.meta b/Tests/Editor/Utilities/Builders/ItemDatabaseBuilder.cs.meta
new file mode 100644
index 0000000..c665710
--- /dev/null
+++ b/Tests/Editor/Utilities/Builders/ItemDatabaseBuilder.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 943137f941274b64ae1a8c303d81f579
+timeCreated: 1688406945
\ No newline at end of file
diff --git a/Tests/Editor/Utilities/Builders/ItemDefinitionBuilder.cs b/Tests/Editor/Utilities/Builders/ItemDefinitionBuilder.cs
new file mode 100644
index 0000000..a518d4f
--- /dev/null
+++ b/Tests/Editor/Utilities/Builders/ItemDefinitionBuilder.cs
@@ -0,0 +1,82 @@
+using System;
+using NSubstitute;
+
+namespace CleverCrow.Fluid.ElasticInventory.Testing {
+    public class ItemDefinitionBuilder {
+        IItemEntry _itemEntry;
+        string _id = System.Guid.NewGuid().ToString();
+        bool _unique;
+        string _category = "Generic";
+        string _displayName = "Item";
+
+        public IItemDefinition Build () {
+            var definition = Substitute.For<IItemDefinition>();
+
+            definition.Id.Returns(_id);
+            definition.Unique.Returns(_unique);
+            definition.Category.Returns(_category);
+            definition.DisplayName.Returns(_displayName);
+
+            _itemEntry?.Definition.Returns(definition);
+
+            definition.CreateItemEntry(
+                Arg.Any<IItemDatabase>(),
+                Arg.Any<int>(),
+                Arg.Any<string>(),
+                Arg.Any<int?>(),
+                Arg.Any<int?>()
+            ).Returns(info => {
+                if (_itemEntry == null) {
+                    var entry = new ItemEntry();
+                    IItemDatabase db = info.ArgAt<IItemDatabase>(0);
+                    int arg0 = info.ArgAt<int>(1);
+                    string arg1 = info.ArgAt<string>(2);
+                    int? arg2 = info.ArgAt<int?>(3);
+                    int? arg3 = info.ArgAt<int?>(4);
+
+                    if (!arg2.HasValue && !arg3.HasValue) {
+                        entry.Setup(db, definition, arg0, arg1);
+                    } else if (!arg3.HasValue) {
+                        entry.Setup(db, definition, arg0, arg1, arg2.Value);
+                    } else {
+                        entry.Setup(db, definition, arg0, arg1, arg2.Value, arg3.Value);
+                    }
+
+                    return entry;
+                }
+
+                return _itemEntry;
+            });
+
+            var dataResolver = new ItemEntryDataResolver();
+            definition.DataResolver.Returns(dataResolver);
+
+            return definition;
+        }
+
+        public ItemDefinitionBuilder WithItemEntry (IItemEntry entry) {
+            _itemEntry = entry;
+            return this;
+        }
+
+        public ItemDefinitionBuilder WithId (string id) {
+            _id = id;
+            return this;
+        }
+
+        public ItemDefinitionBuilder WithUnique (bool unique) {
+            _unique = unique;
+            return this;
+        }
+
+        public ItemDefinitionBuilder WithCategory (string category) {
+            _category = category;
+            return this;
+        }
+
+        public ItemDefinitionBuilder WithDisplayName (string displayName) {
+            _displayName = displayName;
+            return this;
+        }
+    }
+}
diff --git a/Tests/Editor/Utilities/Builders/ItemDefinitionBuilder.cs.meta b/Tests/Editor/Utilities/Builders/ItemDefinitionBuilder.cs.meta
new file mode 100644
index 0000000..f444630
--- /dev/null
+++ b/Tests/Editor/Utilities/Builders/ItemDefinitionBuilder.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 40ba7681f71884569a44d84b5aab1c42
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Tests/Editor/Utilities/Builders/ItemEntryBuilder.cs b/Tests/Editor/Utilities/Builders/ItemEntryBuilder.cs
new file mode 100644
index 0000000..946e343
--- /dev/null
+++ b/Tests/Editor/Utilities/Builders/ItemEntryBuilder.cs
@@ -0,0 +1,48 @@
+using System;
+using NSubstitute;
+
+namespace CleverCrow.Fluid.ElasticInventory.Testing {
+    public class ItemEntryBuilder {
+        private IItemDefinition _definition = A.ItemDefinition().Build();
+        private int _quantity = 1;
+        private string _id = Guid.NewGuid().ToString();
+        int _createdAt;
+        int _updatedAt;
+
+        public IItemEntry Build () {
+            var entry = Substitute.For<IItemEntry>();
+            entry.Definition.Returns(_definition);
+            entry.Quantity.Returns(_quantity);
+            entry.Id.Returns(_id);
+            entry.CreatedAt.Returns(_createdAt);
+            entry.UpdatedAt.Returns(_updatedAt);
+
+            return entry;
+        }
+
+        public ItemEntryBuilder WithDefinition (IItemDefinition definition) {
+            _definition = definition;
+            return this;
+        }
+
+        public ItemEntryBuilder WithQuantity (int quantity) {
+            _quantity = quantity;
+            return this;
+        }
+
+        public ItemEntryBuilder WithId (string id) {
+            _id = id;
+            return this;
+        }
+
+        public ItemEntryBuilder WithCreatedAt (int createdAt) {
+            _createdAt = createdAt;
+            return this;
+        }
+
+        public ItemEntryBuilder WithUpdatedAt (int updatedAt) {
+            _updatedAt = updatedAt;
+            return this;
+        }
+    }
+}
diff --git a/Tests/Editor/Utilities/Builders/ItemEntryBuilder.cs.meta b/Tests/Editor/Utilities/Builders/ItemEntryBuilder.cs.meta
new file mode 100644
index 0000000..5a1be75
--- /dev/null
+++ b/Tests/Editor/Utilities/Builders/ItemEntryBuilder.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: a795bbf4b3d94a368b42d42f5b778422
+timeCreated: 1686620846
\ No newline at end of file
diff --git a/Tests/Editor/Utilities/Builders/ItemEntryReadOnlyBuilder.cs b/Tests/Editor/Utilities/Builders/ItemEntryReadOnlyBuilder.cs
new file mode 100644
index 0000000..85387eb
--- /dev/null
+++ b/Tests/Editor/Utilities/Builders/ItemEntryReadOnlyBuilder.cs
@@ -0,0 +1,30 @@
+using NSubstitute;
+
+namespace CleverCrow.Fluid.ElasticInventory.Testing {
+    public class ItemEntryReadOnlyBuilder {
+        IItemDefinition _definition = A.ItemDefinition().Build();
+        int _quantity = 1;
+
+        public IItemEntryReadOnly Build () {
+            var entry = Substitute.For<IItemEntryReadOnly>();
+
+            entry.Definition.Returns(_definition);
+            entry.Quantity.Returns(_quantity);
+            entry.Id.Returns(System.Guid.NewGuid().ToString());
+            entry.CreatedAt.Returns(0);
+            entry.UpdatedAt.Returns(0);
+
+            return entry;
+        }
+
+        public ItemEntryReadOnlyBuilder WithDefinition (IItemDefinition definition) {
+            _definition = definition;
+            return this;
+        }
+
+        public ItemEntryReadOnlyBuilder WithQuantity (int quantity) {
+            _quantity = quantity;
+            return this;
+        }
+    }
+}
diff --git a/Tests/Editor/Utilities/Builders/ItemEntryReadOnlyBuilder.cs.meta b/Tests/Editor/Utilities/Builders/ItemEntryReadOnlyBuilder.cs.meta
new file mode 100644
index 0000000..8daba54
--- /dev/null
+++ b/Tests/Editor/Utilities/Builders/ItemEntryReadOnlyBuilder.cs.meta
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 7fed6ce064a748d8b852972088f05f79
+timeCreated: 1686012537
\ No newline at end of file
diff --git a/Tests/Editor/com.fluid.elastic-inventory.Editor.Tests.asmdef b/Tests/Editor/com.fluid.elastic-inventory.Editor.Tests.asmdef
new file mode 100755
index 0000000..5866450
--- /dev/null
+++ b/Tests/Editor/com.fluid.elastic-inventory.Editor.Tests.asmdef
@@ -0,0 +1,28 @@
+{
+    "name": "com.fluid.elastic-inventory.Editor.Tests",
+    "rootNamespace": "",
+    "references": [
+        "com.fluid.elastic-inventory",
+        "com.fluid.elastic-inventory.Editor",
+        "UnityEngine.TestRunner",
+        "UnityEditor.TestRunner",
+        "com.fluid.database",
+        "com.fluid.unity-event-plus"
+    ],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": true,
+    "precompiledReferences": [
+        "nunit.framework.dll",
+        "NSubstitute.dll"
+    ],
+    "autoReferenced": false,
+    "defineConstraints": [
+        "UNITY_INCLUDE_TESTS"
+    ],
+    "versionDefines": [],
+    "noEngineReferences": false
+}
\ No newline at end of file
diff --git a/Tests/Editor/com.fluid.elastic-inventory.Editor.Tests.asmdef.meta b/Tests/Editor/com.fluid.elastic-inventory.Editor.Tests.asmdef.meta
new file mode 100644
index 0000000..8a28df6
--- /dev/null
+++ b/Tests/Editor/com.fluid.elastic-inventory.Editor.Tests.asmdef.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 7698c039115c44c839d4d328ff778503
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/package.json b/package.json
new file mode 100755
index 0000000..932cbca
--- /dev/null
+++ b/package.json
@@ -0,0 +1,11 @@
+{
+  "name": "com.fluid.elastic-inventory",
+  "version": "0.0.0",
+  "displayName": "Elastic Inventory",
+  "description": "A simple inventory micro-framework built with extendability in mind",
+  "unity": "2022.2",
+  "dependencies": {
+      "com.fluid.simple-settings": "1.0.1",
+      "com.fluid.database": "2.1.0"
+  }
+}
diff --git a/package.json.meta b/package.json.meta
new file mode 100644
index 0000000..ff95db0
--- /dev/null
+++ b/package.json.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 8311c1e1af64f4832bcc6ac527faca46
+TextScriptImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: