diff --git a/InteractiveAutomationToolkit/Components/Generics/GenericTreeView.cs b/InteractiveAutomationToolkit/Components/Generics/GenericTreeView.cs
new file mode 100644
index 0000000..17ab95b
--- /dev/null
+++ b/InteractiveAutomationToolkit/Components/Generics/GenericTreeView.cs
@@ -0,0 +1,654 @@
+namespace Skyline.DataMiner.Utils.InteractiveAutomationScript
+{
+	using System;
+	using System.Collections.Generic;
+	using System.Linq;
+
+	using Skyline.DataMiner.Automation;
+	using Skyline.DataMiner.Net.AutomationUI.Objects;
+
+	/// <summary>
+	///     A generic tree view structure that allows attaching custom metadata to each item.
+	/// </summary>
+	/// <typeparam name="T">The type of the value associated with each tree view item.</typeparam>
+	public class TreeView<T> : InteractiveWidget, IIsReadonlyWidget
+	{
+		private Dictionary<string, bool> checkedItemCache;
+		private Dictionary<string, bool> collapsedItemCache;
+		private Dictionary<string, TreeViewItemOption<T>> lookupTable;
+
+		private bool itemsChanged = false;
+		private List<TreeViewItemOption<T>> changedItems = new List<TreeViewItemOption<T>>();
+
+		private bool itemsChecked = false;
+		private List<TreeViewItemOption<T>> checkedItems = new List<TreeViewItemOption<T>>();
+
+		private bool itemsUnchecked = false;
+		private List<TreeViewItemOption<T>> uncheckedItems = new List<TreeViewItemOption<T>>();
+
+		private bool itemsExpanded = false;
+		private List<TreeViewItemOption<T>> expandedItems = new List<TreeViewItemOption<T>>();
+
+		private bool itemsCollapsed = false;
+		private List<TreeViewItemOption<T>> collapsedItems = new List<TreeViewItemOption<T>>();
+
+		/// <summary>
+		///     Initializes a new instance of the <see cref="TreeView{T}" /> class.
+		/// </summary>
+		public TreeView() : this(Enumerable.Empty<TreeViewItemOption<T>>())
+		{
+		}
+
+		/// <summary>
+		///     Initializes a new instance of the <see cref="TreeView{T}" /> class.
+		/// </summary>
+		/// <param name="treeViewItems">Root nodes of the tree view.</param>
+		public TreeView(IEnumerable<TreeViewItemOption<T>> treeViewItems)
+		{
+			Type = UIBlockType.TreeView;
+			Items = treeViewItems;
+			IsReadOnly = false;
+		}
+
+		/// <summary>
+		///     Triggered when a different item is selected or no longer selected.
+		///     WantsOnChange will be set to true when this event is subscribed to.
+		/// </summary>
+		public event EventHandler<IEnumerable<TreeViewItemOption<T>>> Changed
+		{
+			add
+			{
+				OnChanged += value;
+				BlockDefinition.WantsOnChange = true;
+			}
+
+			remove
+			{
+				OnChanged -= value;
+				if (OnChanged == null || !OnChanged.GetInvocationList().Any())
+				{
+					BlockDefinition.WantsOnChange = false;
+				}
+			}
+		}
+
+		/// <summary>
+		///     Triggered whenever an item is selected.
+		///     WantsOnChange will be set to true when this event is subscribed to.
+		/// </summary>
+		public event EventHandler<IEnumerable<TreeViewItemOption<T>>> Checked
+		{
+			add
+			{
+				OnChecked += value;
+				BlockDefinition.WantsOnChange = true;
+			}
+
+			remove
+			{
+				OnChecked -= value;
+				if (OnChecked == null || !OnChecked.GetInvocationList().Any())
+				{
+					BlockDefinition.WantsOnChange = false;
+				}
+			}
+		}
+
+		/// <summary>
+		///     Triggered whenever an item is no longer selected.
+		///     WantsOnChange will be set to true when this event is subscribed to.
+		/// </summary>
+		public event EventHandler<IEnumerable<TreeViewItemOption<T>>> Unchecked
+		{
+			add
+			{
+				OnUnchecked += value;
+				BlockDefinition.WantsOnChange = true;
+			}
+
+			remove
+			{
+				OnUnchecked -= value;
+				if (OnUnchecked == null || !OnUnchecked.GetInvocationList().Any())
+				{
+					BlockDefinition.WantsOnChange = false;
+				}
+			}
+		}
+
+		/// <summary>
+		///     Triggered whenever an item is expanded.
+		///     Can be used for lazy loading.
+		///     Will be triggered whenever a node with SupportsLazyLoading set to true is expanded.
+		/// </summary>
+		public event EventHandler<IEnumerable<TreeViewItemOption<T>>> Expanded
+		{
+			add
+			{
+				OnExpanded += value;
+			}
+
+			remove
+			{
+				OnExpanded -= value;
+			}
+		}
+
+		/// <summary>
+		///     Triggered whenever an item is collapsed.
+		///     Will be triggered whenever a node with SupportsLazyLoading set to true is collapsed.
+		/// </summary>
+		public event EventHandler<IEnumerable<TreeViewItemOption<T>>> Collapsed
+		{
+			add
+			{
+				OnCollapsed += value;
+			}
+
+			remove
+			{
+				OnCollapsed -= value;
+			}
+		}
+
+		private event EventHandler<IEnumerable<TreeViewItemOption<T>>> OnChanged;
+
+		private event EventHandler<IEnumerable<TreeViewItemOption<T>>> OnChecked;
+
+		private event EventHandler<IEnumerable<TreeViewItemOption<T>>> OnUnchecked;
+
+		private event EventHandler<IEnumerable<TreeViewItemOption<T>>> OnExpanded;
+
+		private event EventHandler<IEnumerable<TreeViewItemOption<T>>> OnCollapsed;
+
+		/// <summary>
+		///     Gets or sets the top-level items in the tree view.
+		///     The TreeViewItemOption.Item.ChildItems property can be used to navigate further down the tree.
+		/// </summary>
+		public IEnumerable<TreeViewItemOption<T>> Items
+		{
+			get
+			{
+				// Return the TreeViewItemOption wrappers based on the underlying TreeViewItems
+				return BlockDefinition.TreeViewItems.Select(item => lookupTable.Values.FirstOrDefault(x => x.Item == item))
+					.Where(x => x != null);
+			}
+
+			set
+			{
+				if (value == null)
+				{
+					throw new ArgumentNullException(nameof(value));
+				}
+
+				BlockDefinition.TreeViewItems = new List<TreeViewItem>(value.Select(x => x.Item));
+				UpdateItemCache(value);
+			}
+		}
+
+		/// <summary>
+		///     Gets all items in the tree view that are selected.
+		/// </summary>
+		public IEnumerable<TreeViewItemOption<T>> CheckedItems
+		{
+			get
+			{
+				return GetCheckedItems();
+			}
+		}
+
+		/// <summary>
+		///     Gets all leaves (= items without children) in the tree view that are selected.
+		/// </summary>
+		public IEnumerable<TreeViewItemOption<T>> CheckedLeaves
+		{
+			get
+			{
+				return GetCheckedItems().Where(x => !x.ChildItems.Any());
+			}
+		}
+
+		/// <summary>
+		///     Gets all nodes (= items with children) in the tree view that are selected.
+		/// </summary>
+		public IEnumerable<TreeViewItemOption<T>> CheckedNodes
+		{
+			get
+			{
+				return GetCheckedItems().Where(x => x.ChildItems.Any());
+			}
+		}
+
+		/// <summary>
+		///     Gets the values of all items in the tree view that are selected.
+		/// </summary>
+		public IEnumerable<T> CheckedValues
+		{
+			get
+			{
+				return GetCheckedItems().Select(x => x.Value);
+			}
+		}
+
+		/// <summary>
+		///     Gets the values of all leaves in the tree view that are selected.
+		/// </summary>
+		public IEnumerable<T> CheckedLeafValues
+		{
+			get
+			{
+				return CheckedLeaves.Select(x => x.Value);
+			}
+		}
+
+		/// <summary>
+		///     Gets the values of all nodes in the tree view that are selected.
+		/// </summary>
+		public IEnumerable<T> CheckedNodeValues
+		{
+			get
+			{
+				return CheckedNodes.Select(x => x.Value);
+			}
+		}
+
+		/// <summary>
+		///     Gets or sets the tooltip.
+		/// </summary>
+		/// <exception cref="ArgumentNullException">When the value is <c>null</c>.</exception>
+		public string Tooltip
+		{
+			get
+			{
+				return BlockDefinition.TooltipText;
+			}
+
+			set
+			{
+				if (value == null)
+				{
+					throw new ArgumentNullException(nameof(value));
+				}
+
+				BlockDefinition.TooltipText = value;
+			}
+		}
+
+		/// <inheritdoc/>
+		public virtual bool IsReadOnly
+		{
+			get
+			{
+				return BlockDefinition.IsReadOnly;
+			}
+
+			set
+			{
+				BlockDefinition.IsReadOnly = value;
+			}
+		}
+
+		/// <summary>
+		///     Sets the IsCollapsed state for all items in the tree view to true, causing the entire tree view to be collapsed.
+		/// </summary>
+		public void Collapse()
+		{
+			foreach (var item in GetAllItems())
+			{
+				item.IsCollapsed = true;
+			}
+		}
+
+		/// <summary>
+		///     Sets the IsCollapsed state for all items in the tree view to false, causing the entire tree view to be expanded.
+		/// </summary>
+		public void Expand()
+		{
+			foreach (var item in GetAllItems())
+			{
+				item.IsCollapsed = false;
+			}
+		}
+
+		/// <summary>
+		///     Can be used to retrieve an item from the tree view based on its key value.
+		/// </summary>
+		/// <param name="key">Key used to search for the item.</param>
+		/// <param name="item">Item in the tree that matches the provided key.</param>
+		/// <returns>True if the item was found, otherwise false.</returns>
+		public bool TryFindTreeViewItem(string key, out TreeViewItemOption<T> item)
+		{
+			return lookupTable.TryGetValue(key, out item);
+		}
+
+		/// <summary>
+		///     This method is used to update the cached TreeViewItems and lookup table.
+		///     This is done after loading the results from the UI Block, after handling the Events or when setting the Items.
+		///     This method should only be called from outside the TreeView if you are checking or collapsing items from outside of the TreeView and need to access the CheckedItems or CollapsedItems.
+		/// </summary>
+		public void UpdateItemCache()
+		{
+			UpdateItemCache(Items);
+		}
+
+		/// <summary>
+		///     Iterates over all items in the tree and returns them in a flat collection.
+		/// </summary>
+		/// <returns>A flat collection containing all items in the tree view.</returns>
+		public IEnumerable<TreeViewItemOption<T>> GetAllItems()
+		{
+			return lookupTable.Values;
+		}
+
+		/// <summary>
+		///     Returns all items in the tree view that are located at the provided depth.
+		///     Whenever the requested depth is greater than the longest branch in the tree, an empty collection will be returned.
+		/// </summary>
+		/// <param name="depth">Depth of the requested items.</param>
+		/// <returns>All items in the tree view that are located at the provided depth.</returns>
+		public IEnumerable<TreeViewItemOption<T>> GetItems(int depth)
+		{
+			return GetItems(Items, depth, 0);
+		}
+
+		/// <summary>
+		///     Load any changes made through user interaction.
+		/// </summary>
+		/// <param name="uiResults">
+		///     Represents the information a user has entered or selected in a dialog box of an interactive
+		///     Automation script.
+		/// </param>
+		/// <remarks><see cref="InteractiveWidget.DestVar" /> should be used as key to get the changes for this widget.</remarks>
+		protected internal override void LoadResult(IUIResults uiResults)
+		{
+			var checkedItemKeys = uiResults.GetCheckedItemKeys(this);
+			var expandedItemKeys = uiResults.GetExpandedItemKeys(this);
+
+			// Check for changes
+			// Expanded Items
+			RegisterExpandedItems(expandedItemKeys);
+
+			// Collapsed Items
+			RegisterCollapsedItems(expandedItemKeys);
+
+			// Checked Items
+			List<string> newlyCheckedItemKeys = RegisterCheckedItems(checkedItemKeys);
+
+			// Unchecked Items
+			List<string> newlyUncheckedItemKeys = RegisterUncheckedItems(checkedItemKeys);
+
+			// Changed Items
+			List<string> changedItemKeys = new List<string>();
+			changedItemKeys.AddRange(newlyCheckedItemKeys);
+			changedItemKeys.AddRange(newlyUncheckedItemKeys);
+			if (changedItemKeys.Any() && OnChanged != null)
+			{
+				itemsChanged = true;
+				changedItems = new List<TreeViewItemOption<T>>();
+
+				foreach (string changedItemKey in changedItemKeys)
+				{
+					if (lookupTable.TryGetValue(changedItemKey, out var item))
+					{
+						changedItems.Add(item);
+					}
+				}
+			}
+
+			// Persist states
+			foreach (TreeViewItemOption<T> item in lookupTable.Values)
+			{
+				item.Item.IsChecked = checkedItemKeys.Contains(item.KeyValue);
+				item.Item.IsCollapsed = !expandedItemKeys.Contains(item.KeyValue);
+			}
+
+			UpdateItemCache();
+		}
+
+		/// <summary>
+		///     Raises zero or more events of the widget.
+		///     This method is called after <see cref="InteractiveWidget.LoadResult" /> was called on all widgets.
+		/// </summary>
+		/// <remarks>It is up to the implementer to determine if an event must be raised.</remarks>
+		protected internal override void RaiseResultEvents()
+		{
+			// Expanded items
+			if (itemsExpanded && OnExpanded != null)
+			{
+				OnExpanded(this, expandedItems);
+			}
+
+			// Collapsed items
+			if (itemsCollapsed && OnCollapsed != null)
+			{
+				OnCollapsed(this, collapsedItems);
+			}
+
+			// Checked items
+			if (itemsChecked && OnChecked != null)
+			{
+				OnChecked(this, checkedItems);
+			}
+
+			// Unchecked items
+			if (itemsUnchecked && OnUnchecked != null)
+			{
+				OnUnchecked(this, uncheckedItems);
+			}
+
+			// Changed items
+			if (itemsChanged && OnChanged != null)
+			{
+				OnChanged(this, changedItems);
+			}
+
+			itemsExpanded = false;
+			itemsCollapsed = false;
+			itemsChecked = false;
+			itemsUnchecked = false;
+			itemsChanged = false;
+
+			UpdateItemCache();
+		}
+
+		/// <summary>
+		///     Returns all items in the TreeView that are checked.
+		/// </summary>
+		/// <returns>All checked TreeViewItems in the TreeView.</returns>
+		private IEnumerable<TreeViewItemOption<T>> GetCheckedItems()
+		{
+			return lookupTable.Values.Where(x => x.ItemType == TreeViewItem.TreeViewItemType.CheckBox && x.IsChecked);
+		}
+
+		/// <summary>
+		///     This method is used to recursively go through all the items in the TreeView.
+		/// </summary>
+		/// <param name="children">List of TreeViewItems to be visited.</param>
+		/// <param name="parentOptions">Parent TreeViewItemOption wrappers.</param>
+		/// <returns>Flat collection containing every item in the provided children collection and all underlying items.</returns>
+		private IEnumerable<TreeViewItemOption<T>> GetAllItemsRecursive(IEnumerable<TreeViewItem> children, IEnumerable<TreeViewItemOption<T>> parentOptions)
+		{
+			List<TreeViewItemOption<T>> allItems = new List<TreeViewItemOption<T>>();
+			foreach (var item in children)
+			{
+				var option = parentOptions.FirstOrDefault(x => x.Item == item);
+				if (option != null)
+				{
+					allItems.Add(option);
+					// For child items, we need to search in the lookup table
+					var childOptions = option.ChildItems.Select(child => lookupTable.Values.FirstOrDefault(x => x.Item == child)).Where(x => x != null);
+					allItems.AddRange(GetAllItemsRecursive(option.ChildItems, childOptions));
+				}
+			}
+
+			return allItems;
+		}
+
+		/// <summary>
+		///     Returns all TreeViewItems in the TreeView that are located on the provided depth.
+		/// </summary>
+		/// <param name="children">Items to be checked.</param>
+		/// <param name="requestedDepth">Depth that was requested.</param>
+		/// <param name="currentDepth">Current depth in the tree.</param>
+		/// <returns>All TreeViewItems in the TreeView that are located on the provided depth.</returns>
+		private IEnumerable<TreeViewItemOption<T>> GetItems(IEnumerable<TreeViewItemOption<T>> children, int requestedDepth, int currentDepth)
+		{
+			List<TreeViewItemOption<T>> requestedItems = new List<TreeViewItemOption<T>>();
+			bool depthReached = requestedDepth == currentDepth;
+			foreach (TreeViewItemOption<T> item in children)
+			{
+				if (depthReached)
+				{
+					requestedItems.Add(item);
+				}
+				else
+				{
+					int newDepth = currentDepth + 1;
+					var childOptions = item.ChildItems.Select(child => lookupTable.Values.FirstOrDefault(x => x.Item == child)).Where(x => x != null);
+					requestedItems.AddRange(GetItems(childOptions, requestedDepth, newDepth));
+				}
+			}
+
+			return requestedItems;
+		}
+
+		private void RegisterExpandedItems(IEnumerable<string> expandedItemKeys)
+		{
+			List<string> newlyExpandedItems = collapsedItemCache.Where(x => expandedItemKeys.Contains(x.Key) && x.Value).Select(x => x.Key).ToList();
+			if (newlyExpandedItems.Any() && OnExpanded != null)
+			{
+				itemsExpanded = true;
+				expandedItems = new List<TreeViewItemOption<T>>();
+
+				foreach (string newlyExpandedItemKey in newlyExpandedItems)
+				{
+					if (lookupTable.TryGetValue(newlyExpandedItemKey, out var item))
+					{
+						expandedItems.Add(item);
+					}
+				}
+			}
+		}
+
+		private void RegisterCollapsedItems(IEnumerable<string> expandedItemKeys)
+		{
+			List<string> newlyCollapsedItems = collapsedItemCache.Where(x => !expandedItemKeys.Contains(x.Key) && !x.Value).Select(x => x.Key).ToList();
+			if (newlyCollapsedItems.Any() && OnCollapsed != null)
+			{
+				itemsCollapsed = true;
+				collapsedItems = new List<TreeViewItemOption<T>>();
+
+				foreach (string newlyCollapsedItemKey in newlyCollapsedItems)
+				{
+					if (lookupTable.TryGetValue(newlyCollapsedItemKey, out var item))
+					{
+						collapsedItems.Add(item);
+					}
+				}
+			}
+		}
+
+		private List<string> RegisterCheckedItems(IEnumerable<string> checkedItemKeys)
+		{
+			List<string> newlyCheckedItemKeys = checkedItemCache.Where(x => checkedItemKeys.Contains(x.Key) && !x.Value).Select(x => x.Key).ToList();
+			if (newlyCheckedItemKeys.Any() && OnChecked != null)
+			{
+				itemsChecked = true;
+				checkedItems = new List<TreeViewItemOption<T>>();
+
+				foreach (string newlyCheckedItemKey in newlyCheckedItemKeys)
+				{
+					if (lookupTable.TryGetValue(newlyCheckedItemKey, out var item))
+					{
+						checkedItems.Add(item);
+					}
+				}
+			}
+
+			return newlyCheckedItemKeys;
+		}
+
+		private List<string> RegisterUncheckedItems(IEnumerable<string> checkedItemKeys)
+		{
+			List<string> newlyUncheckedItemKeys = checkedItemCache.Where(x => !checkedItemKeys.Contains(x.Key) && x.Value).Select(x => x.Key).ToList();
+			if (newlyUncheckedItemKeys.Any() && OnUnchecked != null)
+			{
+				itemsUnchecked = true;
+				uncheckedItems = new List<TreeViewItemOption<T>>();
+
+				foreach (string newlyUncheckedItemKey in newlyUncheckedItemKeys)
+				{
+					if (lookupTable.TryGetValue(newlyUncheckedItemKey, out var item))
+					{
+						uncheckedItems.Add(item);
+					}
+				}
+			}
+
+			return newlyUncheckedItemKeys;
+		}
+
+		private void UpdateItemCache(IEnumerable<TreeViewItemOption<T>> items)
+		{
+			checkedItemCache = new Dictionary<string, bool>();
+			collapsedItemCache = new Dictionary<string, bool>();
+			lookupTable = new Dictionary<string, TreeViewItemOption<T>>();
+
+			BuildLookupTable(items);
+
+			foreach (var item in lookupTable.Values)
+			{
+				try
+				{
+					checkedItemCache.Add(item.KeyValue, item.IsChecked);
+					if (item.SupportsLazyLoading)
+					{
+						collapsedItemCache.Add(item.KeyValue, item.IsCollapsed);
+					}
+				}
+				catch (Exception e)
+				{
+					throw new TreeViewDuplicateItemsException(item.KeyValue, e);
+				}
+			}
+		}
+
+		private void BuildLookupTable(IEnumerable<TreeViewItemOption<T>> items)
+		{
+			foreach (var item in items)
+			{
+				lookupTable[item.KeyValue] = item;
+				
+				// Recursively process children
+				var childOptions = item.ChildItems.Select(child =>
+				{
+					// Try to find existing wrapper or create a temporary one
+					var existing = lookupTable.Values.FirstOrDefault(x => x.Item == child);
+					return existing;
+				}).Where(x => x != null);
+
+				if (item.ChildItems.Any())
+				{
+					// For children that don't have wrappers yet, we need to handle them
+					// This is a limitation - child items added directly to TreeViewItem won't have metadata
+					BuildLookupTableFromTreeViewItems(item.ChildItems);
+				}
+			}
+		}
+
+		private void BuildLookupTableFromTreeViewItems(IEnumerable<TreeViewItem> items)
+		{
+			foreach (var item in items)
+			{
+				if (!lookupTable.ContainsKey(item.KeyValue))
+				{
+					// Create a wrapper with default value for items without explicit metadata
+					var wrapper = new TreeViewItemOption<T>(item, default(T));
+					lookupTable[item.KeyValue] = wrapper;
+				}
+
+				BuildLookupTableFromTreeViewItems(item.ChildItems);
+			}
+		}
+	}
+}
diff --git a/InteractiveAutomationToolkit/Components/TreeViewItemOption.cs b/InteractiveAutomationToolkit/Components/TreeViewItemOption.cs
new file mode 100644
index 0000000..423b9ff
--- /dev/null
+++ b/InteractiveAutomationToolkit/Components/TreeViewItemOption.cs
@@ -0,0 +1,199 @@
+namespace Skyline.DataMiner.Utils.InteractiveAutomationScript
+{
+	using System;
+	using System.Collections.Generic;
+	using System.Linq;
+
+	using Skyline.DataMiner.Net.AutomationUI.Objects;
+
+	/// <summary>
+	///     Represents a TreeViewItem with an associated value of type <typeparamref name="T"/>.
+	///     This allows attaching custom metadata to tree view items.
+	/// </summary>
+	/// <typeparam name="T">The type of the value associated with this tree view item.</typeparam>
+	public sealed class TreeViewItemOption<T> : IEquatable<TreeViewItemOption<T>>
+	{
+		/// <summary>
+		///     Initializes a new instance of the <see cref="TreeViewItemOption{T}"/> class.
+		/// </summary>
+		/// <param name="item">The underlying TreeViewItem.</param>
+		/// <param name="value">The value to associate with this tree view item.</param>
+		/// <exception cref="ArgumentNullException">When item is null.</exception>
+		public TreeViewItemOption(TreeViewItem item, T value)
+		{
+			Item = item ?? throw new ArgumentNullException(nameof(item));
+			Value = value;
+		}
+
+		/// <summary>
+		///     Initializes a new instance of the <see cref="TreeViewItemOption{T}"/> class.
+		///     Creates a TreeViewItem with the specified parameters.
+		/// </summary>
+		/// <param name="keyValue">The unique key for the tree view item.</param>
+		/// <param name="displayValue">The text to display for the tree view item.</param>
+		/// <param name="value">The value to associate with this tree view item.</param>
+		/// <param name="itemType">The type of the tree view item.</param>
+		/// <param name="childItems">The child items of this tree view item.</param>
+		/// <exception cref="ArgumentNullException">When keyValue or displayValue is null.</exception>
+		public TreeViewItemOption(
+			string keyValue,
+			string displayValue,
+			T value,
+			TreeViewItem.TreeViewItemType itemType = TreeViewItem.TreeViewItemType.CheckBox,
+			IEnumerable<TreeViewItemOption<T>> childItems = null)
+		{
+			if (keyValue == null)
+			{
+				throw new ArgumentNullException(nameof(keyValue));
+			}
+
+			if (displayValue == null)
+			{
+				throw new ArgumentNullException(nameof(displayValue));
+			}
+
+			var children = childItems?.Select(x => x.Item).ToList() ?? new List<TreeViewItem>();
+			Item = new TreeViewItem(displayValue, keyValue, children)
+			{
+				ItemType = itemType
+			};
+			Value = value;
+		}
+
+		/// <summary>
+		///     Gets the underlying TreeViewItem.
+		/// </summary>
+		public TreeViewItem Item { get; }
+
+		/// <summary>
+		///     Gets the value associated with this tree view item.
+		/// </summary>
+		public T Value { get; }
+
+		/// <summary>
+		///     Gets or sets the unique key for the tree view item.
+		/// </summary>
+		public string KeyValue
+		{
+			get => Item.KeyValue;
+			set => Item.KeyValue = value;
+		}
+
+		/// <summary>
+		///     Gets or sets the text to display for the tree view item.
+		/// </summary>
+		public string DisplayValue
+		{
+			get => Item.DisplayValue;
+			set => Item.DisplayValue = value;
+		}
+
+		/// <summary>
+		///     Gets or sets the type of the tree view item.
+		/// </summary>
+		public TreeViewItem.TreeViewItemType ItemType
+		{
+			get => Item.ItemType;
+			set => Item.ItemType = value;
+		}
+
+		/// <summary>
+		///     Gets or sets a value indicating whether the tree view item is checked.
+		/// </summary>
+		public bool IsChecked
+		{
+			get => Item.IsChecked;
+			set => Item.IsChecked = value;
+		}
+
+		/// <summary>
+		///     Gets or sets a value indicating whether the tree view item is collapsed.
+		/// </summary>
+		public bool IsCollapsed
+		{
+			get => Item.IsCollapsed;
+			set => Item.IsCollapsed = value;
+		}
+
+		/// <summary>
+		///     Gets or sets a value indicating whether the tree view item supports lazy loading.
+		/// </summary>
+		public bool SupportsLazyLoading
+		{
+			get => Item.SupportsLazyLoading;
+			set => Item.SupportsLazyLoading = value;
+		}
+
+		/// <summary>
+		///     Gets the child items of this tree view item.
+		/// </summary>
+		public IEnumerable<TreeViewItem> ChildItems => Item.ChildItems;
+
+		/// <summary>
+		///     Determines whether the specified object is equal to the current object.
+		/// </summary>
+		/// <param name="obj">The object to compare with the current object.</param>
+		/// <returns>true if the specified object is equal to the current object; otherwise, false.</returns>
+		public override bool Equals(object obj)
+		{
+			return obj is TreeViewItemOption<T> option && Equals(option);
+		}
+
+		/// <summary>
+		///     Determines whether the specified TreeViewItemOption is equal to the current TreeViewItemOption.
+		/// </summary>
+		/// <param name="other">The TreeViewItemOption to compare with the current TreeViewItemOption.</param>
+		/// <returns>true if the specified TreeViewItemOption is equal to the current TreeViewItemOption; otherwise, false.</returns>
+		public bool Equals(TreeViewItemOption<T> other)
+		{
+			if (ReferenceEquals(this, other)) return true;
+			if (ReferenceEquals(null, other)) return false;
+
+			return Item.KeyValue.Equals(other.Item.KeyValue) &&
+				EqualityComparer<T>.Default.Equals(Value, other.Value);
+		}
+
+		/// <summary>
+		///     Serves as the default hash function.
+		/// </summary>
+		/// <returns>A hash code for the current object.</returns>
+		public override int GetHashCode()
+		{
+			int hashCode = 11;
+			hashCode ^= 13 * Item.KeyValue.GetHashCode();
+			hashCode ^= 13 * (Value != null ? Value.GetHashCode() : 0);
+			return hashCode;
+		}
+
+		/// <summary>
+		///     Returns a string that represents the current object.
+		/// </summary>
+		/// <returns>A string that represents the current object.</returns>
+		public override string ToString()
+		{
+			return $"{DisplayValue} ({KeyValue}) => {Value}";
+		}
+
+		/// <summary>
+		///     Determines whether two TreeViewItemOption objects are equal.
+		/// </summary>
+		/// <param name="left">The first object to compare.</param>
+		/// <param name="right">The second object to compare.</param>
+		/// <returns>true if the objects are equal; otherwise, false.</returns>
+		public static bool operator ==(TreeViewItemOption<T> left, TreeViewItemOption<T> right)
+		{
+			return Equals(left, right);
+		}
+
+		/// <summary>
+		///     Determines whether two TreeViewItemOption objects are not equal.
+		/// </summary>
+		/// <param name="left">The first object to compare.</param>
+		/// <param name="right">The second object to compare.</param>
+		/// <returns>true if the objects are not equal; otherwise, false.</returns>
+		public static bool operator !=(TreeViewItemOption<T> left, TreeViewItemOption<T> right)
+		{
+			return !Equals(left, right);
+		}
+	}
+}
diff --git a/InteractiveAutomationToolkit/UiResultsExtensions.cs b/InteractiveAutomationToolkit/UiResultsExtensions.cs
index ec55d0b..92b8456 100644
--- a/InteractiveAutomationToolkit/UiResultsExtensions.cs
+++ b/InteractiveAutomationToolkit/UiResultsExtensions.cs
@@ -201,6 +201,42 @@ public static IEnumerable<string> GetCheckedItemKeys(this IUIResults uiResults,
 			return result.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
 		}
 
