//arrange
	var transitions = new IStateTransition<BugState, TransitionActionStatus>[]
				         {
				             new BugTransition.Open(),
				             new BugTransition.Assign(new BugTransitionAction.Assign()),
				             new BugTransition.Defer(new BugTransitionAction.Defer()),
				             new BugTransition.Resolve(new BugTransitionAction.Resolve()),
				             new BugTransition.Close(new BugTransitionAction.Close()),
				         };
	var myStateMachine = new StateMachine<BugState, TransitionActionStatus>("example",
                                                                      transitions,
                                                                      initialState: new BugState.Open());
	
	//act
	var bug = new Bug("my bug name", myStateMachine); //Bug type inherits from Stateful base type
	
	//assert
	Assert.That(bug.CurrentState, Is.TypeOf<BugState.Open>()); //true	
	
	//act
	bug.Assign("[email protected]", out transitionActionStatus); //triggers a transition of the state machine
	
	//assert
	Assert.That(bug.CurrentState, Is.TypeOf<BugState.Assigned>()); //true
	Assert.That(transitionActionStatus, Is.EqualTo(TransitionActionStatus.Success)); //true
	Assert.That(bug.AssigneeEmail, Is.EqualTo("[email protected]")); //true
	
	//act
	var json = myStateMachine.ToJson();
	var myDeserializedStateMachine = new StateMachine<BugState, TransitionActionStatus>("example",
                                                                                         _transitions,
                                                                                         initialState: new BugState.Open());
	myDeserializedStateMachine.InitializeFromJson(json);
	
	//assert
	Assert.That(myDeserializedStateMachine.CurrentState, Is.TypeOf<BugState.Assigned>()); //true

	public abstract class BugState : State
	{
		public class Assigned : BugState {}

 		public class Closed : BugState {}

 		public class Deferred : BugState {}

  		public class Open : BugState {}

 		public class Resolved : BugState {}
	}
    

	public class Bug : Stateful<BugState, TransitionActionStatus>
	{
		public Bug(string title, IStateMachine<BugState, TransitionActionStatus> stateMachine) : base(stateMachine)
		{
			Title = title;
		}
		
		public string Title { get; set; }
		
		public string AssigneeEmail { get; set; }
		
		public string ClosedByName { get; set; }
		
		public Bug Open(out TransitionActionStatus transitionActionStatus)
		{
			return TriggerTransition(this, new BugState.Open(), out transitionActionStatus);
		}
        
		public Bug Assign(string assigneeEmail, out TransitionActionStatus transitionActionStatus)
		{
			dynamic dto = new ExpandoObject();
			dto.AssigneeEmail = assigneeEmail;

			return TriggerTransition(this, new BugState.Assigned(), out transitionActionStatus, dto);
		}
		
		public void Defer(out TransitionActionStatus transitionActionStatus)
		{
			return TriggerTransition(this, new BugState.Deferred(), out transitionActionStatus);
		}
		
		public void Resolve(out TransitionActionStatus transitionActionStatus)
		{
			return TriggerTransition(this, new BugState.Resolved(), out transitionActionStatus);
		}
		
		public Bug Close(string closedByName, out TransitionActionStatus transitionActionStatus)
		{
			dynamic dto = new ExpandoObject();
			dto.ClosedByName = closedByName;

			return TriggerTransition(this, new BugState.Closed(), out transitionActionStatus, dto);
		}
	}

	public partial class BugTransition
	{
		public class Resolve : StateTransition<BugState, TransitionActionStatus>
		{
		    public Resolve(BugTransitionAction.Resolve transitionAction)
		        : base(transitionAction: transitionAction) { }
		
		    public override BugState[] StartStates
		    {
		        get { return new[] { new BugState.Assigned(), }; }
		    }
		
		    public override BugState[] EndStates
		    {
		        get { return new[] { new BugState.Resolved(), }; }
		    }
		}
		
		public class Assign : StateTransition<BugState, TransitionActionStatus>
		{
			//...
		}
		
		//etc.
	}	

	public partial class BugTransitionAction
	{
		public class Assign : TransitionAction<BugState, TransitionActionStatus>
		{
		    public override TransitionActionStatus Run(BugState targetState,
		                                            IStateMachine<BugState, TransitionActionStatus> stateMachine,
		                                            dynamic statefulObject, dynamic dto = null)
		    {
		        if (dto == null)
		        {
		            throw new ArgumentNullException("dto");
		        }
		
		        if (dto.AssigneeEmail == null)
		        {
		            throw new Exception("AssigneeEmail not supplied.");
		        }
		
		        statefulObject.AssigneeEmail = dto.AssigneeEmail;
		
		        return TransitionActionStatus.Success;
		    }
		}
		
		//etc.
	}

	//...
	
	var transitions = new IStateTransition<BugState, TransitionActionStatus>[]
				{
					new BugTransition.Open(),
					new BugTransition.Assign(new BugTransitionAction.Assign()),
					new BugTransition.Defer(new BugTransitionAction.Defer()),
					new BugTransition.Resolve(new BugTransitionAction.Resolve()),
					new BugTransition.Close(new BugTransitionAction.Close()),
				};	
	
	_stateMachine = new StateMachine<BugState, TransitionActionStatus>("example",
                                                                  transitions,
                                                                  initialState: new BugState.Open());
	
	//...

	//arrange
	var bug = new Bug("my bug name", _stateMachine);	
	
	//act
	bug.Assign("[email protected]", out transitionActionStatus);
	
	//assert
	Assert.That(bug.CurrentState, Is.TypeOf(BugState.Assigned)); //true
	Assert.That(transitionActionStatus, Is.EqualTo(TransitionActionStatus.Success)); //true
	Assert.That(bug.AssigneeEmail, Is.EqualTo("[email protected]")); //true

	//...
	
	var json = _myStateMachine.ToJson();
	//send json to Couch or somewhere...
	
	//later...
	
	var myStateMachine = new StateMachine<BugState, TransitionActionStatus>("example",
                                                                         _transitions,
                                                                         initialState: new BugState.Open());
	myStateMachine.InitializeFromJson(json);
	
	//continue where you left off...