anchor.diff:          | 1 -> Type case.UnionCaseFields.[0].FieldType
           | _ -> Types case.UnionCaseFields.[0]
   
  -    let (|AllJustNames|Mixture|) (cases:IList<FSharpUnionCase>) =
  +    let (|AllJustNames|NamesAndNumbers|ComplexTypes|) (cases:IList<FSharpUnionCase>) =
           if cases |> Seq.exists (fun case -> case.UnionCaseFields.Count > 0) then
  -            Mixture cases
  +            if cases |> Seq.collect (fun case -> case.UnionCaseFields) |> Seq.exists (fun field -> not (isNumber field.FieldType)) then
  +                ComplexTypes cases
  +            else
  +                NamesAndNumbers cases
           else
               AllJustNames cases
   
  
positive.code: 
      let unions = nested |> Seq.filter (fun entity -> entity.IsFSharpUnion)
  
      let (|JustName|Type|Types|) (case:FSharpUnionCase) =
  
          match case.UnionCaseFields.Count with
  
negative.code:         | Type singleType -> sprintf "\t\t\t%s%s: %s;" case.DisplayName optional (typeToTS singleType)
          | Types types -> sprintf "\t\t\t%s%s: %s;" case.DisplayName optional "OnlySupportSingleTypeCases"
  
      let nameOrNumberToString (case:FSharpUnionCase) =
          if case.UnionCaseFields.Count = 1 && isNumber case.UnionCaseFields.[0].FieldType then
              sprintf "{ %s: number }" case.DisplayName
          else
              "\"" + case.DisplayName + "\""
  
      let casesAsString (cases:IList<FSharpUnionCase>) = cases |> Seq.map (cases |> caseAsString) |> String.concat "\n"
      
      let namesAndNumbersCasesAsString (cases:IList<FSharpUnionCase>) = cases |> Seq.map (fun case -> nameOrNumberToString case) |> String.concat " | "
  
      let simpleCasesAsString (cases:IList<FSharpUnionCase>) = cases |> Seq.map (fun case -> nameOrNumberToString case) |> String.concat " | "
  
  
      let unionsAsString = unions |> Seq.map (fun union -> match union.UnionCases with
                                                              | ComplexTypes cases -> sprintf "\t\texport interface %s {\n%s\n\t\t}" (entityNameToString union) (casesAsString cases)
                                                              | NamesAndNumbers cases -> sprintf "\t\texport type %s = %s" union.DisplayName (namesAndNumbersCasesAsString cases)
                                                              | AllJustNames cases -> sprintf "\t\texport type %s = %s" union.DisplayName (simpleCasesAsString cases))
  
      //Classes
  