+		/// <summary>
+		/// Gets the names of the tree view items that are expanded according to the UI results.
+		/// </summary>
+		/// <param name="uiResults">Represents the information a user has entered or selected in a dialog box of an interactive Automation script.</param>
+		/// <param name="treeView">The generic tree view widget.</param>
+		/// <typeparam name="T">The type of the value associated with each tree view item.</typeparam>
+		/// <returns>The names of tree view items that are expanded.</returns>
+		public static IEnumerable<string> GetExpandedItemKeys<T>(this IUIResults uiResults, TreeView<T> treeView)
+		{
+			string[] expandedItems = uiResults.GetExpanded(treeView.DestVar);
+			if (expandedItems == null)
+			{
+				return Array.Empty<string>();
+			}
+
+			return expandedItems.Where(x => !String.IsNullOrWhiteSpace(x)).ToList();
+		}
+
+		/// <summary>
+		/// Gets the names of the tree view items that are checked according to the UI results.
+		/// </summary>
+		/// <param name="uiResults">Represents the information a user has entered or selected in a dialog box of an interactive Automation script.</param>
+		/// <param name="treeView">The generic tree view widget.</param>
+		/// <typeparam name="T">The type of the value associated with each tree view item.</typeparam>
+		/// <returns>The names of tree view items that are checked.</returns>
+		public static IEnumerable<string> GetCheckedItemKeys<T>(this IUIResults uiResults, TreeView<T> treeView)
+		{
+			string result = uiResults.GetString(treeView.DestVar);
+			if (String.IsNullOrEmpty(result))
+			{
+				return Array.Empty<string>();
+			}
+
+			return result.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
+		}
+
 		/// <summary>
 		/// Gets the time zone info of the client in which the calendar is displayed.
 		/// </summary>
