anchor.diff:          | 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 simpleCasesAsString (cases:IList<FSharpUnionCase>) = cases |> Seq.map (fun case -> "\"" + case.DisplayName + "\"") |> String.concat " | "
  +    
  +    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
  -                                                            | Mixture cases -> sprintf "\t\texport interface %s {\n%s\n\t\t}" (entityNameToString union) (casesAsString cases)
  +                                                            | 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
  
positive.code: let parameterAndTypeToTS parameterName (fsharpType:FSharpType) =
  
      //We have to check it's not some of these or will throw on accessing TypeDefinition
      let isOption =
          fsharpType.IsAbbreviation &&
          not fsharpType.IsGenericParameter &&
  
negative.code: 
      let unions = nested |> Seq.filter (fun entity -> entity.IsFSharpUnion)
  
      let isNumber (type_:FSharpType) =
  
          let reallyType = if type_.IsAbbreviation then type_.AbbreviatedType else type_
  
          reallyType.HasTypeDefinition &&
          not reallyType.IsAbbreviation &&
          not reallyType.IsGenericParameter &&
          not reallyType.IsFunctionType &&
          not reallyType.IsTupleType &&
          (reallyType.TypeDefinition.DisplayName = "Double" || //Bit much to assume this is the right "option"
           reallyType.TypeDefinition.DisplayName = "int32")
  
      let (|JustName|Type|Types|) (case:FSharpUnionCase) =
  
          match case.UnionCaseFields.Count with
  