fix: add IMeterFeedback interface

feat: Update .gitignore and enhance routing-related classes

.vscode/extensions.json

@@ -0,0 +1,9 @@
+{
+  "recommendations": [
+    "ms-dotnettools.vscode-dotnet-runtime",
+    "ms-dotnettools.csharp",
+    "ms-dotnettools.csdevkit",
+    "vivaxy.vscode-conventional-commits",
+    "mhutchie.git-graph"
+  ]
+}

src/PepperDash.Core/Device.cs

@@ -11,35 +11,35 @@ namespace PepperDash.Core
 	public class Device : IKeyName
 	{
 
-        /// <summary>
-        /// Unique Key
-        /// </summary>
+		/// <summary>
+		/// Unique Key
+		/// </summary>
 		public string Key { get; protected set; }
 		/// <summary>
 		/// Name of the devie
 		/// </summary>
-        public string Name { get; protected set; }
-        /// <summary>
-        /// 
-        /// </summary>
+		public string Name { get; protected set; }
+		/// <summary>
+		/// 
+		/// </summary>
 		public bool Enabled { get; protected set; }
 
-        ///// <summary>
-        ///// A place to store reference to the original config object, if any. These values should 
-        ///// NOT be used as properties on the device as they are all publicly-settable values.
-        ///// </summary>
-        //public DeviceConfig Config { get; private set; }
-        ///// <summary>
-        ///// Helper method to check if Config exists
-        ///// </summary>
-        //public bool HasConfig { get { return Config != null; } }
+		///// <summary>
+		///// A place to store reference to the original config object, if any. These values should 
+		///// NOT be used as properties on the device as they are all publicly-settable values.
+		///// </summary>
+		//public DeviceConfig Config { get; private set; }
+		///// <summary>
+		///// Helper method to check if Config exists
+		///// </summary>
+		//public bool HasConfig { get { return Config != null; } }
 
 		List<Action> _PreActivationActions;
 		List<Action> _PostActivationActions;
 
-        /// <summary>
-        /// 
-        /// </summary>
+		/// <summary>
+		/// 
+		/// </summary>
 		public static Device DefaultDevice { get { return _DefaultDevice; } }
 		static Device _DefaultDevice = new Device("Default", "Default");
 
@@ -54,27 +54,27 @@ namespace PepperDash.Core
 			Name = "";
 		}
 
-        /// <summary>
-        /// Constructor with key and name
-        /// </summary>
-        /// <param name="key"></param>
-        /// <param name="name"></param>
+		/// <summary>
+		/// Constructor with key and name
+		/// </summary>
+		/// <param name="key"></param>
+		/// <param name="name"></param>
 		public Device(string key, string name) : this(key)
 		{
 			Name = name;
 
 		}
 
-        //public Device(DeviceConfig config)
-        //    : this(config.Key, config.Name)
-        //{
-        //    Config = config;
-        //}
+		//public Device(DeviceConfig config)
+		//    : this(config.Key, config.Name)
+		//{
+		//    Config = config;
+		//}
 
-        /// <summary>
-        /// Adds a pre activation action
-        /// </summary>
-        /// <param name="act"></param>
+		/// <summary>
+		/// Adds a pre activation action
+		/// </summary>
+		/// <param name="act"></param>
 		public void AddPreActivationAction(Action act)
 		{
 			if (_PreActivationActions == null)
@@ -82,10 +82,10 @@ namespace PepperDash.Core
 			_PreActivationActions.Add(act);
 		}
 
-        /// <summary>
-        /// Adds a post activation action
-        /// </summary>
-        /// <param name="act"></param>
+		/// <summary>
+		/// Adds a post activation action
+		/// </summary>
+		/// <param name="act"></param>
 		public void AddPostActivationAction(Action act)
 		{
 			if (_PostActivationActions == null)
@@ -93,55 +93,58 @@ namespace PepperDash.Core
 			_PostActivationActions.Add(act);
 		}
 
-        /// <summary>
-        /// Executes the preactivation actions
-        /// </summary>
-        public void PreActivate()
-        {
-            if (_PreActivationActions != null)
-                _PreActivationActions.ForEach(a => {
+		/// <summary>
+		/// Executes the preactivation actions
+		/// </summary>
+		public void PreActivate()
+		{
+			if (_PreActivationActions != null)
+				_PreActivationActions.ForEach(a =>
+				{
 					try
 					{
 						a.Invoke();
-					} catch (Exception e)
-					{ 
+					}
+					catch (Exception e)
+					{
 						Debug.LogMessage(e, "Error in PreActivationAction: " + e.Message, this);
 					}
-            });
-        }
+				});
+		}
 
 		/// <summary>
 		/// Gets this device ready to be used in the system. Runs any added pre-activation items, and
 		/// all post-activation at end. Classes needing additional logic to 
 		/// run should override CustomActivate()
 		/// </summary>
-		public bool Activate() 
+		public bool Activate()
 		{
-            //if (_PreActivationActions != null)
-            //    _PreActivationActions.ForEach(a => a.Invoke());
+			//if (_PreActivationActions != null)
+			//    _PreActivationActions.ForEach(a => a.Invoke());
 			var result = CustomActivate();
-            //if(result && _PostActivationActions != null)
-            //    _PostActivationActions.ForEach(a => a.Invoke());
-			return result; 	
+			//if(result && _PostActivationActions != null)
+			//    _PostActivationActions.ForEach(a => a.Invoke());
+			return result;
 		}
 
-        /// <summary>
-        /// Executes the postactivation actions
-        /// </summary>
-        public void PostActivate()
-        {
-            if (_PostActivationActions != null)
-                _PostActivationActions.ForEach(a => {
-                    try
-                    {
-                        a.Invoke();
-                    }
-                    catch (Exception e)
-                    {
-                        Debug.LogMessage(e, "Error in PostActivationAction: " + e.Message, this);
-                    }
-                });
-        }
+		/// <summary>
+		/// Executes the postactivation actions
+		/// </summary>
+		public void PostActivate()
+		{
+			if (_PostActivationActions != null)
+				_PostActivationActions.ForEach(a =>
+				{
+					try
+					{
+						a.Invoke();
+					}
+					catch (Exception e)
+					{
+						Debug.LogMessage(e, "Error in PostActivationAction: " + e.Message, this);
+					}
+				});
+		}
 
 		/// <summary>
 		/// Called in between Pre and PostActivationActions when Activate() is called. 