diff --git a/InteractiveAutomationToolkitTests/GenericTreeViewTests.cs b/InteractiveAutomationToolkitTests/GenericTreeViewTests.cs
new file mode 100644
index 0000000..7c60a33
--- /dev/null
+++ b/InteractiveAutomationToolkitTests/GenericTreeViewTests.cs
@@ -0,0 +1,274 @@
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Skyline.DataMiner.Utils.InteractiveAutomationScript;
+using System.Linq;
+
+namespace InteractiveAutomationToolkitTests
+{
+	[TestClass]
+	public class GenericTreeViewTests
+	{
+		[TestMethod]
+		public void Constructor_Test()
+		{
+			var rootItems = new[]
+			{
+				new TreeViewItemOption<int>("root1", "Root Item 1", 1),
+				new TreeViewItemOption<int>("root2", "Root Item 2", 2)
+			};
+
+			var treeView = new TreeView<int>(rootItems);
+
+			Assert.IsNotNull(treeView);
+			Assert.AreEqual(2, treeView.Items.Count());
+			Assert.IsFalse(treeView.IsReadOnly);
+		}
+
+		[TestMethod]
+		public void Constructor_WithChildItems_Test()
+		{
+			var childItems = new[]
+			{
+				new TreeViewItemOption<string>("child1", "Child Item 1", "child1data"),
+				new TreeViewItemOption<string>("child2", "Child Item 2", "child2data")
+			};
+
+			var rootItem = new TreeViewItemOption<string>("root", "Root Item", "rootdata", childItems: childItems);
+			var treeView = new TreeView<string>(new[] { rootItem });
+
+			Assert.IsNotNull(treeView);
+			Assert.AreEqual(1, treeView.Items.Count());
+			Assert.AreEqual(3, treeView.GetAllItems().Count()); // 1 root + 2 children
+		}
+
+		[TestMethod]
+		public void TryFindTreeViewItem_Test()
+		{
+			var rootItems = new[]
+			{
+				new TreeViewItemOption<int>("root1", "Root Item 1", 100),
+				new TreeViewItemOption<int>("root2", "Root Item 2", 200)
+			};
+
+			var treeView = new TreeView<int>(rootItems);
+			treeView.UpdateItemCache();
+
+			bool found = treeView.TryFindTreeViewItem("root1", out var item);
+
+			Assert.IsTrue(found);
+			Assert.IsNotNull(item);
+			Assert.AreEqual("root1", item.KeyValue);
+			Assert.AreEqual("Root Item 1", item.DisplayValue);
+			Assert.AreEqual(100, item.Value);
+		}
+
+		[TestMethod]
+		public void TryFindTreeViewItem_NotFound_Test()
+		{
+			var rootItems = new[]
+			{
+				new TreeViewItemOption<int>("root1", "Root Item 1", 100)
+			};
+
+			var treeView = new TreeView<int>(rootItems);
+			treeView.UpdateItemCache();
+
+			bool found = treeView.TryFindTreeViewItem("nonexistent", out var item);
+
+			Assert.IsFalse(found);
+			Assert.IsNull(item);
+		}
+
+		[TestMethod]
+		public void GetAllItems_Test()
+		{
+			var child1 = new TreeViewItemOption<int>("child1", "Child 1", 10);
+			var child2 = new TreeViewItemOption<int>("child2", "Child 2", 20);
+			var rootItem = new TreeViewItemOption<int>("root", "Root", 1, childItems: new[] { child1, child2 });
+
+			var treeView = new TreeView<int>(new[] { rootItem });
+			treeView.UpdateItemCache();
+
+			var allItems = treeView.GetAllItems().ToList();
+
+			Assert.AreEqual(3, allItems.Count);
+			Assert.IsTrue(allItems.Any(x => x.KeyValue == "root"));
+			Assert.IsTrue(allItems.Any(x => x.KeyValue == "child1"));
+			Assert.IsTrue(allItems.Any(x => x.KeyValue == "child2"));
+		}
+
+		[TestMethod]
+		public void GetItems_Depth0_Test()
+		{
+			var child = new TreeViewItemOption<int>("child", "Child", 10);
+			var root = new TreeViewItemOption<int>("root", "Root", 1, childItems: new[] { child });
+
+			var treeView = new TreeView<int>(new[] { root });
+			treeView.UpdateItemCache();
+
+			var depth0Items = treeView.GetItems(0).ToList();
+
+			Assert.AreEqual(1, depth0Items.Count);
+			Assert.AreEqual("root", depth0Items[0].KeyValue);
+		}
+
+		[TestMethod]
+		public void GetItems_Depth1_Test()
+		{
+			var child = new TreeViewItemOption<int>("child", "Child", 10);
+			var root = new TreeViewItemOption<int>("root", "Root", 1, childItems: new[] { child });
+
+			var treeView = new TreeView<int>(new[] { root });
+			treeView.UpdateItemCache();
+
+			var depth1Items = treeView.GetItems(1).ToList();
+
+			Assert.AreEqual(1, depth1Items.Count);
+			Assert.AreEqual("child", depth1Items[0].KeyValue);
+		}
+
+		[TestMethod]
+		public void CheckedValues_Test()
+		{
+			var item1 = new TreeViewItemOption<int>("item1", "Item 1", 100);
+			var item2 = new TreeViewItemOption<int>("item2", "Item 2", 200);
+			var item3 = new TreeViewItemOption<int>("item3", "Item 3", 300);
+
+			var treeView = new TreeView<int>(new[] { item1, item2, item3 });
+			treeView.UpdateItemCache();
+
+			// Simulate checking items
+			item1.IsChecked = true;
+			item3.IsChecked = true;
+			treeView.UpdateItemCache();
+
+			var checkedValues = treeView.CheckedValues.ToList();
+
+			Assert.AreEqual(2, checkedValues.Count);
+			Assert.IsTrue(checkedValues.Contains(100));
+			Assert.IsTrue(checkedValues.Contains(300));
+			Assert.IsFalse(checkedValues.Contains(200));
+		}
+
+		[TestMethod]
+		public void CollapseAndExpand_Test()
+		{
+			var child = new TreeViewItemOption<int>("child", "Child", 10);
+			var root = new TreeViewItemOption<int>("root", "Root", 1, childItems: new[] { child });
+
+			var treeView = new TreeView<int>(new[] { root });
+			treeView.UpdateItemCache();
+
+			treeView.Collapse();
+
+			Assert.IsTrue(root.IsCollapsed);
+			Assert.IsTrue(child.IsCollapsed);
+
+			treeView.Expand();
+
+			Assert.IsFalse(root.IsCollapsed);
+			Assert.IsFalse(child.IsCollapsed);
+		}
+
+		[TestMethod]
+		public void TreeViewItemOption_Equals_Test()
+		{
+			var item1 = new TreeViewItemOption<int>("key1", "Display 1", 100);
+			var item2 = new TreeViewItemOption<int>("key1", "Display 1", 100);
+			var item3 = new TreeViewItemOption<int>("key2", "Display 2", 200);
+
+			Assert.AreEqual(item1, item2);
+			Assert.AreNotEqual(item1, item3);
+		}
+
+		[TestMethod]
+		public void TreeViewItemOption_Properties_Test()
+		{
+			var item = new TreeViewItemOption<string>("key", "display", "value");
+
+			Assert.AreEqual("key", item.KeyValue);
+			Assert.AreEqual("display", item.DisplayValue);
+			Assert.AreEqual("value", item.Value);
+
+			item.KeyValue = "newKey";
+			item.DisplayValue = "newDisplay";
+
+			Assert.AreEqual("newKey", item.KeyValue);
+			Assert.AreEqual("newDisplay", item.DisplayValue);
+			Assert.AreEqual("value", item.Value); // Value is read-only
+		}
+
+		[TestMethod]
+		public void CheckedLeaves_And_CheckedNodes_Test()
+		{
+			var leaf1 = new TreeViewItemOption<int>("leaf1", "Leaf 1", 10);
+			var leaf2 = new TreeViewItemOption<int>("leaf2", "Leaf 2", 20);
+			var node = new TreeViewItemOption<int>("node", "Node", 100, childItems: new[] { leaf1, leaf2 });
+
+			var treeView = new TreeView<int>(new[] { node });
+			treeView.UpdateItemCache();
+
+			// Check both node and one leaf
+			node.IsChecked = true;
+			leaf1.IsChecked = true;
+			treeView.UpdateItemCache();
+
+			var checkedNodes = treeView.CheckedNodes.ToList();
+			var checkedLeaves = treeView.CheckedLeaves.ToList();
+			var checkedNodeValues = treeView.CheckedNodeValues.ToList();
+			var checkedLeafValues = treeView.CheckedLeafValues.ToList();
+
+			Assert.AreEqual(1, checkedNodes.Count);
+			Assert.AreEqual("node", checkedNodes[0].KeyValue);
+			Assert.AreEqual(1, checkedNodeValues.Count);
+			Assert.AreEqual(100, checkedNodeValues[0]);
+
+			Assert.AreEqual(1, checkedLeaves.Count);
+			Assert.AreEqual("leaf1", checkedLeaves[0].KeyValue);
+			Assert.AreEqual(1, checkedLeafValues.Count);
+			Assert.AreEqual(10, checkedLeafValues[0]);
+		}
+
+		[TestMethod]
+		public void EmptyConstructor_Test()
+		{
+			var treeView = new TreeView<string>(System.Linq.Enumerable.Empty<TreeViewItemOption<string>>());
+
+			Assert.IsNotNull(treeView);
+			Assert.AreEqual(0, treeView.Items.Count());
+			Assert.AreEqual(0, treeView.GetAllItems().Count());
+		}
+
+		[TestMethod]
+		public void ParameterlessConstructor_Test()
+		{
+			var treeView = new TreeView<int>();
+
+			Assert.IsNotNull(treeView);
+			Assert.AreEqual(0, treeView.Items.Count());
+			Assert.AreEqual(0, treeView.GetAllItems().Count());
+			Assert.IsFalse(treeView.IsReadOnly);
+		}
+
+		[TestMethod]
+		public void NullValue_Test()
+		{
+			// Test that null values are handled correctly
+			var item = new TreeViewItemOption<string>("key", "display", null);
+
+			Assert.IsNull(item.Value);
+			Assert.AreEqual("key", item.KeyValue);
+			Assert.AreEqual("display", item.DisplayValue);
+		}
+
+		[TestMethod]
+		public void ComplexType_Test()
+		{
+			// Test with a complex custom type
+			var customData = new { Id = 123, Name = "Test", Active = true };
+			var item = new TreeViewItemOption<object>("key", "display", customData);
+
+			Assert.IsNotNull(item.Value);
+			Assert.AreEqual(customData, item.Value);
+		}
+	}
+}