anchor.diff:              | _ -> Choice2Of2(Errors.HTTP_UNSUPPORTED_CONTENT_TYPE |> GenerateOperationMessage)
           else Choice2Of2(Errors.HTTP_NO_BODY_DEFINED |> GenerateOperationMessage)
       
  +    let Created = HttpStatusCode.Created
  +    let Accepted = HttpStatusCode.Accepted
  +    let Ok = HttpStatusCode.OK
  +    let NotFound = HttpStatusCode.NotFound
  +    let BadRequest = HttpStatusCode.BadRequest
  +    let Conflict = HttpStatusCode.Conflict
       let CREATED (value : obj) (owin : IOwinContext) = WriteResponse HttpStatusCode.Created value owin
       let ACCEPTED (value : obj) (owin : IOwinContext) = WriteResponse HttpStatusCode.Accepted value owin
       let OK (value : obj) (owin : IOwinContext) = WriteResponse HttpStatusCode.OK value owin
  
positive.code:     open System.Net
      open System.Text
      open System.Threading
      open FlexSearch.Api.Messages
      
      let jsonSettings = new JsonSerializerSettings()
      
      jsonSettings.Converters.Add(new StringEnumConverter())
      
      /// Helper method to serialize cluster messages
      let ProtoSerialize(message : 'a) = 
  
negative.code:         Serializer.Serialize(stream, message)
          stream.ToArray()
      
      /// Helper method to De-serialize cluster messages
      let ProtoDeserialize<'T>(message : byte []) = 
          use stream = new MemoryStream(message)
          Serializer.Deserialize<'T>(stream)
      
      /// <summary>
      /// Formatter interface for supporting multiple formats in the HTTP engine
      /// </summary>
      type IFormatter = 
          abstract SupportedHeaders : unit -> string []
          abstract Serialize : body:obj * stream:Stream -> unit
          abstract DeSerialize<'T> : stream:Stream -> 'T
      
      [<Sealed>]
      type JilJsonFormatter() = 
          let options = new Jil.Options(false, false, true, Jil.DateTimeFormat.ISO8601, false)
          interface IFormatter with
              
              member x.DeSerialize<'T>(stream : Stream) = 
                  use reader = new StreamReader(stream) :> TextReader
                  Jil.JSON.Deserialize<'T>(reader, options)
              
              member x.Serialize(body : obj, stream : Stream) : unit = 
                  use writer = new StreamWriter(stream)
                  Jil.JSON.Serialize(body, writer, options)
                  writer.Flush()
              
              member x.SupportedHeaders() : string [] = 
                  [| "application/json"; "text/json"; "application/json;charset=utf-8"; "application/json; charset=utf-8" |]
      
      [<Sealed>]
      type ProtoBufferFormatter() = 
          interface IFormatter with
              member x.DeSerialize<'T>(stream : Stream) = ProtoBuf.Serializer.Deserialize<'T>(stream)
              member x.Serialize(body : obj, stream : Stream) : unit = ProtoBuf.Serializer.Serialize(stream, body)
              member x.SupportedHeaders() : string [] = [| "application/x-protobuf"; "application/octet-stream" |]
      
      let private Formatters = new ConcurrentDictionary<string, IFormatter>(StringComparer.OrdinalIgnoreCase)
      let protoFormatter = new ProtoBufferFormatter() :> IFormatter
      let jsonFormatter = new JilJsonFormatter() :> IFormatter
      
      protoFormatter.SupportedHeaders() |> Array.iter (fun x -> Formatters.TryAdd(x, protoFormatter) |> ignore)
      jsonFormatter.SupportedHeaders() |> Array.iter (fun x -> Formatters.TryAdd(x, jsonFormatter) |> ignore)
      
      /// Get request format from the request object
      /// Defaults to json
  