@@ -158,14 +161,14 @@ namespace PepperDash.Core
 		/// <returns></returns>
 		public virtual bool Deactivate() { return true; }
 
-        /// <summary>
-        /// Call this method to start communications with a device. Overriding classes do not need to call base.Initialize()
-        /// </summary>
-	    public virtual void Initialize()
-	    {
-	    }
+		/// <summary>
+		/// Call this method to start communications with a device. Overriding classes do not need to call base.Initialize()
+		/// </summary>
+		public virtual void Initialize()
+		{
+		}
 
-	    /// <summary>
+		/// <summary>
 		/// Helper method to check object for bool value false and fire an Action method
 		/// </summary>
 		/// <param name="o">Should be of type bool, others will be ignored</param>
@@ -175,5 +178,15 @@ namespace PepperDash.Core
 			if (o is bool && !(bool)o) a();
 		}
 
+        /// <summary>
+        /// Returns a string representation of the object, including its key and name.
+        /// </summary>
+        /// <remarks>The returned string is formatted as "{Key} - {Name}". If the <c>Name</c> property is
+        /// null or empty,  "---" is used in place of the name.</remarks>
+        /// <returns>A string that represents the object, containing the key and name in the format "{Key} - {Name}".</returns>
+		public override string ToString()
+		{
+			return string.Format("{0} - {1}", Key, string.IsNullOrEmpty(Name) ? "---" : Name);
+		}
 	}
 }

src/PepperDash.Essentials.Core/DeviceTypeInterfaces/IMeterFeedback.cs

@@ -0,0 +1,18 @@
+using System;
+
+namespace PepperDash.Essentials.Core.DeviceTypeInterfaces
+{
+
+  /// <summary>
+  /// Interface for devices that provide audio meter feedback.
+  /// This interface is used to standardize access to meter feedback across different devices.
+  /// </summary>
+  public interface IMeterFeedback
+  {
+    /// <summary>
+    /// Gets the meter feedback for the device.
+    /// This property provides an IntFeedback that represents the current audio level or meter value.
+    /// </summary>
+    IntFeedback MeterFeedback { get; }
+  }
+}

src/PepperDash.Essentials.Core/DeviceTypeInterfaces/INvxNetworkPortInformation.cs

@@ -0,0 +1,90 @@
+using Crestron.SimplSharpPro.DM.Streaming;
+using System;
+using System.Collections.Generic;
+
+namespace PepperDash.Essentials.Core
+{
+    /// <summary>
+    /// Represents a collection of network port information and provides notifications when the information changes.
+    /// </summary>
+    /// <remarks>This interface is designed to provide access to a list of network port details and to notify
+    /// subscribers when the port information is updated. Implementations of this interface should ensure that the  <see
+    /// cref="PortInformationChanged"/> event is raised whenever the <see cref="NetworkPorts"/> collection
+    /// changes.</remarks>
+    public interface INvxNetworkPortInformation
+    {
+        /// <summary>
+        /// Occurs when the port information changes.
+        /// </summary>
+        /// <remarks>This event is triggered whenever there is a change in the port information, such as
+        /// updates to port settings or status. Subscribers can handle this event to respond to such changes.</remarks>
+        event EventHandler PortInformationChanged;
+
+        /// <summary>
+        /// Gets the collection of network port information associated with the current instance.
+        /// </summary>
+        /// <remarks>The collection provides information about the network ports, such as their status,
+        /// configuration, or other relevant details. The returned list is read-only and cannot be modified
+        /// directly.</remarks>
+        List<NvxNetworkPortInformation> NetworkPorts { get; }
+    }
+
+    /// <summary>
+    /// Represents information about a network port, including its configuration and associated system details.
+    /// </summary>
+    /// <remarks>This class provides properties to describe various attributes of a network port, such as its
+    /// name, description, VLAN configuration, and management IP address. It is typically used to store and retrieve 
+    /// metadata about network ports in a managed environment.</remarks>
+    public class NvxNetworkPortInformation
+    {
+        private readonly DmNvxBaseClass.DmNvx35xNetwork.DmNvxNetworkLldpPort port;
+
+        /// <summary>
+        /// Gets or sets the index of the device port.
+        /// </summary>
+        public uint DevicePortIndex { get; }
+
+        /// <summary>
+        /// Gets or sets the name of the port used for communication.
+        /// </summary>        
+        public string PortName => port.PortNameFeedback.StringValue;
+
+        /// <summary>
+        /// Gets or sets the description of the port.
+        /// </summary>
+        public string PortDescription => port.PortNameDescriptionFeedback.StringValue;
+
+        /// <summary>
+        /// Gets or sets the name of the VLAN (Virtual Local Area Network).
+        /// </summary>
+        public string VlanName => port.VlanNameFeedback.StringValue;
+
+        /// <summary>
+        /// Gets the IP management address associated with the port.
+        /// </summary>
+        public string IpManagementAddress => port.IpManagementAddressFeedback.StringValue;
+
+        /// <summary>
+        /// Gets the name of the system as reported by the associated port.
+        /// </summary>
+        public string SystemName => port.SystemNameFeedback.StringValue;
+
+        /// <summary>
+        /// Gets the description of the system name.
+        /// </summary>
+        public string SystemNameDescription => port.SystemNameDescriptionFeedback.StringValue;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="NvxNetworkPortInformation"/> class with the specified network port
+        /// and device port index.
+        /// </summary>
+        /// <param name="port">The network port associated with the device. Cannot be <see langword="null"/>.</param>
+        /// <param name="devicePortIndex">The index of the device port.</param>
+        /// <exception cref="ArgumentNullException">Thrown if <paramref name="port"/> is <see langword="null"/>.</exception>
+        public NvxNetworkPortInformation(DmNvxBaseClass.DmNvx35xNetwork.DmNvxNetworkLldpPort port, uint devicePortIndex)
+        {
+            this.port = port ?? throw new ArgumentNullException(nameof(port), "Port cannot be null");
+            DevicePortIndex = devicePortIndex;
+        }
+    }
+}

src/PepperDash.Essentials.Core/Devices/DeviceManager.cs

