anchor.diff:              ActivityWorker.Start(clt, domain, activity.TaskList.Name, activity.Process, onActivityTaskError.Trigger, heartbeat, ?identity = identity))
       let startChildWorkflows clt = childWorkflows |> List.iter (fun workflow -> workflow.Start clt)
   
  -    static let validateChildWorkflow (child : Workflow) =
  +    static let validateChildWorkflow (child : IWorkflow) =
           if child.ExecutionStartToCloseTimeout.IsNone then failwithf "child workflows must specify execution timeout"
           if child.TaskStartToCloseTimeout.IsNone then failwithf "child workflows must specify decision task timeout"
           if child.ChildPolicy.IsNone then failwithf "child workflows must specify child policy"
  
positive.code: 
  type Activity = Activity<string, string>
  
  type StageExecutionState =
      {
          mutable StageNumber   : int
          mutable AttemptNumber : int
          mutable MaxAttempts   : int
      }
  
  /// The different actions that can be taken as a stage in the workflow
  type StageAction = 
      | ScheduleActivity      of IActivity
      | StartChildWorkflow    of Workflow
  
  /// Represents a stage in the workflow
  and Stage =
      {
          StageNumber : int           // zero-based index, e.g. 5 = 6th stage
          Action      : StageAction   // what action to perform at this stage in the workflow?
      }
  
  and Workflow (domain, name, description, version, ?taskList, 
                ?stages                  : Stage list,
                ?taskStartToCloseTimeout : Seconds,
                ?execStartToCloseTimeout : Seconds,
                ?childPolicy             : ChildPolicy,
                ?identity                : Identity,
                ?maxAttempts) =
      do if nullOrWs domain then nullArg "domain"
      do if nullOrWs name   then nullArg "name"
  
  
negative.code:             let activities = stages 
                               |> List.collect (function 
                                  | { StageNumber = stageNum; Action = ScheduleActivity(activity) }
                                      -> [ (stageNum, activity, getActivityVersion name stageNum) ]
                                  | { StageNumber = stageNum; Action = ParallelActions(arr, _) }
                                      -> let activityVersion = getActivityVersion name stageNum
                                         arr |> getActivities |> Array.map (fun activity -> stageNum, activity, activityVersion) |> Array.toList
                                  | _ -> [])
                               |> List.filter (fun (_, activity, version) -> not <| existing.Contains(activity.Name, version))
                               |> Seq.distinctBy (fun (_, activity, version) -> activity.Name, version)
  
              for (id, activity, version) in activities do
                  let req = RegisterActivityTypeRequest(Domain = domain, Name = activity.Name)
  