com.beamable 5.0.1 → 5.1.0-PREVIEW.RC1

package/Common/Runtime/SmallerJSON/SmallerJSON.FromString.cs

@@ -1,5 +1,5 @@
-// this file was copied from nuget package Beamable.Common@7.0.1
-// https://www.nuget.org/packages/Beamable.Common/7.0.1
+// this file was copied from nuget package Beamable.Common@7.2.0-PREVIEW.RC1
+// https://www.nuget.org/packages/Beamable.Common/7.2.0-PREVIEW.RC1
 
 /*
  * Simplified fork of MiniJSON optimized to minimize heap allocations

package/Common/Runtime/SmallerJSON/SmallerJSON.cs

@@ -1,5 +1,5 @@
-// this file was copied from nuget package Beamable.Common@7.0.1
-// https://www.nuget.org/packages/Beamable.Common/7.0.1
+// this file was copied from nuget package Beamable.Common@7.2.0-PREVIEW.RC1
+// https://www.nuget.org/packages/Beamable.Common/7.2.0-PREVIEW.RC1
 
 /*
  * Simplified fork of MiniJSON optimized to minimize heap allocations
@@ -80,6 +80,35 @@ namespace Beamable.Serialization.SmallerJSON
 				return obj;
 			}
 		}
+		
+		/// <summary>
+		/// Deserialize JSON into a concrete type. Unlike Unity JsonUtility, this supports
+		/// custom semantic wrapper types (ex: types implementing IBeamSemanticType<T>)
+		/// even when JSON contains only the primitive token (string/number).
+		/// </summary>
+		public static T Deserialize<T>(string json)
+		{
+			return (T)Deserialize(json, typeof(T));
+		}
+
+		/// <summary>
+		/// Deserialize JSON into a concrete type (runtime type overload).
+		/// </summary>
+		public static object Deserialize(string json, Type targetType)
+		{
+			if (json == null) return null;
+
+			// First parse into SmallerJSON's object model (ArrayDict/List/primitives).
+			object root;
+			using (var parser = new StringBasedParser(json))
+			{
+				root = parser.ParseValue();
+			}
+
+			// Then materialize into the requested type.
+			return ObjectMapper.ConvertToType(root, targetType);
+		}
+		
 
 		public static bool IsValidJson(string strInput)
 		{
@@ -1052,5 +1081,200 @@ namespace Beamable.Serialization.SmallerJSON
 				}
 			}
 		}
+		
+		private static class ObjectMapper
+		{
+			private static readonly Type SerializeFieldType = typeof(SerializeField);
+
+			// NOTE: We cannot reference Beamable.Common.Semantics directly from this folder.
+			// We detect semantic types via reflection by interface full name instead
+			private const string BeamSemanticInterfaceFullName = "Beamable.Common.Semantics.IBeamSemanticType`1";
+
+			public static object ConvertToType(object node, Type targetType)
+			{
+				if (targetType == null) throw new ArgumentNullException(nameof(targetType));
+
+				// Null handling
+				if (node == null)
+				{
+					targetType = Nullable.GetUnderlyingType(targetType) ?? targetType;
+					return targetType.IsValueType ? Activator.CreateInstance(targetType) : null;
+				}
+
+				// Unwrap nullable
+				targetType = Nullable.GetUnderlyingType(targetType) ?? targetType;
+
+				// Semantic types: construct from primitive JSON tokens
+				if (TryGetSemanticPrimitiveType(targetType, out var primitiveType))
+				{
+					return ConstructSemantic(targetType, primitiveType, node);
+				}
+
+				// Direct assign
+				if (targetType.IsInstanceOfType(node))
+				{
+					return node;
+				}
+
+				// Enums
+				if (targetType.IsEnum)
+				{
+					if (node is string s) return Enum.Parse(targetType, s, ignoreCase: true);
+					if (node is long l) return Enum.ToObject(targetType, (int)l);
+				}
+
+				// Common scalars
+				if (targetType == typeof(string)) return node.ToString();
+				if (targetType == typeof(bool)) return Convert.ToBoolean(node);
+				if (targetType == typeof(long)) return Convert.ToInt64(node);
+				if (targetType == typeof(int)) return Convert.ToInt32(node);
+				if (targetType == typeof(double)) return Convert.ToDouble(node);
+				if (targetType == typeof(float)) return Convert.ToSingle(node);
+				if (targetType == typeof(decimal)) return Convert.ToDecimal(node);
+
+				// Dictionaries (only generic Dictionary<string, TValue> supported here)
+				if (typeof(IDictionary).IsAssignableFrom(targetType) && targetType.IsGenericType)
+				{
+					var genArgs = targetType.GetGenericArguments();
+					if (genArgs.Length == 2 && genArgs[0] == typeof(string) && node is ArrayDict dictNode)
+					{
+						var valueType = genArgs[1];
+						var dict = (IDictionary)Activator.CreateInstance(targetType);
+						foreach (var kvp in dictNode)
+						{
+							dict[kvp.Key] = ConvertToType(kvp.Value, valueType);
+						}
+						return dict;
+					}
+				}
+
+				// Arrays
+				if (targetType.IsArray && node is IList listNodeForArray)
+				{
+					var elemType = targetType.GetElementType();
+					var arr = Array.CreateInstance(elemType!, listNodeForArray.Count);
+					for (int i = 0; i < listNodeForArray.Count; i++)
+					{
+						arr.SetValue(ConvertToType(listNodeForArray[i], elemType!), i);
+					}
+					return arr;
+				}
+
+				// Lists
+				if (typeof(IList).IsAssignableFrom(targetType) && node is IList listNode)
+				{
+					var elemType = targetType.IsGenericType ? targetType.GetGenericArguments()[0] : typeof(object);
+					var list = (IList)Activator.CreateInstance(targetType);
+					foreach (var elem in listNode)
+					{
+						list.Add(ConvertToType(elem, elemType));
+					}
+					return list;
+				}
+
+				// POCO object
+				if (node is ArrayDict objNode)
+				{
+					var instance = Activator.CreateInstance(targetType);
+
+					// Mirror existing Serializer rules: fields only, allow [SerializeField] privates,
+					// skip [NonSerialized] fields.
+					var fields = targetType.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
+					for (int i = 0; i < fields.Length; i++)
+					{
+						var field = fields[i];
+
+						var hasSerializeField = field.GetCustomAttribute(SerializeFieldType) != null;
+						var canBeSerialized = (hasSerializeField || !field.IsNotSerialized);
+						if (!canBeSerialized) continue;
+
+						if (!objNode.TryGetValue(field.Name, out var rawValue)) continue;
+
+						var converted = ConvertToType(rawValue, field.FieldType);
+						field.SetValue(instance, converted);
+					}
+
+					// If the target uses Unity callbacks, respect them (parity with existing Serializer behavior)
+					if (instance is ISerializationCallbackReceiver receiver)
+					{
+						receiver.OnAfterDeserialize();
+					}
+
+					return instance;
+				}
+
+				throw new InvalidOperationException(
+					$"SmallerJSON cannot convert node type [{node.GetType().FullName}] to [{targetType.FullName}].");
+			}
+
+			private static bool TryGetSemanticPrimitiveType(Type semanticType, out Type primitiveType)
+			{
+				var iface = semanticType.GetInterfaces()
+					.FirstOrDefault(i => i.IsGenericType && i.GetGenericTypeDefinition().FullName == BeamSemanticInterfaceFullName);
+
+				if (iface == null)
+				{
+					primitiveType = null;
+					return false;
+				}
+
+				primitiveType = iface.GetGenericArguments()[0];
+				return true;
+			}
+
+			private static object ConstructSemantic(Type semanticType, Type primitiveType, object node)
+			{
+				// Prefer ctor(string) when JSON is a string. Many long-backed semantic types accept string too
+				// and preserve formatting (leading zeros etc) or validate (ServiceName).
+				if (node is string s)
+				{
+					var stringCtor = semanticType.GetConstructor(new[] { typeof(string) });
+					if (stringCtor != null) return stringCtor.Invoke(new object[] { s });
+
+					if (primitiveType == typeof(long))
+					{
+						if (!long.TryParse(s, System.Globalization.NumberStyles.Integer,
+								System.Globalization.CultureInfo.InvariantCulture, out var parsed))
+						{
+							throw new FormatException($"Cannot parse '{s}' as long for semantic type [{semanticType.FullName}].");
+						}
+
+						var longCtor = semanticType.GetConstructor(new[] { typeof(long) });
+						if (longCtor != null) return longCtor.Invoke(new object[] { parsed });
+					}
+
+					throw new MissingMethodException(
+						$"Semantic type [{semanticType.FullName}] has no public ctor(string) and cannot be built from JSON string.");
+				}
+
+				// If JSON is numeric and semantic primitive is long
+				if (primitiveType == typeof(long))
+				{
+					var l = Convert.ToInt64(node, System.Globalization.CultureInfo.InvariantCulture);
+					var longCtor = semanticType.GetConstructor(new[] { typeof(long) });
+					if (longCtor != null) return longCtor.Invoke(new object[] { l });
+
+					// Some semantic types might only expose ctor(string); allow numeric -> string as fallback.
+					var stringCtor = semanticType.GetConstructor(new[] { typeof(string) });
+					if (stringCtor != null) return stringCtor.Invoke(new object[] { l.ToString(System.Globalization.CultureInfo.InvariantCulture) });
+
+					throw new MissingMethodException($"Semantic type [{semanticType.FullName}] must have ctor(long) or ctor(string).");
+				}
+
+				// If semantic primitive is string, coerce to string
+				if (primitiveType == typeof(string))
+				{
+					var stringCtor = semanticType.GetConstructor(new[] { typeof(string) });
+					if (stringCtor == null)
+						throw new MissingMethodException($"Semantic type [{semanticType.FullName}] must have ctor(string).");
+
+					return stringCtor.Invoke(new object[] { node.ToString() });
+				}
+
+				throw new NotSupportedException(
+					$"Semantic type [{semanticType.FullName}] uses unsupported primitive [{primitiveType.FullName}].");
+			}
+		}
+		
 	}
 }

package/Common/Runtime/Spew/Logger.cs

@@ -1,5 +1,5 @@
-// this file was copied from nuget package Beamable.Common@7.0.1
-// https://www.nuget.org/packages/Beamable.Common/7.0.1
+// this file was copied from nuget package Beamable.Common@7.2.0-PREVIEW.RC1
+// https://www.nuget.org/packages/Beamable.Common/7.2.0-PREVIEW.RC1
 
 //#define PREPEND_SPEW_METADATA
 // With PREPEND_SPEW_METADATA defined, all spew logs will have frame # and time prepended.

package/Common/Runtime/Spew/SpewLoggerAttribute.cs

@@ -1,5 +1,5 @@
-// this file was copied from nuget package Beamable.Common@7.0.1
-// https://www.nuget.org/packages/Beamable.Common/7.0.1
+// this file was copied from nuget package Beamable.Common@7.2.0-PREVIEW.RC1
+// https://www.nuget.org/packages/Beamable.Common/7.2.0-PREVIEW.RC1
 
 using System;
 using System.Diagnostics;

package/Common/Runtime/Trie.cs

@@ -1,5 +1,5 @@
-// this file was copied from nuget package Beamable.Common@7.0.1
-// https://www.nuget.org/packages/Beamable.Common/7.0.1
+// this file was copied from nuget package Beamable.Common@7.2.0-PREVIEW.RC1
+// https://www.nuget.org/packages/Beamable.Common/7.2.0-PREVIEW.RC1
 
 using System;
 using System.Collections.Generic;

package/Common/Runtime/TypeExtensions.cs

@@ -1,5 +1,5 @@
-// this file was copied from nuget package Beamable.Common@7.0.1
-// https://www.nuget.org/packages/Beamable.Common/7.0.1
+// this file was copied from nuget package Beamable.Common@7.2.0-PREVIEW.RC1
+// https://www.nuget.org/packages/Beamable.Common/7.2.0-PREVIEW.RC1
 
 
 using System;

package/Common/Runtime/Util/BeamAssemblyVersionUtil.cs

@@ -1,5 +1,5 @@
-// this file was copied from nuget package Beamable.Common@7.0.1
-// https://www.nuget.org/packages/Beamable.Common/7.0.1
+// this file was copied from nuget package Beamable.Common@7.2.0-PREVIEW.RC1
+// https://www.nuget.org/packages/Beamable.Common/7.2.0-PREVIEW.RC1
 
 using Beamable.Common.Spew;
 using System;

package/Common/Runtime/Util/BeamFileUtil.cs

@@ -1,5 +1,5 @@
-// this file was copied from nuget package Beamable.Common@7.0.1
-// https://www.nuget.org/packages/Beamable.Common/7.0.1
+// this file was copied from nuget package Beamable.Common@7.2.0-PREVIEW.RC1
+// https://www.nuget.org/packages/Beamable.Common/7.2.0-PREVIEW.RC1
 
 using System;
 using System.IO;

package/Common/Runtime/Util/DocsPageHelper.cs

@@ -1,5 +1,5 @@
-// this file was copied from nuget package Beamable.Common@7.0.1
-// https://www.nuget.org/packages/Beamable.Common/7.0.1
+// this file was copied from nuget package Beamable.Common@7.2.0-PREVIEW.RC1
+// https://www.nuget.org/packages/Beamable.Common/7.2.0-PREVIEW.RC1
 
 namespace Beamable.Common.Util
 {

package/Common/Runtime/Util/NaturalStringComparer.cs

@@ -1,5 +1,5 @@
-// this file was copied from nuget package Beamable.Common@7.0.1
-// https://www.nuget.org/packages/Beamable.Common/7.0.1
+// this file was copied from nuget package Beamable.Common@7.2.0-PREVIEW.RC1
+// https://www.nuget.org/packages/Beamable.Common/7.2.0-PREVIEW.RC1
 
 using System.Collections.Generic;
 

package/Editor/BeamCli/BeamCommand.cs

@@ -444,9 +444,6 @@ namespace Beamable.Editor.BeamCli
 						{
 							CliLogger.Log("stdout", args.Data, System.Environment.NewLine + System.Environment.NewLine,
 							              _command);
-						});
-						_dispatcher.Schedule(() =>
-						{
 							try
 							{
 								ProcessStandardOut(args.Data);
@@ -469,9 +466,6 @@ namespace Beamable.Editor.BeamCli
 						{
 							CliLogger.Log("stderr", args.Data, System.Environment.NewLine + System.Environment.NewLine,
 							              _command);
-						});
-						_dispatcher.Schedule(() =>
-						{
 							try
 							{
 								ProcessStandardErr(args.Data);

package/Editor/BeamCli/BeamWebCommand.cs

@@ -135,6 +135,22 @@ namespace Beamable.Editor.BeamCli
 			_serverCommand = null;
 		}
 
+		public void InvalidateServer(Exception cause)
+		{
+			// Marshal back to the editor coroutine thread — port, _serverCommand,
+			// and discoveryRequest are all touched by ServerDiscoveryLoop and
+			// shouldn't race with an async continuation.
+			dispatcher.Schedule(() =>
+			{
+				_history.AddServerEvent(
+					$"Server invalidated: {cause.GetType().Name}: {cause.Message}");
+
+				KillServer();
+				port = _options.startPortOverride.GetOrElse(8432);
+				discoveryRequest++;
+			});
+		}
+
 		public string GetServerProcess()
 		{
 			
@@ -399,8 +415,8 @@ namespace Beamable.Editor.BeamCli
 			{
 				if (!_cts.IsCancellationRequested)
 				{
-					var client = new HttpClient() {Timeout = TimeSpan.FromDays(7),};
-					var sendTask = client.SendAsync(req, HttpCompletionOption.ResponseHeadersRead);
+					using var client = new HttpClient() {Timeout = TimeSpan.FromDays(7),};
+					var sendTask = client.SendAsync(req, HttpCompletionOption.ResponseHeadersRead, _cts.Token);
 					_history.AddCustomLog(id, "[Unity] sent request...");
 
 					using HttpResponseMessage response = await sendTask;
@@ -420,13 +436,10 @@ namespace Beamable.Editor.BeamCli
 						}
 
 						readTask = reader.ReadLineAsync();
-						while (!readTask.IsCompleted)
+						var cancelTcs = new TaskCompletionSource<bool>();
+						using (_cts.Token.Register(() => cancelTcs.TrySetResult(true)))
 						{
-							await Task.WhenAny(readTask, Task.Delay(50));
-							if (_cts.Token.IsCancellationRequested)
-							{
-								break;
-							}
+							await Task.WhenAny(readTask, cancelTcs.Task);
 						}
 						if (_cts.Token.IsCancellationRequested)
 						{
@@ -464,6 +477,15 @@ namespace Beamable.Editor.BeamCli
 				}
 
 			}
+			catch (Exception ex) when (IsTransportFailure(ex) && !_cts.IsCancellationRequested)
+			{
+				// The loopback connection to the CLI server is unhealthy
+				// (server died, port stale, half-closed socket). Tear down
+				// the cached server state so the next attempt rediscovers
+				// before we keep hammering a dead endpoint.
+				_factory.InvalidateServer(ex);
+				throw;
+			}
 			finally
 			{
 				_history.AddCustomLog(id, "[Unity] ending...");
@@ -484,6 +506,14 @@ namespace Beamable.Editor.BeamCli
 			_cts.Cancel();
 		}
 
+		private static bool IsTransportFailure(Exception ex)
+		{
+			return ex is HttpRequestException
+			       || ex is SocketException
+			       || ex is ObjectDisposedException
+			       || ex is IOException;
+		}
+
 		public IBeamCommand On<T>(Func<ReportDataPointDescription, bool> predicate, Action<ReportDataPoint<T>> cb)
 		{
 			On(desc =>

package/Editor/BeamCli/Commands/Beam.cs

@@ -22,6 +22,8 @@ namespace Beamable.Editor.BeamCli.Commands
         public bool quiet;
         /// <summary>This option defines the target Beamable environment. Needed for private cloud customers to target their exclusive Beamable environment. Ignorable by everyone else. Stored in '.beamable/config.beam.json'</summary>
         public string host;
+        /// <summary>Overrides the default portal url.</summary>
+        public string portalUrl;
         /// <summary>The access token to use for the requests. It overwrites the logged in user stored in auth.beam.json for THIS INVOCATION ONLY</summary>
         public string accessToken;
         /// <summary>A Refresh Token to use for the requests. It overwrites the logged in user stored in auth.beam.json for THIS INVOCATION ONLY</summary>
@@ -104,6 +106,11 @@ namespace Beamable.Editor.BeamCli.Commands
             {
                 genBeamCommandArgs.Add(("--host=" + this.host));
             }
+            // If the portalUrl value was not default, then add it to the list of args.
+            if ((this.portalUrl != default(string)))
+            {
+                genBeamCommandArgs.Add(("--portal-url=" + this.portalUrl));
+            }
             // If the accessToken value was not default, then add it to the list of args.
             if ((this.accessToken != default(string)))
             {

package/Editor/BeamCli/Commands/BeamBeamableTypesSchema.cs

@@ -0,0 +1,17 @@
+
+namespace Beamable.Editor.BeamCli.Commands
+{
+    using Beamable.Common;
+    using Beamable.Common.BeamCli;
+    
+    [System.SerializableAttribute()]
+    public partial class BeamBeamableTypesSchema
+    {
+        public string GeneratedAt;
+        public string AssemblyVersion;
+        public BeamContentTypeEntry[] ContentTypes;
+        public BeamFederationTypeEntry[] FederationTypes;
+        public BeamUtilityTypeEntry[] UtilityTypes;
+        public BeamUnrealTypeMappingEntry[] UnrealTypeMappings;
+    }
+}

package/Editor/BeamCli/Commands/BeamBeamableTypesSchema.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 985e9b6b78b6fdfe12724a8e7025ac81
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Editor/BeamCli/Commands/BeamComponentExtensionOption.cs

@@ -0,0 +1,13 @@
+
+namespace Beamable.Editor.BeamCli.Commands
+{
+    using Beamable.Common;
+    using Beamable.Common.BeamCli;
+    
+    [System.SerializableAttribute()]
+    public partial class BeamComponentExtensionOption
+    {
+        public string path;
+        public System.Collections.Generic.List<BeamComponentSelectorOption> selectors;
+    }
+}

package/Editor/BeamCli/Commands/BeamComponentExtensionOption.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6427644af03340ce56b76eb2436eb85a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Editor/BeamCli/Commands/BeamComponentSelectorOption.cs

@@ -0,0 +1,13 @@
+
+namespace Beamable.Editor.BeamCli.Commands
+{
+    using Beamable.Common;
+    using Beamable.Common.BeamCli;
+    
+    [System.SerializableAttribute()]
+    public partial class BeamComponentSelectorOption
+    {
+        public string selector;
+        public string type;
+    }
+}

package/Editor/BeamCli/Commands/BeamComponentSelectorOption.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b8b4a7b3fb707e7979fcd33ced57a3c5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Editor/BeamCli/Commands/BeamContentFieldEntry.cs

@@ -0,0 +1,14 @@
+
+namespace Beamable.Editor.BeamCli.Commands
+{
+    using Beamable.Common;
+    using Beamable.Common.BeamCli;
+    
+    [System.SerializableAttribute()]
+    public partial class BeamContentFieldEntry
+    {
+        public string Name;
+        public string Type;
+        public string Summary;
+    }
+}

package/Editor/BeamCli/Commands/BeamContentFieldEntry.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4018aaefd60289f04c939b20657322a2
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Editor/BeamCli/Commands/BeamContentHistory.cs

@@ -0,0 +1,97 @@
+
+namespace Beamable.Editor.BeamCli.Commands
+{
+    using Beamable.Common;
+    using Beamable.Common.BeamCli;
+    
+    public partial class ContentHistoryArgs : Beamable.Common.BeamCli.IBeamCommandArgs
+    {
+        /// <summary>When true, the command will run forever and watch the state of the program</summary>
+        public bool watch;
+        /// <summary>Inform a subset of ','-separated manifest ids for which to return data. By default, will return just the global manifest</summary>
+        public string[] manifestIds;
+        /// <summary>Listens to the given process id. Terminates this long-running command when the it no longer is running</summary>
+        public int requireProcessId;
+        /// <summary>Filter entries from this Unix timestamp (milliseconds)</summary>
+        public System.Nullable<long> fromDate;
+        /// <summary>Filter entries to this Unix timestamp (milliseconds)</summary>
+        public System.Nullable<long> toDate;
+        /// <summary>Filter by specific manifest UIDs</summary>
+        public System.Collections.Generic.List<string> manifestUids;
+        /// <summary>Serializes the arguments for command line usage.</summary>
+        public virtual string Serialize()
+        {
+            // Create a list of arguments for the command
+            System.Collections.Generic.List<string> genBeamCommandArgs = new System.Collections.Generic.List<string>();
+            // If the watch value was not default, then add it to the list of args.
+            if ((this.watch != default(bool)))
+            {
+                genBeamCommandArgs.Add(("--watch=" + this.watch));
+            }
+            // If the manifestIds value was not default, then add it to the list of args.
+            if ((this.manifestIds != default(string[])))
+            {
+                for (int i = 0; (i < this.manifestIds.Length); i = (i + 1))
+                {
+                    // The parameter allows multiple values
+                    genBeamCommandArgs.Add(("--manifest-ids=" + this.manifestIds[i]));
+                }
+            }
+            // If the requireProcessId value was not default, then add it to the list of args.
+            if ((this.requireProcessId != default(int)))
+            {
+                genBeamCommandArgs.Add(("--require-process-id=" + this.requireProcessId));
+            }
+            // If the fromDate value was not default, then add it to the list of args.
+            if ((this.fromDate != default(System.Nullable<long>)))
+            {
+                genBeamCommandArgs.Add(("--from-date=" + this.fromDate));
+            }
+            // If the toDate value was not default, then add it to the list of args.
+            if ((this.toDate != default(System.Nullable<long>)))
+            {
+                genBeamCommandArgs.Add(("--to-date=" + this.toDate));
+            }
+            // If the manifestUids value was not default, then add it to the list of args.
+            if ((this.manifestUids != default(System.Collections.Generic.List<string>)))
+            {
+                genBeamCommandArgs.Add(("--manifest-uids=" + this.manifestUids));
+            }
+            string genBeamCommandStr = "";
+            // Join all the args with spaces
+            genBeamCommandStr = string.Join(" ", genBeamCommandArgs);
+            return genBeamCommandStr;
+        }
+    }
+    public partial class BeamCommands
+    {
+        public virtual ContentHistoryWrapper ContentHistory(ContentHistoryArgs historyArgs)
+        {
+            // Create a list of arguments for the command
+            System.Collections.Generic.List<string> genBeamCommandArgs = new System.Collections.Generic.List<string>();
+            genBeamCommandArgs.Add("beam");
+            genBeamCommandArgs.Add(defaultBeamArgs.Serialize());
+            genBeamCommandArgs.Add("content");
+            genBeamCommandArgs.Add("history");
+            genBeamCommandArgs.Add(historyArgs.Serialize());
+            // Create an instance of an IBeamCommand
+            Beamable.Common.BeamCli.IBeamCommand command = this._factory.Create();
+            // Join all the command paths and args into one string
+            string genBeamCommandStr = string.Join(" ", genBeamCommandArgs);
+            // Configure the command with the command string
+            command.SetCommand(genBeamCommandStr);
+            ContentHistoryWrapper genBeamCommandWrapper = new ContentHistoryWrapper();
+            genBeamCommandWrapper.Command = command;
+            // Return the command!
+            return genBeamCommandWrapper;
+        }
+    }
+    public partial class ContentHistoryWrapper : Beamable.Common.BeamCli.BeamCommandWrapper
+    {
+        public virtual ContentHistoryWrapper OnStreamContentHistoryCommandEvent(System.Action<ReportDataPoint<BeamContentHistoryCommandEvent>> cb)
+        {
+            this.Command.On("stream", cb);
+            return this;
+        }
+    }
+}