@@ -248,7 +248,7 @@ namespace PepperDash.Essentials.Core
 
             foreach (var dev in Devices.Values.OfType<ICommunicationMonitor>())
             {
-                CrestronConsole.ConsoleCommandResponse($"{dev}: {dev.CommunicationMonitor.Status}{Environment.NewLine}");
+                CrestronConsole.ConsoleCommandResponse($"{dev}: {dev.CommunicationMonitor.Status}\r\n");
             }
         }
 

src/PepperDash.Essentials.Core/Devices/EssentialsDevice.cs

@@ -20,19 +20,20 @@ namespace PepperDash.Essentials.Core
         public event EventHandler Initialized;
 
         private bool _isInitialized;
-        public bool IsInitialized { 
+        public bool IsInitialized
+        {
             get { return _isInitialized; }
-            private set 
-            { 
+            private set
+            {
                 if (_isInitialized == value) return;
-                
+
                 _isInitialized = value;
 
                 if (_isInitialized)
                 {
                     Initialized?.Invoke(this, new EventArgs());
                 }
-            } 
+            }
         }
 
         protected EssentialsDevice(string key)
@@ -80,8 +81,9 @@ namespace PepperDash.Essentials.Core
         /// <summary>
         /// Override this method to build and create custom Mobile Control Messengers during the Activation phase
         /// </summary>
-        protected virtual void CreateMobileControlMessengers() {
-           
+        protected virtual void CreateMobileControlMessengers()
+        {
+
         }
     }
 

src/PepperDash.Essentials.Core/Room/Combining/EssentialsRoomCombiner.cs

@@ -10,6 +10,13 @@ using System.Threading.Tasks;
 
 namespace PepperDash.Essentials.Core
 {
+    /// <summary>
+    /// Represents a device that manages room combinations by controlling partitions and scenarios.
+    /// </summary>
+    /// <remarks>The <see cref="EssentialsRoomCombiner"/> allows for dynamic configuration of room
+    /// combinations  based on partition states and predefined scenarios. It supports both automatic and manual modes 
+    /// for managing room combinations. In automatic mode, the device determines the current room  combination scenario
+    /// based on partition sensor states. In manual mode, scenarios can be set  explicitly by the user.</remarks>
     public class EssentialsRoomCombiner : EssentialsDevice, IEssentialsRoomCombiner
     {
         private EssentialsRoomCombinerPropertiesConfig _propertiesConfig;
@@ -18,6 +25,9 @@ namespace PepperDash.Essentials.Core
 
         private List<IEssentialsRoom> _rooms;
 
+        /// <summary>
+        /// Gets a list of rooms represented as key-name pairs.
+        /// </summary>
         public List<IKeyName> Rooms
         {
             get
@@ -28,6 +38,12 @@ namespace PepperDash.Essentials.Core
 
         private bool _isInAutoMode;
 
+        /// <summary>
+        /// Gets or sets a value indicating whether the system is operating in automatic mode.
+        /// </summary>
+        /// <remarks>Changing this property triggers an update event via
+        /// <c>IsInAutoModeFeedback.FireUpdate()</c>. Ensure that any event listeners are properly configured to handle
+        /// this update.</remarks>
         public bool IsInAutoMode
         {
             get
@@ -46,12 +62,36 @@ namespace PepperDash.Essentials.Core
             }
         }
 
+        /// <summary>
+        /// Gets a value indicating whether automatic mode is disabled.
+        /// </summary>
+        public bool DisableAutoMode
+        {
+            get
+            {
+                return _propertiesConfig.DisableAutoMode;
+            }
+        }
+
         private CTimer _scenarioChangeDebounceTimer;
 
         private int _scenarioChangeDebounceTimeSeconds = 10; // default to 10s
 
         private Mutex _scenarioChange = new Mutex();
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="EssentialsRoomCombiner"/> class, which manages room combination
+        /// scenarios and partition states.
+        /// </summary>
+        /// <remarks>The <see cref="EssentialsRoomCombiner"/> class is designed to handle dynamic room
+        /// combination scenarios based on partition states. It supports both automatic and manual modes for managing
+        /// room combinations. By default, the instance starts in automatic mode unless the <paramref name="props"/>
+        /// specifies otherwise.  After activation, the room combiner initializes partition state providers and sets up
+        /// the initial room configuration. Additionally, it subscribes to the <see
+        /// cref="DeviceManager.AllDevicesInitialized"/> event to ensure proper initialization of dependent devices
+        /// before determining or setting the room combination scenario.</remarks>
+        /// <param name="key">The unique identifier for the room combiner instance.</param>
+        /// <param name="props">The configuration properties for the room combiner, including default settings and debounce times.</param>
         public EssentialsRoomCombiner(string key, EssentialsRoomCombinerPropertiesConfig props)
             : base(key)
         {
@@ -246,8 +286,16 @@ namespace PepperDash.Essentials.Core
 
         #region IEssentialsRoomCombiner Members
 
+        /// <summary>
+        /// Occurs when the room combination scenario changes.
+        /// </summary>
+        /// <remarks>This event is triggered whenever the configuration or state of the room combination
+        /// changes. Subscribers can use this event to update their logic or UI based on the new scenario.</remarks>
         public event EventHandler<EventArgs> RoomCombinationScenarioChanged;
 
+        /// <summary>
+        /// Gets the current room combination scenario.
+        /// </summary>
         public IRoomCombinationScenario CurrentScenario
         {
             get
@@ -256,10 +304,25 @@ namespace PepperDash.Essentials.Core
             }
         }
 
+        /// <summary>
+        /// Gets the feedback indicating whether the system is currently in auto mode.
+        /// </summary>
         public BoolFeedback IsInAutoModeFeedback { get; private set; }
 
+        /// <summary>
+        /// Enables auto mode for the room combiner and its partitions, allowing automatic room combination scenarios to
+        /// be determined.
+        /// </summary>
+        /// <remarks>Auto mode allows the room combiner to automatically adjust its configuration based on
+        /// the state of its partitions.  If auto mode is disabled in the configuration, this method logs a warning and
+        /// does not enable auto mode.</remarks>
         public void SetAutoMode()
         {
+            if(_propertiesConfig.DisableAutoMode)
+            {
+                this.LogWarning("Auto mode is disabled for this room combiner. Cannot set to auto mode.");
+                return;
+            }
             IsInAutoMode = true;
 
             foreach (var partition in Partitions)
@@ -270,6 +333,12 @@ namespace PepperDash.Essentials.Core
             DetermineRoomCombinationScenario();
         }
 
+        /// <summary>
+        /// Switches the system to manual mode, disabling automatic operations.
+        /// </summary>
+        /// <remarks>This method sets the system to manual mode by updating the mode state and propagates 
+        /// the change to all partitions. Once in manual mode, automatic operations are disabled  for the system and its
+        /// partitions.</remarks>
         public void SetManualMode()
         {
             IsInAutoMode = false;
@@ -280,6 +349,11 @@ namespace PepperDash.Essentials.Core
             }
         }
 
+        /// <summary>
+        /// Toggles the current mode between automatic and manual.
+        /// </summary>
+        /// <remarks>If the current mode is automatic, this method switches to manual mode.  If the
+        /// current mode is manual, it switches to automatic mode.</remarks>
         public void ToggleMode()
         {
             if (IsInAutoMode)
@@ -292,10 +366,22 @@ namespace PepperDash.Essentials.Core
             }
         }
 
+        /// <summary>
+        /// Gets the collection of room combination scenarios.
+        /// </summary>
         public List<IRoomCombinationScenario> RoomCombinationScenarios { get; private set; }
 
+        /// <summary>
+        /// Gets the collection of partition controllers managed by this instance.
+        /// </summary>
         public List<IPartitionController> Partitions { get; private set; }
 
+        /// <summary>
+        /// Toggles the state of the partition identified by the specified partition key.
+        /// </summary>
+        /// <remarks>If no partition with the specified key exists, the method performs no
+        /// action.</remarks>
+        /// <param name="partitionKey">The key of the partition whose state is to be toggled. This value cannot be null or empty.</param>
         public void TogglePartitionState(string partitionKey)
         {
             var partition = Partitions.FirstOrDefault((p) => p.Key.Equals(partitionKey));
@@ -306,6 +392,17 @@ namespace PepperDash.Essentials.Core
             }
         }
 
