fix comments

Author: Nilay Vishwakarma

src/FsmNet/BaseStateMachine.cs

@@ -5,8 +5,8 @@
     /// <summary>
     /// Base class for state machines that defines the core functionality for transitioning between states.
     /// </summary>
-    /// <typeparam name="TState"></typeparam>
-    /// <typeparam name="TContext"></typeparam>
+    /// <typeparam name="TState">State Enum Type</typeparam>
+    /// <typeparam name="TContext">Context Type</typeparam>
     public abstract class BaseStateMachine<TState, TContext> : IStateMachine<TState, TContext> where TState : struct, Enum
     {
         /// <summary>
@@ -17,17 +17,17 @@ public abstract class BaseStateMachine<TState, TContext> : IStateMachine<TState,
         /// <summary>
         /// Checks if a transition to the specified target state is possible given the current context.
         /// </summary>
-        /// <param name="target"></param>
-        /// <param name="context"></param>
-        /// <returns></returns>
+        /// <param name="target">Target State</param>
+        /// <param name="context">Context</param>
+        /// <returns>If transition is possible to target state</returns>
         public abstract bool CanTransitionTo(TState target, TContext context);
 
         /// <summary>
         /// Attempts to transition to the specified target state given the current context.
         /// </summary>
-        /// <param name="target"></param>
-        /// <param name="context"></param>
-        /// <returns></returns>
+        /// <param name="target">Target State</param>
+        /// <param name="context">Context</param>
+        /// <returns>If transition is successful to target state</returns>
         public abstract bool TryTransitionTo(TState target, TContext context);
     }
 }

src/FsmNet/EnumState.cs

@@ -5,7 +5,7 @@
     /// <summary>
     /// Represents a state in a finite state machine defined by an enumeration.
     /// </summary>
-    /// <typeparam name="TEnum"></typeparam>
+    /// <typeparam name="TEnum">State Enum Type</typeparam>
     public class EnumState<TEnum> : IState where TEnum : struct, Enum
     {
         /// <summary>
@@ -21,13 +21,13 @@ public class EnumState<TEnum> : IState where TEnum : struct, Enum
         /// <summary>
         /// Initializes a new instance of the <see cref="EnumState{TEnum}"/> class with the specified enumeration value.
         /// </summary>
-        /// <param name="value"></param>
+        /// <param name="value">Enum state value</param>
         public EnumState(TEnum value) => Value = value;
 
         /// <summary>
         /// Returns a string representation of the state, which is its name.
         /// </summary>
-        /// <returns></returns>
+        /// <returns>String representation of state</returns>
         public override string ToString() => Name;
     }
 }

src/FsmNet/EnumStateMachineDefinition.cs

@@ -7,14 +7,14 @@
     /// <summary>
     /// Represents a state machine definition based on an enumeration type.
     /// </summary>
