From c90f1052a3cd9f3af26b20531668d8c53a7da225 Mon Sep 17 00:00:00 2001
From: Deyan Nenov <dnenov@archilizer.com>
Date: Fri, 15 Mar 2024 15:42:36 +0000
Subject: [PATCH] DYN-6607 - Input/Output Node - part 1 (#14987)

* initialize definedata model

- starting with the model and the test suite

* added test structure, node customization

- now types are contained inside an enum
- added the basic primitives to the test structure, including lists checks
- reworked the node to start getting the customization going (and make sense of the whole thing)

* hierarchical container, geometry tests

- created hierarchical container capable of tracking type inheritance
- added all geometry tests

* primitive tests done

- finished all primitive date type tests

* ggroup

* Revert "ggroup"

This reverts commit 1621855d3edacde667af1d474ef6be856d88e720.

* inheritance tests done

- completed tests checking inf inheritance works on individual and on list level

* comments

- added a few additional comments
- additional test checking if inheritance stops at the desired level (ie. `Cone` does not inherit from `Curve`)

* finished refactoring for tests

- removed the Enum, replaced directly with Type

* refactor, comments

- removed dictionary in favor of list of datatypes
- renamed methods to better suit the specificity of the node functionality they were serving

---------

Co-authored-by: Ashish Aggarwal <ashish.aggarwal@autodesk.com>
---
 .../UI/Themes/Modern/DynamoModern.xaml        | 130 +++++++
 src/Libraries/CoreNodeModels/DefineData.cs    | 161 ++++++++
 .../Controls/DefineDataControl.xaml           |  81 ++++
 .../Controls/DefineDataControl.xaml.cs        |  23 ++
 .../CoreNodeModelsWpf.csproj                  |   1 +
 .../CoreNodeModelsWpf/DefineDataViewModel.cs  |  21 ++
 .../NodeViewCustomizations/DefineData.cs      |  47 +++
 src/Libraries/CoreNodes/Data.cs               | 161 +++++++-
 test/DynamoCoreTests/DSCoreDataTests.cs       | 349 +++++++++++++++++-
 9 files changed, 952 insertions(+), 22 deletions(-)
 create mode 100644 src/Libraries/CoreNodeModels/DefineData.cs
 create mode 100644 src/Libraries/CoreNodeModelsWpf/Controls/DefineDataControl.xaml
 create mode 100644 src/Libraries/CoreNodeModelsWpf/Controls/DefineDataControl.xaml.cs
 create mode 100644 src/Libraries/CoreNodeModelsWpf/DefineDataViewModel.cs
 create mode 100644 src/Libraries/CoreNodeModelsWpf/NodeViewCustomizations/DefineData.cs

diff --git a/src/DynamoCoreWpf/UI/Themes/Modern/DynamoModern.xaml b/src/DynamoCoreWpf/UI/Themes/Modern/DynamoModern.xaml
index abf88c0e770..474efa30ab6 100644
--- a/src/DynamoCoreWpf/UI/Themes/Modern/DynamoModern.xaml
+++ b/src/DynamoCoreWpf/UI/Themes/Modern/DynamoModern.xaml
@@ -489,6 +489,136 @@
         </Setter>
         <Style.Triggers />
     </Style>
+
+
+    <!-- NodeView c ustomization styles --> 
+    <ControlTemplate x:Key="NodeViewComboBoxToggleButton" TargetType="ToggleButton">
+        <Grid>
+            <Border x:Name="Border"
+                    Background="#2a2a2a"
+                    BorderThickness="0"/>
+            <Path x:Name="Arrow"
+                  Margin="0 0 5 0"
+                  HorizontalAlignment="Right"
+                  VerticalAlignment="Center"
+                  Data="M 0 0 L 4 4 L 8 0 Z"
+                  Fill="#999" />
+        </Grid>
+        <ControlTemplate.Triggers>
+            <Trigger Property="ToggleButton.IsMouseOver"
+                     Value="true">
+                <Setter TargetName="Arrow"
+                        Property="Fill"
+                        Value="#fff" />
+            </Trigger>
+        </ControlTemplate.Triggers>
+    </ControlTemplate>
+    
+    <Style x:Key="NodeViewComboBox" TargetType="{x:Type ComboBox}">
+        <Setter Property="SnapsToDevicePixels" Value="true" />
+        <Setter Property="OverridesDefaultStyle" Value="true" />
+        <Setter Property="ScrollViewer.HorizontalScrollBarVisibility" Value="Auto" />
+        <Setter Property="ScrollViewer.VerticalScrollBarVisibility" Value="Auto" />
+        <Setter Property="ScrollViewer.CanContentScroll" Value="true" />
+        <Setter Property="MinWidth" Value="40" />
+        <Setter Property="Padding" Value="5 0" />
+        <Setter Property="MinHeight" Value="20" />
+        <Setter Property="MaxHeight" Value="30" />
+        <Setter Property="FontSize" Value="10" />
+        <Setter Property="Foreground" Value="#C7C7C7" />
+        <Setter Property="ItemContainerStyle" Value="{DynamicResource PackageManagerComboBoxItemStyle}" />
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="ComboBox">
+                    <Grid>
+                        <ToggleButton Name="ToggleButton"   
+                                      Grid.Column="2"
+                                      ClickMode="Press"
+                                      Focusable="false"
+                                      IsChecked="{Binding Path=IsDropDownOpen, Mode=TwoWay, RelativeSource={RelativeSource TemplatedParent}}"
+                                      Template="{DynamicResource NodeViewComboBoxToggleButton}" />
+                        <ContentPresenter Name="ContentSite"
+                                          Margin="5,3,12,3"
+                                          HorizontalAlignment="Left"
+                                          VerticalAlignment="Center"
+                                          Content="{TemplateBinding SelectionBoxItem}"
+                                          ContentTemplate="{TemplateBinding SelectionBoxItemTemplate}"
+                                          ContentTemplateSelector="{TemplateBinding ItemTemplateSelector}"
+                                          IsHitTestVisible="False" />
+                        <TextBox x:Name="PART_EditableTextBox"
+                                 Margin="3,3,23,3"
+                                 Padding="10"
+                                 HorizontalAlignment="Left"
+                                 VerticalAlignment="Center"
+                                 Background="#2a2a2a"
+                                 CaretBrush="#bbbbbb"
+                                 Focusable="True"
+                                 Foreground="#bbbbbb"
+                                 IsReadOnly="{TemplateBinding IsReadOnly}"
+                                 Style="{x:Null}"
+                                 Template="{StaticResource ComboBoxTextBox}"
+                                 Visibility="Hidden" />
+                        <Popup Name="Popup"
+                               AllowsTransparency="True"
+                               Focusable="False"
+                               IsOpen="{TemplateBinding IsDropDownOpen}"
+                               Placement="Bottom"
+                               PopupAnimation="Slide">
+                            <Grid Name="DropDown"
+                                  MinWidth="{TemplateBinding ActualWidth}"
+                                  MaxHeight="{TemplateBinding MaxDropDownHeight}"
+                                  SnapsToDevicePixels="True">
+                                <Border x:Name="DropDownBorder"
+                                        Background="#2a2a2a"
+                                        BorderBrush="Transparent"
+                                        BorderThickness="0" />
+                                <ScrollViewer Margin="0,6,0,6"
+                                              SnapsToDevicePixels="True">
+                                    <StackPanel IsItemsHost="True"
+                                                KeyboardNavigation.DirectionalNavigation="Contained" />
+                                </ScrollViewer>
+                            </Grid>
+                        </Popup>
+                    </Grid>
+                    <ControlTemplate.Triggers>
+                        <Trigger Property="HasItems"
+                                 Value="false">
+                            <Setter TargetName="DropDownBorder"
+                                    Property="MinHeight"
+                                    Value="95" />
+                        </Trigger>
+                        <Trigger Property="IsGrouping"
+                                 Value="true">
+                            <Setter Property="ScrollViewer.CanContentScroll"
+                                    Value="false" />
+                        </Trigger>
+                        <Trigger SourceName="Popup"
+                                 Property="Popup.AllowsTransparency"
+                                 Value="true">
+                            <Setter TargetName="DropDownBorder"
+                                    Property="CornerRadius"
+                                    Value="0" />
+                            <Setter TargetName="DropDownBorder"
+                                    Property="Margin"
+                                    Value="0,0,0,0" />
+                        </Trigger>
+                        <Trigger Property="IsEditable"
+                                 Value="true">
+                            <Setter Property="IsTabStop"
+                                    Value="false" />
+                            <Setter TargetName="PART_EditableTextBox"
+                                    Property="Visibility"
+                                    Value="Visible" />
+                            <Setter TargetName="ContentSite"
+                                    Property="Visibility"
+                                    Value="Hidden" />
+                        </Trigger>
+                    </ControlTemplate.Triggers>
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+        <Style.Triggers />
+    </Style>
     <!-- End Package Manager Styles -->
     <Style x:Key="SComboBox_Update" TargetType="{x:Type ComboBox}">
         <Setter Property="SnapsToDevicePixels" Value="true" />
diff --git a/src/Libraries/CoreNodeModels/DefineData.cs b/src/Libraries/CoreNodeModels/DefineData.cs
new file mode 100644
index 00000000000..a3424f37342
--- /dev/null
+++ b/src/Libraries/CoreNodeModels/DefineData.cs
@@ -0,0 +1,161 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Linq;
+using System.Runtime.Serialization;
+using DSCore;
+using Dynamo.Graph.Nodes;
+using Newtonsoft.Json;
+using ProtoCore.AST.AssociativeAST;
+using VMDataBridge;
+
+
+namespace CoreNodeModels
+{
+    [NodeName("DefineData")]
+    [NodeDescription(nameof(Properties.Resources.RememberDescription), typeof(Properties.Resources))]
+    [NodeCategory("Core.Data")]
+    [InPortNames(">")]
+    [InPortTypes("var[]..[]")]
+    [InPortDescriptions(typeof(Properties.Resources),
+        nameof(Properties.Resources.RememberInputToolTip))]
+    [OutPortNames(">")]
+    [OutPortTypes("var[]..[]")]
+    [OutPortDescriptions(typeof(Properties.Resources), nameof(Properties.Resources.RememberOuputToolTip))]
+    [IsDesignScriptCompatible]
+    public class DefineData : DSDropDownBase
+    {
+        private bool context;
+        private List<DynamoDropDownItem> serializedItems;
+
+        [JsonProperty]
+        public bool IsList { get; set; }
+
+        /// <summary>
+        /// Copy of <see cref="DSDropDownBase.Items"/> to be serialized./>
+        /// </summary>
+        [JsonProperty]
+        protected List<DynamoDropDownItem> SerializedItems
+        {
+            get => serializedItems;
+            set
+            {
+                serializedItems = value;
+
+                Items.Clear();
+
+                foreach (DynamoDropDownItem item in serializedItems)
+                {
+                    Items.Add(item);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Construct a new DefineData Dropdown Menu node
+        /// </summary>
+        public DefineData() : base(">")
+        {
+            RegisterAllPorts();
+            PropertyChanged += OnPropertyChanged;
+
+            foreach (var dataType in Data.GetDataNodeDynamoTypeList())
+            {
+                var displayName = dataType.Name;
+                var value = dataType;
+
+                Items.Add(new DynamoDropDownItem(displayName, value));
+            }
+
+            SelectedIndex = 0;
+        }
+
+        [JsonConstructor]
+        private DefineData(IEnumerable<PortModel> inPorts, IEnumerable<PortModel> outPorts) : base(">", inPorts, outPorts)
+        {
+            PropertyChanged += OnPropertyChanged;
+        }
+
+        private void OnPropertyChanged(object sender, PropertyChangedEventArgs e)
+        {
+
+        }
+
+        protected override void OnBuilt()
+        {
+            base.OnBuilt();
+            DataBridge.Instance.RegisterCallback(GUID.ToString(), DataBridgeCallback);
+        }
+
+        public override void Dispose()
+        {
+            PropertyChanged -= OnPropertyChanged;
+            base.Dispose();
+            DataBridge.Instance.UnregisterCallback(GUID.ToString());
+        }
+
+        public override IEnumerable<AssociativeNode> BuildOutputAst(List<AssociativeNode> inputAstNodes)
+        {
+            var resultAst = new List<AssociativeNode>();
+
+            // function call inputs - reference to the function, and the function arguments coming from the inputs
+            // the object to be (type) evaluated
+            // the expected datatype
+            // if the input is an ArrayList or not
+            var function = new Func<object, string, bool, bool>(DSCore.Data.IsSupportedDataNodeDynamoType);
+            var funtionInputs = new List<AssociativeNode> {
+                inputAstNodes[0],
+                AstFactory.BuildStringNode((Items[SelectedIndex].Item as Data.DataNodeDynamoType).Type.ToString()),
+                AstFactory.BuildBooleanNode(IsList) };
+
+
+            var functionCall = AstFactory.BuildFunctionCall(function, funtionInputs);
+            var functionCallIdentifier = AstFactory.BuildIdentifier(GUID + "_func");
+
+            // build the function call
+            resultAst.Add(AstFactory.BuildAssignment(functionCallIdentifier, functionCall));
+
+            // build the output call
+            resultAst.Add(AstFactory.BuildAssignment(GetAstIdentifierForOutputIndex(0), functionCall));
+
+            // build the call for the DataBridge 
+            resultAst.Add(AstFactory.BuildAssignment(functionCallIdentifier,
+                DataBridge.GenerateBridgeDataAst(GUID.ToString(),
+                AstFactory.BuildExprList(inputAstNodes))));
+
+
+            return resultAst;
+        }
+
+
+        /// <summary>
+        /// Not sure at the moment how relevant is the databridge for this node type 
+        /// </summary>
+        /// <param name="data"></param>
+        private void DataBridgeCallback(object data)
+        {
+            var inputs = data as ArrayList;
+
+            var inputObject = inputs[0];
+
+            if (!InPorts[0].IsConnected)
+            {
+                return;
+            }
+
+        }
+
+
+        protected override SelectionState PopulateItemsCore(string currentSelection)
+        {
+            return SelectionState.Restore;
+        }
+
+        [OnSerializing]
+        private void OnSerializing(StreamingContext context)
+        {
+            serializedItems = Items.ToList();
+        }
+    }
+}
diff --git a/src/Libraries/CoreNodeModelsWpf/Controls/DefineDataControl.xaml b/src/Libraries/CoreNodeModelsWpf/Controls/DefineDataControl.xaml
new file mode 100644
index 00000000000..e24865162eb
--- /dev/null
+++ b/src/Libraries/CoreNodeModelsWpf/Controls/DefineDataControl.xaml
@@ -0,0 +1,81 @@
+<UserControl x:Class="CoreNodeModelsWpf.Controls.DefineDataControl"
+             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
+             xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
+             xmlns:p="clr-namespace:Dynamo.Wpf.Properties"
+             xmlns:core="clr-namespace:Dynamo.Nodes;assembly=DynamoCoreWpf"
+             xmlns:ui="clr-namespace:Dynamo.UI;assembly=DynamoCoreWpf"
+             mc:Ignorable="d" 
+             d:DesignHeight="200" d:DesignWidth="350">
+    <UserControl.Resources>
+        <ResourceDictionary>
+            <ResourceDictionary.MergedDictionaries>
+                <ui:SharedResourceDictionary Source="{x:Static ui:SharedDictionaryManager.DynamoModernDictionaryUri}" />
+                <ui:SharedResourceDictionary Source="{x:Static ui:SharedDictionaryManager.DynamoConvertersDictionaryUri}" />
+                <ui:SharedResourceDictionary Source="{x:Static ui:SharedDictionaryManager.DynamoColorsAndBrushesDictionaryUri}" />
+            </ResourceDictionary.MergedDictionaries>
+            <SolidColorBrush x:Key="StrokeBrush" Color="#999999 " />
+            
+            <PathGeometry x:Key="QuestionIcon" Figures="M8 0C3.58172 0 0 3.58172 0 8C0 12.4183 3.58172 16 8 16C12.4183 16 16 12.4183 16 8C16 5.87827 15.1571 3.84344 13.6569 2.34315C12.1566 0.842855 10.1217 0 8 0ZM9 14H7V12H9V14ZM10 8.45C9.38 8.74 9 8.95 9 9.45V11H7V8.92C6.97651 8.37388 7.19188 7.84457 7.59 7.47C8.05 7.06 9.75 6.56 9.75 5.59C9.75 5 9.45 4.33 8.23 4.33C6.75 4.33 6.23 6.66 6.23 6.66L4.45 6.25C4.45 6.25 4.86 2.39 8.25 2.39C9.13189 2.33809 9.99827 2.63874 10.6584 3.22576C11.3186 3.81279 11.7185 4.63809 11.77 5.52C11.8034 6.75866 11.1119 7.90321 10 8.45Z"/>
+            <PathGeometry x:Key="PadlockIcon" Figures="M 35 7 C 30.038 7 26 11.038 26 16 L 26 20 L 9 20 C 7.343 20 6 21.343 6 23 L 6 38 C 6 39.657 7.343 41 9 41 L 27 41 C 28.657 41 30 39.657 30 38 L 30 23 C 30 21.343 28.657 20 27 20 L 27 16 C 27 11.589 30.589 8 35 8 C 39.411 8 43 11.589 43 16 L 43 20.5 C 43 20.776 43.224 21 43.5 21 C 43.776 21 44 20.776 44 20.5 L 44 16 C 44 11.038 39.962 7 35 7 z M 9 21 L 27 21 C 28.105 21 29 21.895 29 23 L 29 38 C 29 39.105 28.105 40 27 40 L 9 40 C 7.895 40 7 39.105 7 38 L 7 23 C 7 21.895 7.895 21 9 21 z"/>
+        </ResourceDictionary>
+    </UserControl.Resources>
+    <DockPanel VerticalAlignment="Bottom">
+        <ToggleButton VerticalAlignment="Center"
+                        Width="30"
+                        Height="15"
+                        Margin="2,0,0,0"
+                        IsEnabled="True"
+                        IsChecked="{Binding Path=StaticSplashScreenEnabled}"
+                        Style="{StaticResource EllipseToggleButton1}"/>
+        <Label Content="List"
+                Margin="4 0"    
+                Foreground="{StaticResource PreferencesWindowFontColor}"/>
+        <Canvas VerticalAlignment="Center" Width="14" Height="14">
+            <Viewbox Width="14" Height="14">
+                <Path x:Name="ExpandPath" Data="{StaticResource QuestionIcon}"
+                      Fill="{StaticResource StrokeBrush}"
+                      Stroke="{StaticResource StrokeBrush}">
+                </Path>                    
+            </Viewbox>
+            <Canvas.ToolTip>
+                <ToolTip Content="Fill in later"
+                            Style="{StaticResource GenericToolTipLight}"/>
+            </Canvas.ToolTip>
+        </Canvas>
+
+        <Button Margin="0 0 10 3"
+                x:Name="LockButton"
+                BorderThickness="0"
+                HorizontalAlignment="Right"
+                VerticalAlignment="Center"
+                Cursor="Hand">
+            <Button.ToolTip>
+                <ToolTip Content="Lock tooltup"
+                            Style="{StaticResource GenericToolTipLight}" />
+            </Button.ToolTip>
+            <Button.Template>
+                <ControlTemplate TargetType="Button">
+                    <Border Background="Transparent">
+                        <Viewbox Width="16"
+                                 Height="16"
+                                 VerticalAlignment="Center">
+                            <Path x:Name="Folder"
+                                  Fill="#999999"
+                                  Data="{StaticResource PadlockIcon}"
+                                  StrokeThickness="1"
+                                  Stroke="{StaticResource StrokeBrush}">
+                            </Path>
+                        </Viewbox>
+                    </Border>
+                    <ControlTemplate.Triggers>
+                        <Trigger Property="IsMouseOver" Value="True">
+                            <Setter TargetName="Folder" Property="Fill" Value="#6AC0E7" />
+                        </Trigger>
+                    </ControlTemplate.Triggers>
+                </ControlTemplate>
+            </Button.Template>
+        </Button>
+    </DockPanel>
+</UserControl>
diff --git a/src/Libraries/CoreNodeModelsWpf/Controls/DefineDataControl.xaml.cs b/src/Libraries/CoreNodeModelsWpf/Controls/DefineDataControl.xaml.cs
new file mode 100644
index 00000000000..51214bd23cb
--- /dev/null
+++ b/src/Libraries/CoreNodeModelsWpf/Controls/DefineDataControl.xaml.cs
@@ -0,0 +1,23 @@
+using System.Windows.Controls;
+using CoreNodeModels;
+
+namespace CoreNodeModelsWpf.Controls
+{
+    /// <summary>
+    /// Interaction logic for DefineDataControl.xaml
+    /// </summary>
+    public partial class DefineDataControl : UserControl
+    {
+        private readonly DefineData model;
+
+        internal ComboBox BaseComboBox { get; set; }
+
+        public DefineDataControl(DefineDataViewModel viewModel)
+        {
+            DataContext = viewModel;
+            model = viewModel.Model;
+
+            InitializeComponent();
+        }
+    }
+}
diff --git a/src/Libraries/CoreNodeModelsWpf/CoreNodeModelsWpf.csproj b/src/Libraries/CoreNodeModelsWpf/CoreNodeModelsWpf.csproj
index 73a95cb3c8b..6325c3c9b01 100644
--- a/src/Libraries/CoreNodeModelsWpf/CoreNodeModelsWpf.csproj
+++ b/src/Libraries/CoreNodeModelsWpf/CoreNodeModelsWpf.csproj
@@ -84,6 +84,7 @@
     <None Remove="Charts\Controls\PieChartControl.xaml" />
     <None Remove="Charts\Controls\ScatterPlotControl.xaml" />
     <None Remove="Charts\Controls\XYLineChartControl.xaml" />
+    <None Remove="Controls\DefineDataControl.xaml" />
   </ItemGroup>
   <ItemGroup>
     <Compile Update="Properties\CoreNodeModelWpfResources.Designer.cs">
diff --git a/src/Libraries/CoreNodeModelsWpf/DefineDataViewModel.cs b/src/Libraries/CoreNodeModelsWpf/DefineDataViewModel.cs
new file mode 100644
index 00000000000..8c560c87e72
--- /dev/null
+++ b/src/Libraries/CoreNodeModelsWpf/DefineDataViewModel.cs
@@ -0,0 +1,21 @@
+using CoreNodeModels;
+using Dynamo.Core;
+
+namespace CoreNodeModelsWpf
+{
+    public class DefineDataViewModel : NotificationObject
+    {
+        public DefineData Model { get; }
+
+        public DefineDataViewModel()
+        {
+
+        }
+        public DefineDataViewModel(DefineData model)
+        {
+            Model = model;
+        }
+
+
+    }
+}
diff --git a/src/Libraries/CoreNodeModelsWpf/NodeViewCustomizations/DefineData.cs b/src/Libraries/CoreNodeModelsWpf/NodeViewCustomizations/DefineData.cs
new file mode 100644
index 00000000000..e144089c7ec
--- /dev/null
+++ b/src/Libraries/CoreNodeModelsWpf/NodeViewCustomizations/DefineData.cs
@@ -0,0 +1,47 @@
+using System.Windows;
+using System.Windows.Controls;
+using CoreNodeModels;
+using CoreNodeModelsWpf.Controls;
+using Dynamo.Controls;
+using Dynamo.Wpf;
+
+namespace CoreNodeModelsWpf.Nodes
+{
+    /// <summary>
+    /// View customizer for DefineData node model.
+    /// </summary>
+    public class DefineDataNodeViewCustomization : DropDownNodeViewCustomization, INodeViewCustomization<DefineData>
+    {
+        /// <summary>
+        /// Customize the visual appearance of the DefineData node.
+        /// </summary>
+        /// <param name="model"></param>
+        /// <param name="nodeView"></param>
+        public void CustomizeView(DefineData model, NodeView nodeView)
+        {
+            var formControl = new DefineDataControl(new DefineDataViewModel(model));
+
+            nodeView.inputGrid.Margin = new Thickness(5, 0, 5, 0);
+            nodeView.inputGrid.RowDefinitions.Add(new RowDefinition());
+            nodeView.inputGrid.RowDefinitions.Add(new RowDefinition());
+
+            Grid.SetRow(formControl, 1);
+            nodeView.inputGrid.Children.Add(formControl);
+
+            // Add the dropdown.
+            base.CustomizeView(model, nodeView);
+
+            var style = (Style)Dynamo.UI.SharedDictionaryManager.DynamoModernDictionary["NodeViewComboBox"];
+            var dropdown = (ComboBox)nodeView.inputGrid.Children[1];
+            dropdown.Style = style;
+
+            formControl.BaseComboBox = dropdown;
+
+            // Add margin to the dropdown to show the expander.
+            dropdown.Margin = new Thickness(0, 0, 0, 10);
+            dropdown.VerticalAlignment = VerticalAlignment.Top;
+            dropdown.MinWidth = 220;
+            dropdown.FontSize = 12;
+        }
+    }
+}
diff --git a/src/Libraries/CoreNodes/Data.cs b/src/Libraries/CoreNodes/Data.cs
index 011d581df5e..ccd047bf9d2 100644
--- a/src/Libraries/CoreNodes/Data.cs
+++ b/src/Libraries/CoreNodes/Data.cs
@@ -1,20 +1,21 @@
-using Autodesk.DesignScript.Geometry;
 using System;
+using System.Collections;
 using System.Collections.Generic;
-using System.Linq;
-using Autodesk.DesignScript.Runtime;
-using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
 using System.Drawing;
-using System.IO;
 using System.Drawing.Imaging;
-using System.Collections;
+using System.Globalization;
+using System.IO;
+using System.Linq;
 using System.Runtime.Versioning;
+using System.Text;
+using Autodesk.DesignScript.Geometry;
+using Autodesk.DesignScript.Runtime;
 using Dynamo.Events;
 using Dynamo.Logging;
 using Dynamo.Session;
-using System.Globalization;
-using System.Text;
+using DynamoUnits;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
 
 namespace DSCore
 {
@@ -528,6 +529,148 @@ public static Dictionary<string, object> Remember([ArbitraryDimensionArrayImport
         }
 
         internal static DynamoLogger dynamoLogger = ExecutionEvents.ActiveSession?.GetParameterValue(ParameterKeys.Logger) as DynamoLogger;
+        #endregion
+
+        #region Input Output Node
+
+        public class DataNodeDynamoType
+        {
+            public Type Type { get; private set; }
+            public string Name { get; private set; }
+            public DataNodeDynamoType Parent { get; private set; }
+
+            public DataNodeDynamoType(Type type, string name = null)
+            {
+                Type = type;
+                Name = name ?? type.Name;
+            }
+
+            public DataNodeDynamoType(Type type, DataNodeDynamoType parent, string name = null)
+            : this(type, name)
+            {
+                Parent = parent;
+            }
+        }
+
+
+        /// <summary>
+        /// A static dictionary for all Dynamo supported data types
+        /// </summary>
+        /// <returns>The dictionary containing the supported data types</returns>
+        public static List<DataNodeDynamoType> GetDataNodeDynamoTypeList()
+        {
+            var typeList = new List<DataNodeDynamoType>();
+            typeList.Add(new DataNodeDynamoType(typeof(bool)));
+            typeList.Add(new DataNodeDynamoType(typeof(BoundingBox)));
+            typeList.Add(new DataNodeDynamoType(typeof(CoordinateSystem)));
+
+            // Subtypes of Curve
+            var crv = new DataNodeDynamoType(typeof(Curve));
+            typeList.Add(crv);
+            typeList.Add(new DataNodeDynamoType(typeof(Arc), crv));
+            typeList.Add(new DataNodeDynamoType(typeof(Circle), crv));
+            typeList.Add(new DataNodeDynamoType(typeof(Ellipse), crv));
+            typeList.Add(new DataNodeDynamoType(typeof(EllipseArc), crv));
+            typeList.Add(new DataNodeDynamoType(typeof(Helix), crv));
+            typeList.Add(new DataNodeDynamoType(typeof(Line), crv));
+            typeList.Add(new DataNodeDynamoType(typeof(NurbsCurve), crv));
+
+            var polyCurve = new DataNodeDynamoType(typeof(PolyCurve), crv);
+            var polygon = new DataNodeDynamoType(typeof(Polygon), polyCurve);  // polygon is subtype of polyCurve
+            var rectangle = new DataNodeDynamoType(typeof(Autodesk.DesignScript.Geometry.Rectangle), polygon);    // rectangle is subtype of polygon
+
+            typeList.Add(polyCurve);
+            typeList.Add(polygon);
+            typeList.Add(rectangle);
+            typeList.Add(new DataNodeDynamoType(typeof(System.DateTime)));
+            typeList.Add(new DataNodeDynamoType(typeof(double), "Number"));
+            typeList.Add(new DataNodeDynamoType(typeof(long), "Integer"));
+            typeList.Add(new DataNodeDynamoType(typeof(Location)));
+            typeList.Add(new DataNodeDynamoType(typeof(Mesh)));
+            typeList.Add(new DataNodeDynamoType(typeof(Plane)));
+            typeList.Add(new DataNodeDynamoType(typeof(Autodesk.DesignScript.Geometry.Point)));
+
+            // Subtypes of Solid
+            var solid = new DataNodeDynamoType(typeof(Solid));
+            var cone = new DataNodeDynamoType(typeof(Cone), solid);    // cone is subtype of solid
+            var cylinder = new DataNodeDynamoType(typeof(Cylinder), cone); // cylinder is subtype of cone 
+            var cuboid = new DataNodeDynamoType(typeof(Cuboid), solid);    // cuboid is subtype of solid
+            var sphere = new DataNodeDynamoType(typeof(Sphere), solid);    // sphere is subtype of solid
+
+            typeList.Add(solid);
+            typeList.Add(cone);
+            typeList.Add(cylinder);
+            typeList.Add(cuboid);
+            typeList.Add(sphere);
+            typeList.Add(new DataNodeDynamoType(typeof(string)));
+
+            // Subtypes of Surface
+            var surface = new DataNodeDynamoType(typeof(Surface));
+            var nurbsSrf = new DataNodeDynamoType(typeof(NurbsSurface), surface);    // nurbsSrf is subtype of surface
+            var polySrf = new DataNodeDynamoType(typeof(PolySurface), surface); // polySrf is subtype of surface
+
+            typeList.Add(surface);
+            typeList.Add(nurbsSrf);
+            typeList.Add(polySrf);
+            typeList.Add(new DataNodeDynamoType(typeof(System.TimeSpan)));
+            typeList.Add(new DataNodeDynamoType(typeof(UV)));
+            typeList.Add(new DataNodeDynamoType(typeof(Vector)));
+
+            return typeList;
+        }
+
+        /// <summary>
+        /// Function to validate input type against supported Dynamo input types
+        /// </summary>
+        /// <param name="inputValue">The incoming data to validate</param>
+        /// <param name="typeString">The input type provided by the user. It has to match the inputValue type</param>
+        /// <param name="isList">The value of this boolean decides if the input is a single object or a list</param>
+        /// <returns></returns>
+        [IsVisibleInDynamoLibrary(false)]
+        public static bool IsSupportedDataNodeDynamoType([ArbitraryDimensionArrayImport] object inputValue, string typeString, bool isList)
+        {
+            var type = GetDataNodeDynamoTypeList().FirstOrDefault(x => x.Type.ToString().Equals(typeString)).Type;
+            if (type == null) { return false; } // Add exception
+            if (inputValue == null || type == null)
+            {
+                return false;   // Add exception
+            }
+
+            if (!isList)
+            {
+                if (inputValue is ArrayList) return false;  // Add exception ?
+
+                return IsItemOfType(inputValue, type);
+            }
+            else
+            {
+                if (!(inputValue is ArrayList arrayList)) return false; // Add exception ?
+
+                foreach (var item in arrayList)
+                {
+                    if (!IsItemOfType(item, type))
+                    {
+                        return false; 
+                    }
+                }
+
+                return true;
+            }
+        }
+
+        /// <summary>
+        /// This method checks if an item is of a required Dynamo DataType
+        /// 'IsInstanceOfType' recursivelly checks for upward inheritance
+        /// </summary>
+        /// <param name="item">The item to chek the data type for</param>
+        /// <param name="dataType">The DataType to check against</param>
+        /// <returns>A true or false result based on the check validation</returns>
+        private static bool IsItemOfType(object item, Type dataType)
+        {
+            if (dataType.IsInstanceOfType(item)) return true;
+            
+            return false;
+        }
 
         #endregion
     }
diff --git a/test/DynamoCoreTests/DSCoreDataTests.cs b/test/DynamoCoreTests/DSCoreDataTests.cs
index 4ee3955e9df..dca1dbbcfa0 100644
--- a/test/DynamoCoreTests/DSCoreDataTests.cs
+++ b/test/DynamoCoreTests/DSCoreDataTests.cs
@@ -4,7 +4,7 @@
 using System.Drawing;
 using System.IO;
 using System.Linq;
-using System.Text;
+using Autodesk.DesignScript.Geometry;
 using Dynamo.Graph.Nodes;
 using Dynamo.Graph.Nodes.ZeroTouch;
 using DynamoUnits;
@@ -494,17 +494,17 @@ public void CanObjectBeCachedRejectsEmptyString()
 
         [Test]
         [Category("UnitTests")]
-        public void RememberRestoresFromCacheWhenPassedUnsupportedInputAndValidCacheJson()
+        public void RememberRestoresFromCacheWhenPassedUnsupportedInputAndvCacheJson()
         {
-            var validCachedJson = "2";
+            var vCachedJson = "2";
             object unsupportedInput = null;
-            var dict = DSCore.Data.Remember(unsupportedInput, validCachedJson);
+            var dict = DSCore.Data.Remember(unsupportedInput, vCachedJson);
 
             var returnObject = dict[">"];
             var returnCacheJson = dict["Cache"];
 
             Assert.AreEqual(2, returnObject);
-            Assert.AreEqual(validCachedJson, returnCacheJson);
+            Assert.AreEqual(vCachedJson, returnCacheJson);
         }
 
         [Test]
@@ -524,11 +524,11 @@ public void RememberReturnUnsupportedInputWhenPassedUnsupportedInputAndEmptyCach
 
         [Test]
         [Category("UnitTests")]
-        public void RememberWillUpdateCacheWhenPassedSupportedInputAndValidCacheJson()
+        public void RememberWillUpdateCacheWhenPassedSupportedInputAndvCacheJson()
         {
-            var validCachedJson = "2";
+            var vCachedJson = "2";
             var newInputObject = true;
-            var dict = DSCore.Data.Remember(newInputObject, validCachedJson);
+            var dict = DSCore.Data.Remember(newInputObject, vCachedJson);
 
             var returnObject = dict[">"];
             var returnCacheJson = dict["Cache"];
@@ -556,22 +556,345 @@ public void RememberWillUpdateCacheWhenPassedSupportedInputAndEmptyCacheJson()
 
         [Test]
         [Category("UnitTests")]
-        public void ThrowsWhenPassedUnsupportedInputAndInvalidCacheJson()
+        public void ThrowsWhenPassedUnsupportedInputAndInvCacheJson()
         {
-            var invalidCachedJson = "{\"one: 2}";
+            var invCachedJson = "{\"one: 2}";
             object unsupportedInput = null;
 
-            Assert.That(() => DSCore.Data.Remember(unsupportedInput, invalidCachedJson), Throws.Exception);
+            Assert.That(() => DSCore.Data.Remember(unsupportedInput, invCachedJson), Throws.Exception);
         }
 
         [Test]
         [Category("UnitTests")]
         public void ThrowsWhenPassedAnObjectThatCanNotSerialize()
         {
-            var validCachedJson = "";
+            var vCachedJson = "";
             object unsupportedInput = new FileInfo(Path.Combine(TestDirectory, @"core\json\Solid_Cylinder_JSONParsing.dyn"));
 
-            Assert.That(() => DSCore.Data.Remember(unsupportedInput, validCachedJson), Throws.Exception);
+            Assert.That(() => DSCore.Data.Remember(unsupportedInput, vCachedJson), Throws.Exception);
+        }
+
+
+        [Test]
+        [Category("UnitTests")]
+        public void IsNotSupportedNullInput()
+        {
+            object nullInput = null;
+            var vType = typeof(String);
+            var invType = typeof(Nullable);
+
+            var vString = "input string";
+
+            // Assert - check for nulls - fail
+            var validate = DSCore.Data.IsSupportedDataNodeDynamoType(nullInput, vType.ToString(), false);
+            Assert.AreEqual(false, validate, "Null input should not be supported.");
+
+            validate = DSCore.Data.IsSupportedDataNodeDynamoType(vString, invType.ToString(), false);
+            Assert.AreEqual(false, validate, "Unexisting enum type should not be supported.");
+        }
+
+        [Test]
+        [Category("UnitTests")]
+        public void IsSupportedPrimitiveDataType()
+        {
+            var vString = "input string";
+            var vInt = 5;
+            var vDouble = 3.14;
+            var vDateTime = DSCore.DateTime.ByDate(2001, 1, 1);
+            var vLocation = Location.ByLatitudeAndLongitude(50, 50);
+            var vTimeSpan = DSCore.TimeSpan.ByDateDifference(vDateTime, DSCore.DateTime.ByDate(2000, 1, 1));
+
+            var invStringList = new ArrayList() { vString, vInt, vDouble };
+            var vStringList = new ArrayList() { vString };
+            var vIntList = new ArrayList() { vInt };
+            var vDoubleList = new ArrayList() { vDouble };
+            var vDateTimeList = new ArrayList() { vDateTime };
+            var vLocationList = new ArrayList() { vLocation };
+            var vTimeSpanList = new ArrayList() { vTimeSpan };
+
+            // Assert - check list - succeed
+            var singleChecks = new Dictionary<Type, object>();
+            singleChecks[typeof(string)] = vString;
+            singleChecks[typeof(int)] = vInt;
+            singleChecks[typeof(double)] = vDouble;
+            singleChecks[typeof(DateTime)] = vDateTime;
+            singleChecks[typeof(Location)] = vLocation;
+            singleChecks[typeof(TimeSpan)] = vTimeSpan;
+
+            foreach (var kv in singleChecks)
+            {
+                Assert.AreEqual(
+                    true,
+                    DSCore.Data.IsSupportedDataNodeDynamoType(kv.Value, kv.Key.ToString(), false),
+                    String.Format($"Couldn't validate {kv.Key} input."));
+            }
+
+            // Assert - check list - fail
+            var validate = DSCore.Data.IsSupportedDataNodeDynamoType(vStringList, typeof(string).ToString(), false);
+            Assert.AreEqual(false, validate, "Shouldn't validate list values with list flag off.");
+
+            validate = DSCore.Data.IsSupportedDataNodeDynamoType(vString, typeof(string).ToString(), true);
+            Assert.AreEqual(false, validate, "Shouldn't validate single values with list flag on.");
+
+            validate = DSCore.Data.IsSupportedDataNodeDynamoType(invStringList, typeof(string).ToString(), true);
+            Assert.AreEqual(false, validate, "Shouldn't validate heterogenous list input.");
+
+            // Assert - check homogenous list values - succeed
+            var listChecks = new Dictionary<Type, object>();
+            listChecks[typeof(string)] = vStringList;
+            listChecks[typeof(int)] = vIntList;
+            listChecks[typeof(double)] = vDoubleList;
+            listChecks[typeof(DateTime)] = vDateTimeList;
+            listChecks[typeof(Location)] = vLocationList;
+            listChecks[typeof(TimeSpan)] = vTimeSpanList;
+
+            foreach (var kv in listChecks)
+            {
+                Assert.AreEqual(
+                    true,
+                    DSCore.Data.IsSupportedDataNodeDynamoType(kv.Value, kv.Key.ToString(), true),
+                    String.Format($"Couldn't validate {kv.Key} list input."));
+            }
+        }
+
+
+        [Test]
+        [Category("UnitTests")]
+        public void IsSupportedGeometryDataType()
+        {
+            // Single values and primitive composites
+            var point = Autodesk.DesignScript.Geometry.Point.ByCoordinates(1, 1, 1);
+            var point2 = Autodesk.DesignScript.Geometry.Point.ByCoordinates(2, 2, 1);
+            var point3 = Autodesk.DesignScript.Geometry.Point.ByCoordinates(3, 3, 3);
+            var vector = Vector.ByCoordinates(0, 0, 1);
+            var plane = Plane.ByBestFitThroughPoints([point, point2, point3]);
+            var vBoundingBox = BoundingBox.ByCorners(point, point3);
+            var vCoordinateSystem = CoordinateSystem.ByOrigin(0, 0);
+            var vSurface = Surface.ByPerimeterPoints([point, point2, point3]);
+            var vUV = UV.ByCoordinates(0, 0);
+            var vCurve = Curve.ByParameterLineOnSurface(vSurface, vUV, vUV);
+            var vArc = Arc.ByThreePoints(point, point2, point3);
+            var vCircle = Circle.ByBestFitThroughPoints([point, point2, point3]);
+            var vEllipse = Ellipse.ByOriginRadii(point, 5, 5);
+            var vEllipseArc = EllipseArc.ByPlaneRadiiAngles(plane, 2, 2, 0, 180);
+            var vHelix = Helix.ByAxis(point, vector, point3, 1, 360);
+            var vLine = Line.ByBestFitThroughPoints([point, point2, point3]);
+            var vNurbsCurve = NurbsCurve.ByControlPoints([point, point2, point3, point]);
+            var vPolyCurve = PolyCurve.ByJoinedCurves([vCurve, vCurve], 0.001);
+            var vPolygon = Polygon.ByPoints([point, point2, point3, point]);
+            var vRectangle = Autodesk.DesignScript.Geometry.Rectangle.ByWidthLength(5, 10);
+            var indexGroup = IndexGroup.ByIndices(0, 1, 2);
+            var vMesh = Mesh.ByPointsFaceIndices([point, point2, point3], [indexGroup, indexGroup, indexGroup]);
+            var vSolid = Solid.ByJoinedSurfaces([vSurface, vSurface, vSurface, vSurface, vSurface, vSurface]);
+            var vCone = Cone.ByCoordinateSystemHeightRadii(vCoordinateSystem, 1, 1, 1);
+            var vCylinder = Cylinder.ByPointsRadius(point, point3, 1);
+            var vCuboid = Cuboid.ByCorners(point, point3);
+            var vSphere = Sphere.ByCenterPointRadius(point, 1);
+            var vNurbsSurface = NurbsSurface.ByControlPoints([[point, point2, point3, point],
+                [point, point3, point2, point],
+                [point2, point3, point, point2]], 2, 2);
+            var vPolySurface = PolySurface.ByJoinedSurfaces([vSurface, vSurface]);
+
+            // Lists
+            var invBoundingBoxList = new ArrayList() { point, vBoundingBox };
+            var vBoundingBoxList = new ArrayList() { vBoundingBox, vBoundingBox };
+            var vCoordinateSystemList = new ArrayList() { vCoordinateSystem, vCoordinateSystem };
+            var vPointList = new ArrayList() { point, point };
+            var vVectorList = new ArrayList() { vector, vector };
+            var vPlaneList = new ArrayList() { plane, plane };
+            var vSurfaceList = new ArrayList() { vSurface, vSurface };
+            var vUVList = new ArrayList() { vUV, vUV };
+            var vCurveList = new ArrayList() { vCurve, vCurve };
+            var vArcList = new ArrayList() { vArc, vArc };
+            var vCircleList = new ArrayList() { vCircle, vCircle };
+            var vEllipseList = new ArrayList() { vEllipse, vEllipse };
+            var vEllipseArcList = new ArrayList() { vEllipseArc, vEllipseArc };
+            var vHelixList = new ArrayList() { vHelix, vHelix };
+            var vLineList = new ArrayList() { vLine, vLine };
+            var vNurbsCurveList = new ArrayList() { vNurbsCurve, vNurbsCurve };
+            var vPolyCurveList = new ArrayList() { vPolyCurve, vPolyCurve };
+            var vPolygonList = new ArrayList() { vPolygon, vPolygon };
+            var vRectangleList = new ArrayList() { vRectangle, vRectangle };
+            var vMeshList = new ArrayList() { vMesh, vMesh };
+            var vSolidList = new ArrayList() { vSolid, vSolid };
+            var vConeList = new ArrayList() { vCone, vCone };
+            var vCylinderList = new ArrayList() { vCylinder, vCylinder };
+            var vCuboidList = new ArrayList() { vCuboid, vCuboid };
+            var vSphereList = new ArrayList() { vSphere, vSphere };
+            var vNurbsSurfaceList = new ArrayList() { vNurbsSurface, vNurbsSurface };
+            var vPolySurfaceList = new ArrayList() { vPolySurface, vPolySurface };
+
+            // Assert - check signle values - succeed
+            var singleChecks = new Dictionary<Type, object>();
+            singleChecks[typeof(BoundingBox)] = vBoundingBox;
+            singleChecks[typeof(CoordinateSystem)] = vCoordinateSystem;
+            singleChecks[typeof(Autodesk.DesignScript.Geometry.Point)] = point;
+            singleChecks[typeof(Vector)] = vector;
+            singleChecks[typeof(Plane)] = plane;
+            singleChecks[typeof(Surface)] = vSurface;
+            singleChecks[typeof(UV)] = vUV;
+            singleChecks[typeof(Curve)] = vCurve;
+            singleChecks[typeof(Arc)] = vArc;
+            singleChecks[typeof(Circle)] = vCircle;
+            singleChecks[typeof(Ellipse)] = vEllipse;
+            singleChecks[typeof(EllipseArc)] = vEllipseArc;
+            singleChecks[typeof(Helix)] = vHelix;
+            singleChecks[typeof(Line)] = vLine;
+            singleChecks[typeof(NurbsCurve)] = vNurbsCurve;
+            singleChecks[typeof(PolyCurve)] = vPolyCurve;
+            singleChecks[typeof(Polygon)] = vPolygon;
+            singleChecks[typeof(Autodesk.DesignScript.Geometry.Rectangle)] = vRectangle;
+            singleChecks[typeof(Mesh)] = vMesh;
+            singleChecks[typeof(Solid)] = vSolid;
+            singleChecks[typeof(Cone)] = vCone;
+            singleChecks[typeof(Cylinder)] = vCylinder;
+            singleChecks[typeof(Cuboid)] = vCuboid;
+            singleChecks[typeof(Sphere)] = vSphere;
+            singleChecks[typeof(NurbsSurface)] = vNurbsSurface;
+            singleChecks[typeof(PolySurface)] = vPolySurface;
+
+            foreach (var kv in singleChecks)
+            {
+                Assert.AreEqual(
+                    true,
+                    DSCore.Data.IsSupportedDataNodeDynamoType(kv.Value, kv.Key.ToString(), false),
+                    String.Format($"Couldn't validate {kv.Key} input."));
+            }
+
+            // Assert - check list - fail
+            var validate = DSCore.Data.IsSupportedDataNodeDynamoType(invBoundingBoxList, typeof(BoundingBox).ToString(), true);
+            Assert.AreEqual(false, validate, "Shouldn't validate heterogenous list input.");
+
+            // Assert - check homogenous list values - succeed
+            var listChecks = new Dictionary<Type, object>();
+            listChecks[typeof(BoundingBox)] = vBoundingBoxList;
+            listChecks[typeof(CoordinateSystem)] = vCoordinateSystemList;
+            listChecks[typeof(Autodesk.DesignScript.Geometry.Point)] = vPointList;
+            listChecks[typeof(Vector)] = vVectorList;
+            listChecks[typeof(Plane)] = vPlaneList;
+            listChecks[typeof(Surface)] = vSurfaceList;
+            listChecks[typeof(UV)] = vUVList;
+            listChecks[typeof(Curve)] = vCurveList;
+            listChecks[typeof(Arc)] = vArcList;
+            listChecks[typeof(Circle)] = vCircleList;
+            listChecks[typeof(Ellipse)] = vEllipseList;
+            listChecks[typeof(EllipseArc)] = vEllipseArcList;
+            listChecks[typeof(Helix)] = vHelixList;
+            listChecks[typeof(Line)] = vLineList;
+            listChecks[typeof(NurbsCurve)] = vNurbsCurveList;
+            listChecks[typeof(PolyCurve)] = vPolyCurveList;
+            listChecks[typeof(Polygon)] = vPolygonList;
+            listChecks[typeof(Autodesk.DesignScript.Geometry.Rectangle)] = vRectangleList;
+            listChecks[typeof(Mesh)] = vMeshList;
+            listChecks[typeof(Solid)] = vSolidList;
+            listChecks[typeof(Cone)] = vConeList;
+            listChecks[typeof(Cylinder)] = vCylinderList;
+            listChecks[typeof(Cuboid)] = vCuboidList;
+            listChecks[typeof(Sphere)] = vSphereList;
+            listChecks[typeof(NurbsSurface)] = vNurbsSurfaceList;
+            listChecks[typeof(PolySurface)] = vPolySurfaceList;
+
+            foreach (var kv in listChecks)
+            {
+                Assert.AreEqual(
+                    true,
+                    DSCore.Data.IsSupportedDataNodeDynamoType(kv.Value, kv.Key.ToString(), true),
+                    String.Format($"Couldn't validate {kv.Key} list input."));
+            }
+        }
+
+        [Test]
+        [Category("UnitTests")]
+        public void IsSupprtedInheritanceDataType()
+        {
+            // Primitives
+            var point = Autodesk.DesignScript.Geometry.Point.ByCoordinates(1, 1, 1);
+            var point2 = Autodesk.DesignScript.Geometry.Point.ByCoordinates(2, 2, 1);
+            var point3 = Autodesk.DesignScript.Geometry.Point.ByCoordinates(3, 3, 3);
+            var vector = Vector.ByCoordinates(0, 0, 1);
+            var plane = Plane.ByBestFitThroughPoints([point, point2, point3]);
+            var vCoordinateSystem = CoordinateSystem.ByOrigin(0, 0);
+            var vSurface = Surface.ByPerimeterPoints([point, point2, point3]);
+
+            // Curve
+            var vUV = UV.ByCoordinates(0, 0);
+            var vCurve = Curve.ByParameterLineOnSurface(vSurface, vUV, vUV);
+            var vArc = Arc.ByThreePoints(point, point2, point3);
+            var vCircle = Circle.ByBestFitThroughPoints([point, point2, point3]);
+            var vEllipse = Ellipse.ByOriginRadii(point, 5, 5);
+            var vEllipseArc = EllipseArc.ByPlaneRadiiAngles(plane, 2, 2, 0, 180);
+            var vHelix = Helix.ByAxis(point, vector, point3, 1, 360);
+            var vLine = Line.ByBestFitThroughPoints([point, point2, point3]);
+            var vNurbsCurve = NurbsCurve.ByControlPoints([point, point2, point3, point]);
+            var vPolyCurve = PolyCurve.ByJoinedCurves([vCurve, vCurve], 0.001);
+            var vPolygon = Polygon.ByPoints([point, point2, point3, point]);
+            var vRectangle = Autodesk.DesignScript.Geometry.Rectangle.ByWidthLength(5, 10);
+
+
+            var indexGroup = IndexGroup.ByIndices(0, 1, 2);
+            var vMesh = Mesh.ByPointsFaceIndices([point, point2, point3], [indexGroup, indexGroup, indexGroup]);
+
+            // Solid
+            var vSolid = Solid.ByJoinedSurfaces([vSurface, vSurface, vSurface, vSurface, vSurface, vSurface]);
+            var vCone = Cone.ByCoordinateSystemHeightRadii(vCoordinateSystem, 1, 1, 1);
+            var vCylinder = Cylinder.ByPointsRadius(point, point3, 1);
+            var vCuboid = Cuboid.ByCorners(point, point3);
+            var vSphere = Sphere.ByCenterPointRadius(point, 1);
+
+            // Surface
+            var vNurbsSurface = NurbsSurface.ByControlPoints([[point, point2, point3, point],
+                [point, point3, point2, point],
+                [point2, point3, point, point2]], 2, 2);
+            var vPolySurface = PolySurface.ByJoinedSurfaces([vSurface, vSurface]);
+
+            // Heterogeneous lists
+            var vCurveInheritanceList = new ArrayList() { vRectangle, vPolygon, vNurbsCurve, vEllipse };
+            var vPolyCurveInheritanceList = new ArrayList() { vRectangle, vPolygon, vPolyCurve };
+            var vSolidInheritanceList = new ArrayList() { vSolid, vCone, vCylinder, vCuboid, vSphere };
+            var vSurfaceInheritanceList = new ArrayList() { vNurbsSurface, vPolySurface };
+
+            var ivCurveInheritanceList = new ArrayList() { vRectangle, vPolygon, vNurbsCurve, vEllipse, vSphere };
+            var ivPolyCurveInheritanceList = new ArrayList() { vRectangle, vPolygon, vPolyCurve, vCurve };
+            var ivSolidInheritanceList = new ArrayList() { vPolygon, vCone, vCylinder, vCuboid, vSphere };
+            var ivSurfaceInheritanceList = new ArrayList() { vNurbsSurface, vPolySurface, vCylinder, vCuboid, vSphere };
+
+            // Assert - check single upward inheritence - succeed
+            var validate = DSCore.Data.IsSupportedDataNodeDynamoType(vRectangle, typeof(Curve).ToString(), false);
+            Assert.AreEqual(true, validate, "Couldn't vaidate Rectangle inheritance from Curve.");
+
+            // Assert - check single downward inheritance - fail 
+            validate = DSCore.Data.IsSupportedDataNodeDynamoType(vCurve, typeof(Autodesk.DesignScript.Geometry.Rectangle).ToString(), false);
+            Assert.AreEqual(false, validate, "Shouldn't vaidate Curve inheritance from Rectangle.");
+
+            validate = DSCore.Data.IsSupportedDataNodeDynamoType(vCone, typeof(Curve).ToString(), false);
+            Assert.AreEqual(false, validate, "Shouldn't vaidate Cone inheritance from Curve.");
+
+            // Assert - check heterogeneous list values - succeed
+            validate = DSCore.Data.IsSupportedDataNodeDynamoType(vCurveInheritanceList, typeof(Curve).ToString(), true);
+            Assert.AreEqual(true, validate, "Couldn't validate DataTypes inheriting from Curve in a heterogeneous list input.");
+
+            validate = DSCore.Data.IsSupportedDataNodeDynamoType(vPolyCurveInheritanceList, typeof(PolyCurve).ToString(), true);
+            Assert.AreEqual(true, validate, "Couldn't validate DataTypes inheriting from PolyCurve in a heterogeneous list input.");
+
+            validate = DSCore.Data.IsSupportedDataNodeDynamoType(vSolidInheritanceList, typeof(Solid).ToString(), true);
+            Assert.AreEqual(true, validate, "Couldn't validate DataTypes inheriting from Solid in a heterogeneous list input.");
+
+            validate = DSCore.Data.IsSupportedDataNodeDynamoType(vSurfaceInheritanceList, typeof(Surface).ToString(), true);
+            Assert.AreEqual(true, validate, "Couldn't validate DataTypes inheriting from Surface in a heterogeneous list input.");
+
+
+            // Assert - check invalid heterogeneous list values - fail
+            validate = DSCore.Data.IsSupportedDataNodeDynamoType(ivCurveInheritanceList, typeof(Curve).ToString(), true);
+            Assert.AreEqual(false, validate, "Shouldn't validate DataTypes inheriting from Curve if there is a Sphere in the list input.");
+
+            validate = DSCore.Data.IsSupportedDataNodeDynamoType(ivPolyCurveInheritanceList, typeof(PolyCurve).ToString(), true);
+            Assert.AreEqual(false, validate, "Shouldn't validate DataTypes - Curve does not inherit from PolyCurve.");
+
+            validate = DSCore.Data.IsSupportedDataNodeDynamoType(ivSolidInheritanceList, typeof(Solid).ToString(), true);
+            Assert.AreEqual(false, validate, "Shouldn't validate DataTypes inheriting from Solid if there is a Polygone in the list input.");
+
+            validate = DSCore.Data.IsSupportedDataNodeDynamoType(ivSurfaceInheritanceList, typeof(Surface).ToString(), true);
+            Assert.AreEqual(false, validate, "Shouldn't validate DataTypes inheriting from Surface with Cylindar, Cuboid and Sphere in the list.");
         }
     }
 }