+        /// <summary>
+        /// Sets the room combination scenario based on the specified scenario key.
+        /// </summary>
+        /// <remarks>This method manually adjusts the partition states according to the specified
+        /// scenario. If the application is in auto mode,  the operation will not proceed, and a log message will be
+        /// generated indicating that the mode must be set to manual first.  If the specified scenario key does not
+        /// match any existing scenario, a debug log message will be generated. For each partition state in the
+        /// scenario, the corresponding partition will be updated to either "Present" or "Not Present"  based on the
+        /// scenario's configuration. If a partition key in the scenario cannot be found, a debug log message will be
+        /// generated.</remarks>
+        /// <param name="scenarioKey">The key identifying the room combination scenario to apply. This must match the key of an existing scenario.</param>
         public void SetRoomCombinationScenario(string scenarioKey)
         {
             if (IsInAutoMode)
@@ -354,13 +451,32 @@ namespace PepperDash.Essentials.Core
         #endregion
     }
 
+    /// <summary>
+    /// Provides a factory for creating instances of <see cref="EssentialsRoomCombiner"/> devices.
+    /// </summary>
+    /// <remarks>This factory is responsible for constructing <see cref="EssentialsRoomCombiner"/> devices
+    /// based on the provided configuration. It supports the type name "essentialsroomcombiner" for device
+    /// creation.</remarks>
     public class EssentialsRoomCombinerFactory : EssentialsDeviceFactory<EssentialsRoomCombiner>
     {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="EssentialsRoomCombinerFactory"/> class.
+        /// </summary>
+        /// <remarks>This factory is used to create instances of room combiners with the specified type
+        /// names. By default, the factory includes the type name "essentialsroomcombiner".</remarks>
         public EssentialsRoomCombinerFactory()
         {
             TypeNames = new List<string> { "essentialsroomcombiner" };
         }
 
+        /// <summary>
+        /// Creates and initializes a new instance of the <see cref="EssentialsRoomCombiner"/> device.
+        /// </summary>
+        /// <remarks>This method uses the provided device configuration to extract the properties and
+        /// create an  <see cref="EssentialsRoomCombiner"/> device. Ensure that the configuration contains valid 
+        /// properties for the device to be created successfully.</remarks>
+        /// <param name="dc">The device configuration containing the key and properties required to build the device.</param>
+        /// <returns>A new instance of <see cref="EssentialsRoomCombiner"/> initialized with the specified configuration.</returns>
         public override EssentialsDevice BuildDevice(PepperDash.Essentials.Core.Config.DeviceConfig dc)
         {
             Debug.LogMessage(LogEventLevel.Debug, "Factory Attempting to create new EssentialsRoomCombiner Device");

src/PepperDash.Essentials.Core/Room/Combining/EssentialsRoomCombinerPropertiesConfig.cs

@@ -1,10 +1,4 @@
-
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using Crestron.SimplSharp;
+using System.Collections.Generic;
 
 using PepperDash.Core;
 
@@ -17,6 +11,14 @@ namespace PepperDash.Essentials.Core
     /// </summary>
     public class EssentialsRoomCombinerPropertiesConfig
     {
+        /// <summary>
+        /// Gets or sets a value indicating whether the system operates in automatic mode.
+        /// <remarks>Some systems don't have partitions sensors, and show shouldn't allow auto mode to be turned on. When this is true in the configuration, 
+        /// auto mode won't be allowed to be turned on.</remarks>
+        /// </summary>
+        [JsonProperty("disableAutoMode")]
+        public bool DisableAutoMode { get; set; }
+
         /// <summary>
         /// The list of partitions that device the rooms
         /// </summary>
@@ -47,6 +49,9 @@ namespace PepperDash.Essentials.Core
         [JsonProperty("defaultScenarioKey")]
         public string defaultScenarioKey { get; set; }
 
+        /// <summary>
+        /// Gets or sets the debounce time, in seconds, for scenario changes.
+        /// </summary>
         [JsonProperty("scenarioChangeDebounceTimeSeconds")]
         public int ScenarioChangeDebounceTimeSeconds { get; set; }
     }
@@ -56,9 +61,15 @@ namespace PepperDash.Essentials.Core
     /// </summary>
     public class PartitionConfig : IKeyName
     {
+        /// <summary>
+        /// Gets or sets the unique key associated with the object.
+        /// </summary>
         [JsonProperty("key")]
         public string Key { get; set; }
 
+        /// <summary>
+        /// Gets or sets the name associated with the object.
+        /// </summary>
         [JsonProperty("name")]
         public string Name { get; set; }
 
@@ -80,12 +91,21 @@ namespace PepperDash.Essentials.Core
     /// </summary>
     public class RoomCombinationScenarioConfig : IKeyName
     {
+        /// <summary>
+        /// Gets or sets the key associated with the object.
+        /// </summary>
         [JsonProperty("key")]
         public string Key { get; set; }
 
+        /// <summary>
+        /// Gets or sets the name associated with the object.
+        /// </summary>
         [JsonProperty("name")]
         public string Name { get; set; }
 
+        /// <summary>
+        /// Gets or sets the collection of partition states.
+        /// </summary>
         [JsonProperty("partitionStates")]
         public List<PartitionState> PartitionStates { get; set; }
 
@@ -95,9 +115,15 @@ namespace PepperDash.Essentials.Core
         [JsonProperty("uiMap")]
         public Dictionary<string, string> UiMap { get; set; }
 
+        /// <summary>
+        /// Gets or sets the list of actions to be performed during device activation.
+        /// </summary>
         [JsonProperty("activationActions")]
         public List<DeviceActionWrapper> ActivationActions { get; set; }
 
+        /// <summary>
+        /// Gets or sets the list of actions to be performed when a device is deactivated.
+        /// </summary>
         [JsonProperty("deactivationActions")]
         public List<DeviceActionWrapper> DeactivationActions { get; set; }    
     }
@@ -107,9 +133,15 @@ namespace PepperDash.Essentials.Core
     /// </summary>
     public class PartitionState
     {
+        /// <summary>
+        /// Gets or sets the partition key used to group and organize data within a storage system.
+        /// </summary>
         [JsonProperty("partitionKey")]
         public string PartitionKey { get; set; }
 
+        /// <summary>
+        /// Gets or sets a value indicating whether a partition is currently present.
+        /// </summary>
         [JsonProperty("partitionSensedState")]
         public bool PartitionPresent { get; set; }
     }

src/PepperDash.Essentials.Core/Room/Combining/IEssentialsRoomCombiner.cs

@@ -28,9 +28,20 @@ namespace PepperDash.Essentials.Core
         [JsonIgnore]
         BoolFeedback IsInAutoModeFeedback {get;}
 
+        /// <summary>
+        /// Gets a value indicating whether the automatic mode is disabled.
+        /// </summary>
+        [JsonProperty("disableAutoMode")]
+        bool DisableAutoMode { get; }
+        /// <summary>
+        /// Gets a value indicating whether the system is operating in automatic mode.
+        /// </summary>
         [JsonProperty("isInAutoMode")]
         bool IsInAutoMode { get; }
 
+        /// <summary>
+        /// Gets the collection of rooms associated with the current object.
+        /// </summary>
         [JsonProperty("rooms")]
         List<IKeyName> Rooms { get; }
 
@@ -74,6 +85,13 @@ namespace PepperDash.Essentials.Core
         void SetRoomCombinationScenario(string scenarioKey);
     }
 
+    /// <summary>
+    /// Represents a scenario for combining rooms, including activation, deactivation, and associated state.
+    /// </summary>
+    /// <remarks>This interface defines the behavior for managing room combination scenarios, including
+    /// activation and deactivation, tracking the active state, and managing related partition states and UI mappings.
+    /// Implementations of this interface are expected to handle the logic for room combinations based on the provided
+    /// partition states and UI mappings.</remarks>
     public interface IRoomCombinationScenario : IKeyName
     {
         /// <summary>
@@ -82,6 +100,9 @@ namespace PepperDash.Essentials.Core
         [JsonIgnore]
         BoolFeedback IsActiveFeedback { get; }
 
+        /// <summary>
+        /// Gets a value indicating whether the entity is active.
+        /// </summary>
         [JsonProperty("isActive")]
         bool IsActive { get; }
 

src/PepperDash.Essentials.Devices.Common/Cameras/CameraControl.cs

@@ -3,60 +3,29 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using Crestron.SimplSharp;
-using PepperDash.Core;
+
 using PepperDash.Essentials.Core;
 
 namespace PepperDash.Essentials.Devices.Common.Cameras
 {
-    /// <summary>
-    /// Enum for camera control modes
-    /// </summary>
     public enum eCameraControlMode
-    {
-        /// <summary>
-        /// Manual control mode, where the camera is controlled directly by the user or system
-        /// </summary>
+    {       
         Manual = 0,
-        /// <summary>
-        /// Off control mode, where the camera is turned off or disabled
-        /// </summary>
         Off,
-        /// <summary>
-        ///  Auto control mode, where the camera automatically adjusts settings based on the environment or conditions
-        /// </summary>
         Auto
     }
 
 
-    /// <summary>
-    /// Interface for devices that have cameras
-    /// </summary>
-    public interface IHasCameras : IKeyName
+    public interface IHasCameras
     {
-        /// <summary>
-        /// Event that is raised when a camera is selected
-        /// </summary>
         event EventHandler<CameraSelectedEventArgs> CameraSelected;
 
-        /// <summary>
-        /// List of cameras on the device.  This should be a list of CameraBase objects
-        /// </summary>
         List<CameraBase> Cameras { get; }
 
-        /// <summary>
-        /// The currently selected camera.  This should be a CameraBase object
-        /// </summary>
         CameraBase SelectedCamera { get; }
 
-        /// <summary>
-        /// Feedback that indicates the currently selected camera
-        /// </summary>
         StringFeedback SelectedCameraFeedback { get; }
 
-        /// <summary>
-        /// 
-        /// </summary>
-        /// <param name="key"></param>
         void SelectCamera(string key);
     }
 
@@ -73,14 +42,7 @@ namespace PepperDash.Essentials.Devices.Common.Cameras
     /// </summary>
     public interface IHasCameraOff
     {
-        /// <summary>
-        /// Feedback that indicates whether the camera is off
-        /// </summary>
         BoolFeedback CameraIsOffFeedback { get; }
-
-        /// <summary>
-        /// Turns the camera off, blanking the near end video
-        /// </summary>
         void CameraOff();
     }
 
@@ -89,71 +51,31 @@ namespace PepperDash.Essentials.Devices.Common.Cameras
     /// </summary>
     public interface IHasCameraMute
     {
-        /// <summary>
-        /// Feedback that indicates whether the camera is muted
-        /// </summary>
         BoolFeedback CameraIsMutedFeedback { get; }
-
-        /// <summary>
-        /// Mutes the camera video, preventing it from being sent to the far end
-        /// </summary>
         void CameraMuteOn();
-
-        /// <summary>
-        /// Unmutes the camera video, allowing it to be sent to the far end
-        /// </summary>
         void CameraMuteOff();
-
-        /// <summary>
-        /// Toggles the camera mute state. If the camera is muted, it will be unmuted, and vice versa.
-        /// </summary>
         void CameraMuteToggle();
     }
 
-    /// <summary>
-    /// Interface for devices that can mute and unmute their camera video, with an event for unmute requests
-    /// </summary>
     public interface IHasCameraMuteWithUnmuteReqeust : IHasCameraMute
     {
-        /// <summary>
-        /// Event that is raised when a video unmute is requested, typically by the far end
-        /// </summary>
         event EventHandler VideoUnmuteRequested;
     }
 
-    /// <summary>
-    /// Event arguments for the CameraSelected event
-    /// </summary>
     public class CameraSelectedEventArgs : EventArgs
     {
-        /// <summary>
-        /// The selected camera
-        /// </summary>
         public CameraBase SelectedCamera { get; private set; }
 
-        /// <summary>
-        /// Constructor for CameraSelectedEventArgs
-        /// </summary>
-        /// <param name="camera"></param>
         public CameraSelectedEventArgs(CameraBase camera)
         {
             SelectedCamera = camera;
         }
     }
 
-    /// <summary>
-    /// Interface for devices that have a far end camera control
-    /// </summary>
     public interface IHasFarEndCameraControl
     {
-        /// <summary>
-        /// Gets the far end camera, which is typically a CameraBase object that represents the camera at the far end of a call
-        /// </summary>
         CameraBase FarEndCamera { get; }
 
-        /// <summary>
-        /// Feedback that indicates whether the far end camera is being controlled
-        /// </summary>
         BoolFeedback ControllingFarEndCameraFeedback { get; }
 
     }
@@ -166,9 +88,6 @@ namespace PepperDash.Essentials.Devices.Common.Cameras
 
     }
 
-    /// <summary>
-    /// Interface for devices that have camera controls
-    /// </summary>
     public interface IHasCameraControls
     {
     }
@@ -189,19 +108,8 @@ namespace PepperDash.Essentials.Devices.Common.Cameras
     /// </summary>
     public interface IHasCameraPanControl : IHasCameraControls
     {
-        /// <summary>
-        /// Pans the camera left
-        /// </summary>
         void PanLeft();
-
-        /// <summary>
-        /// Pans the camera right
-        /// </summary>
         void PanRight();
-
-        /// <summary>
-        /// Stops the camera pan movement
-        /// </summary>
         void PanStop();
     }
 
@@ -210,19 +118,8 @@ namespace PepperDash.Essentials.Devices.Common.Cameras
     /// </summary>
     public interface IHasCameraTiltControl : IHasCameraControls
     {
-        /// <summary>
-        /// Tilts the camera down
-        /// </summary>
         void TiltDown();
-
-        /// <summary>
-        /// Tilts the camera up
-        /// </summary>
         void TiltUp();
-
-        /// <summary>
-        /// Stops the camera tilt movement
-        /// </summary>
         void TiltStop();
     }
 
@@ -231,19 +128,8 @@ namespace PepperDash.Essentials.Devices.Common.Cameras
     /// </summary>
     public interface IHasCameraZoomControl : IHasCameraControls
     {
-        /// <summary>
-        /// Zooms the camera in
-        /// </summary>
         void ZoomIn();
-
-        /// <summary>
-        /// Zooms the camera out
-        /// </summary>
         void ZoomOut();
-
-        /// <summary>
-        /// Stops the camera zoom movement
-        /// </summary>
         void ZoomStop();
     }
 
@@ -252,71 +138,25 @@ namespace PepperDash.Essentials.Devices.Common.Cameras
     /// </summary>
     public interface IHasCameraFocusControl : IHasCameraControls
     {
-        /// <summary>
-        /// Focuses the camera near
-        /// </summary>
         void FocusNear();
-
-        /// <summary>
-        /// Focuses the camera far
-        /// </summary>
         void FocusFar();
-
-        /// <summary>
-        /// Stops the camera focus movement
-        /// </summary>
         void FocusStop();
 
-        /// <summary>
-        /// Triggers the camera's auto focus functionality, if available.
-        /// </summary>
         void TriggerAutoFocus();
     }
 
-    /// <summary>
-    /// Interface for devices that have auto focus mode control
-    /// </summary>
     public interface IHasAutoFocusMode
     {
-        /// <summary>
-        /// Sets the focus mode to auto or manual, or toggles between them.
-        /// </summary>
         void SetFocusModeAuto();
-
-        /// <summary>
-        /// Sets the focus mode to manual, allowing for manual focus adjustments.
-        /// </summary>
         void SetFocusModeManual();
-
-        /// <summary>
-        /// Toggles the focus mode between auto and manual.
-        /// </summary>
         void ToggleFocusMode();
     }
 
-    /// <summary>
-    /// Interface for devices that have camera auto mode control
-    /// </summary>
     public interface IHasCameraAutoMode : IHasCameraControls
     {
-        /// <summary>
-        /// Enables or disables the camera's auto mode, which may include automatic adjustments for focus, exposure, and other settings.
-        /// </summary>
         void CameraAutoModeOn();
-
-        /// <summary>
-        /// Disables the camera's auto mode, allowing for manual control of camera settings.
-        /// </summary>
         void CameraAutoModeOff();
-
-        /// <summary>
-        /// Toggles the camera's auto mode state. If the camera is in auto mode, it will switch to manual mode, and vice versa.
-        /// </summary>
         void CameraAutoModeToggle();
-
-        /// <summary>
-        /// Feedback that indicates whether the camera's auto mode is currently enabled.
-        /// </summary>
         BoolFeedback CameraAutoModeIsOnFeedback { get; }
     }
 

src/PepperDash.Essentials.MobileControl.Messengers/Messengers/CameraBaseMessenger.cs

@@ -6,14 +6,11 @@ using System.Collections.Generic;
 
 namespace PepperDash.Essentials.AppServer.Messengers
 {
-    /// <summary>
-    /// Messenger for a CameraBase device
-    /// </summary>
     public class CameraBaseMessenger : MessengerBase
     {
         /// <summary>
         /// Device being bridged
-        /// </summary>  
+        /// </summary>
         public CameraBase Camera { get; set; }
 
         /// <summary>
@@ -48,9 +45,6 @@ namespace PepperDash.Essentials.AppServer.Messengers
             );
         }
 
-        /// <summary>
-        /// Registers the actions for this messenger.  This is called by the base class
-        /// </summary>
         protected override void RegisterActions()
         {
             base.RegisterActions();

src/PepperDash.Essentials.MobileControl.Messengers/Messengers/DeviceInfoMessenger.cs

@@ -2,27 +2,69 @@
 using Newtonsoft.Json.Linq;
 using PepperDash.Core;
 using PepperDash.Essentials.Core.DeviceInfo;
+using System.Timers;
 
 namespace PepperDash.Essentials.AppServer.Messengers
 {
+    /// <summary>
+    /// Facilitates communication of device information by providing mechanisms for status updates and  device
+    /// information reporting.
+    /// </summary>
+    /// <remarks>The <see cref="DeviceInfoMessenger"/> class integrates with an <see
+    /// cref="IDeviceInfoProvider"/> to  manage device-specific information. It uses a debounce timer to limit the
+    /// frequency of updates,  ensuring efficient communication. The timer is initialized with a 1-second interval and
+    /// is disabled  by default. This class also subscribes to device information change events and provides actions for
+    /// reporting full device status and triggering updates.</remarks>
     public class DeviceInfoMessenger : MessengerBase
     {
         private readonly IDeviceInfoProvider _deviceInfoProvider;
+
+        private readonly Timer debounceTimer;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="DeviceInfoMessenger"/> class, which facilitates communication
+        /// of device information.
+        /// </summary>
+        /// <remarks>The messenger uses a debounce timer to limit the frequency of certain operations. The
+        /// timer is initialized with a 1-second interval and is disabled by default.</remarks>
+        /// <param name="key">A unique identifier for the messenger instance.</param>
+        /// <param name="messagePath">The path used for sending and receiving messages.</param>
+        /// <param name="device">An implementation of <see cref="IDeviceInfoProvider"/> that provides device-specific information.</param>
         public DeviceInfoMessenger(string key, string messagePath, IDeviceInfoProvider device) : base(key, messagePath, device as Device)
         {
             _deviceInfoProvider = device;
-        }
 
+            debounceTimer = new Timer(1000)
+            {
+                Enabled = false,
+                AutoReset = false
+            };
+
+            debounceTimer.Elapsed += DebounceTimer_Elapsed;
+        }
+
+        private void DebounceTimer_Elapsed(object sender, ElapsedEventArgs e)
+        {
+            PostStatusMessage(JToken.FromObject(new
+            {
+                deviceInfo = _deviceInfoProvider.DeviceInfo
+            }));
+        }
+
+        /// <summary>
+        /// Registers actions and event handlers for device information updates and status reporting.
+        /// </summary>
+        /// <remarks>This method sets up actions for handling device status updates and reporting full
+        /// device status. It also subscribes to the <see cref="IDeviceInfoProvider.DeviceInfoChanged"/> event to
+        /// trigger debounced updates when the device information changes.</remarks>
         protected override void RegisterActions()
         {
             base.RegisterActions();
 
             _deviceInfoProvider.DeviceInfoChanged += (o, a) =>
             {
-                PostStatusMessage(JToken.FromObject(new
-                {
-                    deviceInfo = a.DeviceInfo
-                }));
+                debounceTimer.Stop();
+                debounceTimer.Start();
             };
 
             AddAction("/fullStatus", (id, context) => PostStatusMessage(new DeviceInfoStateMessage
@@ -34,6 +76,12 @@ namespace PepperDash.Essentials.AppServer.Messengers
         }
     }
 
+    /// <summary>
+    /// Represents a message containing the state information of a device, including detailed device information.
+    /// </summary>
+    /// <remarks>This class is used to encapsulate the state of a device along with its associated
+    /// information. It extends <see cref="DeviceStateMessageBase"/> to provide additional details about the
+    /// device.</remarks>
     public class DeviceInfoStateMessage : DeviceStateMessageBase
     {
         [JsonProperty("deviceInfo")]

src/PepperDash.Essentials.MobileControl.Messengers/Messengers/IEssentialsRoomCombinerMessenger.cs

@@ -8,16 +8,42 @@ using System.Collections.Generic;
 
 namespace PepperDash.Essentials.AppServer.Messengers
 {
+    /// <summary>
+    /// Provides messaging functionality for managing room combination scenarios and partition states in an  <see
+    /// cref="IEssentialsRoomCombiner"/> instance. Enables external systems to interact with the room combiner  via
+    /// predefined actions and status updates.
+    /// </summary>
+    /// <remarks>This class facilitates communication with an <see cref="IEssentialsRoomCombiner"/> by
+    /// exposing actions  for toggling modes, managing partitions, and setting room combination scenarios. It also
+    /// listens for  feedback changes and broadcasts status updates to connected systems.   Typical usage involves
+    /// registering actions for external commands and handling feedback events to  synchronize state changes.</remarks>
     public class IEssentialsRoomCombinerMessenger : MessengerBase
     {
         private readonly IEssentialsRoomCombiner _roomCombiner;
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="IEssentialsRoomCombinerMessenger"/> class,  which facilitates
+        /// messaging for an <see cref="IEssentialsRoomCombiner"/> instance.
+        /// </summary>
+        /// <remarks>This class is designed to enable communication and interaction with an <see
+        /// cref="IEssentialsRoomCombiner"/>  through the specified messaging path. Ensure that the <paramref
+        /// name="roomCombiner"/> parameter is not null  when creating an instance.</remarks>
+        /// <param name="key">The unique key identifying this messenger instance.</param>
+        /// <param name="messagePath">The path used for messaging operations.</param>
+        /// <param name="roomCombiner">The <see cref="IEssentialsRoomCombiner"/> instance associated with this messenger.</param>
         public IEssentialsRoomCombinerMessenger(string key, string messagePath, IEssentialsRoomCombiner roomCombiner)
             : base(key, messagePath, roomCombiner as IKeyName)
         {
             _roomCombiner = roomCombiner;
         }
 
+        /// <summary>
+        /// Registers actions and event handlers for managing room combination scenarios and partition states.
+        /// </summary>
+        /// <remarks>This method sets up various actions that can be triggered via specific endpoints,
+        /// such as toggling modes,  setting room combination scenarios, and managing partition states. It also
+        /// subscribes to feedback events  to update the status when changes occur in room combination scenarios or
+        /// partition states.</remarks>
         protected override void RegisterActions()
         {
             AddAction("/fullStatus", (id, content) => SendFullStatus());
@@ -107,6 +133,7 @@ namespace PepperDash.Essentials.AppServer.Messengers
 
                 var message = new IEssentialsRoomCombinerStateMessage
                 {
+                    DisableAutoMode = _roomCombiner.DisableAutoMode,
                     IsInAutoMode = _roomCombiner.IsInAutoMode,
                     CurrentScenario = _roomCombiner.CurrentScenario,
                     Rooms = rooms,
@@ -132,20 +159,48 @@ namespace PepperDash.Essentials.AppServer.Messengers
         }
     }
 
+    /// <summary>
+    /// Represents the state message for a room combiner system, providing information about the current configuration, 
+    /// operational mode, and associated rooms, partitions, and scenarios.
+    /// </summary>
+    /// <remarks>This class is used to encapsulate the state of a room combiner system, including its current
+    /// mode of operation,  active room combination scenario, and the list of rooms and partitions involved. It is
+    /// typically serialized  and transmitted to communicate the state of the system.</remarks>
     public class IEssentialsRoomCombinerStateMessage : DeviceStateMessageBase
     {
+        /// <summary>
+        /// Gets or sets a value indicating whether automatic mode is disabled.
+        /// </summary>
+        [JsonProperty("disableAutoMode", NullValueHandling = NullValueHandling.Ignore)]
+        public bool DisableAutoMode { get; set; }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether the system is operating in automatic mode.
+        /// </summary>
         [JsonProperty("isInAutoMode", NullValueHandling = NullValueHandling.Ignore)]
         public bool IsInAutoMode { get; set; }
 
+        /// <summary>
+        /// Gets or sets the current room combination scenario.
+        /// </summary>
         [JsonProperty("currentScenario", NullValueHandling = NullValueHandling.Ignore)]
         public IRoomCombinationScenario CurrentScenario { get; set; }
 
+        /// <summary>
+        /// Gets or sets the collection of rooms associated with the entity.
+        /// </summary>
         [JsonProperty("rooms", NullValueHandling = NullValueHandling.Ignore)]
         public List<IKeyName> Rooms { get; set; }
 
+        /// <summary>
+        /// Gets or sets the collection of room combination scenarios.
+        /// </summary>
         [JsonProperty("roomCombinationScenarios", NullValueHandling = NullValueHandling.Ignore)]
         public List<IRoomCombinationScenario> RoomCombinationScenarios { get; set; }
 
+        /// <summary>
+        /// Gets or sets the collection of partition controllers.
+        /// </summary>
         [JsonProperty("partitions", NullValueHandling = NullValueHandling.Ignore)]
         public List<IPartitionController> Partitions { get; set; }
     }

src/PepperDash.Essentials.MobileControl.Messengers/Messengers/IHasCamerasMessenger.cs

@@ -1,104 +0,0 @@
-using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
-using PepperDash.Essentials.Devices.Common.Cameras;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace PepperDash.Essentials.AppServer.Messengers
-{
-    /// <summary>
-    /// Messenger for devices that implement the IHasCameras interface.
-    /// </summary>
-    public class IHasCamerasMessenger : MessengerBase
-    {
-        /// <summary>
-        /// Device being bridged that implements IHasCameras interface.
-        /// </summary>
-        public IHasCameras CameraController { get; private set; }
-
-        /// <summary>
-        /// Messenger for devices that implement IHasCameras interface.
-        /// </summary>
-        /// <param name="key"></param>
-        /// <param name="cameraController"></param>
-        /// <param name="messagePath"></param>
-        /// <exception cref="ArgumentNullException"></exception>
-        public IHasCamerasMessenger(string key, IHasCameras cameraController, string messagePath)
-            : base(key, messagePath, cameraController)
-        {
-            CameraController = cameraController ?? throw new ArgumentNullException("cameraController");
-            CameraController.CameraSelected += CameraController_CameraSelected;
-        }
-
-        private void CameraController_CameraSelected(object sender, CameraSelectedEventArgs e)
-        {
-            PostStatusMessage(new IHasCamerasStateMessage
-            {
-                SelectedCamera = e.SelectedCamera
-            });
-        }
-
-        /// <summary>
-        /// Registers the actions for this messenger.
-        /// </summary>
-        /// <exception cref="ArgumentException"></exception>
-        protected override void RegisterActions()
-        {
-            base.RegisterActions();
-
-            AddAction("/fullStatus", (id, context) =>
-            {
-                SendFullStatus();
-            });
-
-            AddAction("/selectCamera", (id, content) =>
-            {
-                var cameraKey = content?.ToObject<string>();
-
-                if (!string.IsNullOrEmpty(cameraKey))
-                {
-                    CameraController.SelectCamera(cameraKey);
-                }
-                else
-                {
-                    throw new ArgumentException("Content must be a string representing the camera key");
-                }
-            });
-        }
-
-        private void SendFullStatus()
-        {
-            var state = new IHasCamerasStateMessage
-            {
-                CameraList = CameraController.Cameras,
-                SelectedCamera = CameraController.SelectedCamera
-            };
-
-            PostStatusMessage(state);
-        }
-
-
-    }
-
-    /// <summary>
-    /// State message for devices that implement the IHasCameras interface.
-    /// </summary>
-    public class IHasCamerasStateMessage : DeviceStateMessageBase
-    {
-        /// <summary>
-        /// List of cameras available in the device.
-        /// </summary>
-        [JsonProperty("cameraList", NullValueHandling = NullValueHandling.Ignore)]
-        public List<CameraBase> CameraList { get; set; }
-
-        /// <summary>
-        /// The currently selected camera on the device.
-        /// </summary>
-        [JsonProperty("selectedCamera", NullValueHandling = NullValueHandling.Ignore)]
-        public CameraBase SelectedCamera { get; set; }
-
-    }
-}