-    /// <typeparam name="TEnum"></typeparam>
-    /// <typeparam name="TContext"></typeparam>
+    /// <typeparam name="TEnum">State Enum Type</typeparam>
+    /// <typeparam name="TContext">Context Type</typeparam>
     public class EnumStateMachineDefinition<TEnum, TContext> : IStateMachineDefinition<TContext> where TEnum : struct, Enum
     {
         /// <summary>
         /// The type of work item this state machine is associated with.
         /// </summary>
-        public string WorkItemType { get; }
+        public string EntityType { get; }
 
         /// <summary>
         /// A collection of all states in the state machine, represented as <see cref="IState"/> instances.
@@ -34,13 +34,13 @@ public class EnumStateMachineDefinition<TEnum, TContext> : IStateMachineDefiniti
         /// <summary>
         /// Initialize a new instance of the <see cref="EnumStateMachineDefinition{TEnum, TContext}"/> class.
         /// </summary>
-        /// <param name="workItemType"></param>
+        /// <param name="entityType">Entity type name, example: Order, Bug, etc.</param>
         /// <param name="states"></param>
         /// <param name="transitions"></param>
         /// <param name="initialState"></param>
-        public EnumStateMachineDefinition(string workItemType, IEnumerable<TEnum> states, IEnumerable<ITransition<TContext>> transitions, TEnum initialState)
+        public EnumStateMachineDefinition(string entityType, IEnumerable<TEnum> states, IEnumerable<ITransition<TContext>> transitions, TEnum initialState)
         {
-            WorkItemType = workItemType;
+            EntityType = entityType;
             States = states.Select(s => new EnumState<TEnum>(s)).ToList();
             Transitions = transitions;
             InitialState = new EnumState<TEnum>(initialState);

src/FsmNet/EnumTransition.cs

@@ -5,8 +5,8 @@
     /// <summary>
     /// Represents a transition in a finite state machine defined by an enumeration.
     /// </summary>
-    /// <typeparam name="TEnum"></typeparam>
-    /// <typeparam name="TContext"></typeparam>
+    /// <typeparam name="TEnum">State Enum Type</typeparam>
+    /// <typeparam name="TContext">Context Type</typeparam>
     public class EnumTransition<TEnum, TContext> : ITransition<TContext> where TEnum : struct, Enum
     {
         /// <summary>

src/FsmNet/FiniteStateMachine.cs

@@ -6,8 +6,8 @@
     /// <summary>
     /// Represents a finite state machine based on an enumeration type.
     /// </summary>
-    /// <typeparam name="TState"></typeparam>
-    /// <typeparam name="TContext"></typeparam>
+    /// <typeparam name="TState">State Enum Type</typeparam>
+    /// <typeparam name="TContext">Context Type</typeparam>
     public class FiniteStateMachine<TState, TContext> : BaseStateMachine<TState, TContext> where TState : struct, Enum
     {
         private readonly EnumStateMachineDefinition<TState, TContext> _definition;
@@ -31,9 +31,9 @@ public FiniteStateMachine(EnumStateMachineDefinition<TState, TContext> definitio
         /// <summary>
         /// Gets the definition of the finite state machine.
         /// </summary>
-        /// <param name="target"></param>
-        /// <param name="context"></param>
-        /// <returns></returns>
+        /// <param name="target">Target state</param>
+        /// <param name="context">Context object</param>
+        /// <returns>If transition to target state is allowed</returns>
         public override bool CanTransitionTo(TState target, TContext context) =>
             _definition.Transitions.Any(t =>
                 t.From.Name == _current.Name &&
@@ -43,9 +43,9 @@ public override bool CanTransitionTo(TState target, TContext context) =>
         /// <summary>
         /// Attempts to transition to the specified target state given the current context.
         /// </summary>
-        /// <param name="target"></param>
-        /// <param name="context"></param>
-        /// <returns></returns>
+        /// <param name="target">Target state</param>
+        /// <param name="context">Context object</param>
+        /// <returns>If transtion to target state is successful</returns>
         public override bool TryTransitionTo(TState target, TContext context)
         {
             var transition = _definition.Transitions.FirstOrDefault(t =>

src/FsmNet/FiniteStateMachineBuilder.cs

@@ -8,23 +8,23 @@
     /// <summary>
     /// Builder for creating a finite state machine based on an enumeration type.
     /// </summary>
-    /// <typeparam name="TState"></typeparam>
-    /// <typeparam name="TContext"></typeparam>
+    /// <typeparam name="TState">State Enum Type</typeparam>
+    /// <typeparam name="TContext">Context Type</typeparam>
     public class FiniteStateMachineBuilder<TState, TContext> where TState : struct, Enum
     {
-        private readonly string _workItemType;
+        private readonly string _entityType;
         private TState? _initial;
         private readonly HashSet<TState> _states = new HashSet<TState>();
         private readonly List<ITransition<TContext>> _transitions = new List<ITransition<TContext>>();
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="FiniteStateMachineBuilder{TState, TContext}"/> class with the specified work item type.
+        /// Initializes a new instance of the <see cref="FiniteStateMachineBuilder{TState, TContext}"/> class with the specified entity type.
         /// </summary>
-        /// <param name="workItemType"></param>
-        private FiniteStateMachineBuilder(string workItemType) => _workItemType = workItemType;
+        /// <param name="entityType"></param>
+        private FiniteStateMachineBuilder(string entityType) => _entityType = entityType;
 
         /// <summary>
-        /// Creates a new instance of the <see cref="FiniteStateMachineBuilder{TState, TContext}"/> for the specified work item type.
+        /// Creates a new instance of the <see cref="FiniteStateMachineBuilder{TState, TContext}"/> for the specified entity type.
         /// </summary>
         /// <param name="workItemType"></param>
         /// <returns></returns>
@@ -63,7 +63,7 @@ public TransitionBuilder AddTransition(TState from, TState to)
         public EnumStateMachineDefinition<TState, TContext> Build()
         {
             if (_initial is null) throw new InvalidOperationException("Initial state not specified.");
-            return new EnumStateMachineDefinition<TState, TContext>(_workItemType, _states, _transitions, _initial.Value);
+            return new EnumStateMachineDefinition<TState, TContext>(_entityType, _states, _transitions, _initial.Value);
         }
 
         /// <summary>
@@ -76,7 +76,7 @@ public SerializableStateMachine ToSerializable()
             if (_initial is null) throw new InvalidOperationException("Initial state must be defined.");
             return new SerializableStateMachine
             {
-                EntityType = _workItemType,
+                EntityType = _entityType,
                 InitialState = _initial.ToString(),
                 States = _states.Select(s => s.ToString()).ToList(),
                 Transitions = _transitions.Select(t => new SerializableTransition
@@ -102,33 +102,59 @@ public class TransitionBuilder
             private string _conditionName;
             private string _sideEffectName;
 
+            /// <summary>
+            /// Initializes a new instance of the <see cref="TransitionBuilder"/> class with the specified parent builder and states.
+            /// </summary>
+            /// <param name="parent"></param>
+            /// <param name="from"></param>
+            /// <param name="to"></param>
             public TransitionBuilder(FiniteStateMachineBuilder<TState, TContext> parent, TState from, TState to)
             {
                 _parent = parent;
                 _from = from;
                 _to = to;
             }
 
+            /// <summary>
+            /// Defines a condition for the transition. The condition is a function that takes the context and returns a boolean indicating whether the transition can occur.
+            /// </summary>
+            /// <param name="condition"></param>
+            /// <param name="name"></param>
+            /// <returns></returns>
             public TransitionBuilder When(Func<TContext, bool> condition, string name = null)
             {
                 _condition = condition;
                 _conditionName = name;
                 return this;
             }
 
+            /// <summary>
+            /// Defines a side effect for the transition. The side effect is an action that takes the context and is executed when the transition occurs.
+            /// </summary>
+            /// <param name="effect"></param>
+            /// <param name="name"></param>
+            /// <returns></returns>
             public TransitionBuilder WithSideEffect(Action<TContext> effect, string name = null)
             {
                 _sideEffect = effect;
                 _sideEffectName = name;
                 return this;
             }
 
+            /// <summary>
+            /// Finalizes the transition definition and adds it to the parent finite state machine builder's list of transitions.
+            /// </summary>
+            /// <returns></returns>
             public FiniteStateMachineBuilder<TState, TContext> Done()
             {
                 _parent._transitions.Add(new EnumTransition<TState, TContext>(_from, _to, _condition, _sideEffect, _conditionName, _sideEffectName));
                 return _parent;
             }
 
+            /// <summary>
+            /// Implicitly converts the TransitionBuilder to a FiniteStateMachineBuilder, allowing for method chaining.
+            /// </summary>
+            /// <param name="b"></param>
             public static implicit operator FiniteStateMachineBuilder<TState, TContext>(TransitionBuilder b) => b.Done();
         }
 

src/FsmNet/IStateMachine.cs

@@ -5,8 +5,8 @@
     /// <summary>
     /// Interface for a state machine that defines the core functionality for transitioning between states.
     /// </summary>
-    /// <typeparam name="TState"></typeparam>
-    /// <typeparam name="TContext"></typeparam>
+    /// <typeparam name="TState">State Enum Type</typeparam>
+    /// <typeparam name="TContext">Context Type</typeparam>
     public interface IStateMachine<TState, TContext> where TState : struct, Enum
     {
         /// <summary>

src/FsmNet/IStateMachineDefinition.cs

@@ -11,7 +11,7 @@ public interface IStateMachineDefinition<TContext>
         /// <summary>
         /// Gets the type of work item this state machine is associated with.
         /// </summary>
-        string WorkItemType { get; }
+        string EntityType { get; }
 
         /// <summary>
         /// Gets a collection of all states in the state machine.

src/FsmNet/ITransition.cs

@@ -5,7 +5,7 @@
     /// <summary>
     /// Represents a transition between two states in a finite state machine.
     /// </summary>
-    /// <typeparam name="TContext"></typeparam>
+    /// <typeparam name="TContext">Context Type</typeparam>
     public interface ITransition<TContext>
     {
         /// <summary>

src/FsmNet/Serialization/TransitionRegistry.cs

@@ -6,7 +6,7 @@
     /// <summary>
     /// Represents a registry for conditions and side effects associated with transitions in a state machine.
     /// </summary>
-    /// <typeparam name="TContext"></typeparam>
+    /// <typeparam name="TContext">Context Type</typeparam>
     public class TransitionRegistry<TContext>
     {
         /// <summary>