anchor.diff:      
       /// Returns the Sort field associated with the field
       let sortField (schema : FieldSchema) = schema.Field.SortFieldType
  -
  +    
       /// Signifies if a field is represented using multiple fields in the index
  -    let hasSubType (field : IField) = field.SubTypes.IsSome
  +    let hasSubType (field : FieldBase) = field.SubTypes.IsSome
   
   [<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
   module TypeIndentity = 
  
positive.code: /// Information needed to represent a field in FlexSearch document
  /// This should only contain information which is fixed for a given type so that the
  /// instance could be cachced. Any Index specific information shouls go to FieldSchema
  [<Interface>]
  type IField = 
      
      
      abstract Suffix : string option
      abstract SubTypes : IField [] option
      abstract FieldType : FlexSearch.Api.Constants.FieldType
      abstract LuceneFieldType : LuceneFieldType
      abstract SortFieldType : SortFieldType option
      abstract DefaultStringValue : string
      abstract ToInternal : string -> BasicDataType
      abstract ToExternal : fieldName:string -> fieldValue:string -> string
      abstract Validate : fieldName:string -> fieldValue:string -> BasicDataType option
      abstract DefaultValue : BasicDataType
      abstract CreateFieldTemplate : schemaName:string -> generateDocValue:bool -> FieldTemplate
      abstract UpdateFieldTemplate : fieldName:string -> document:Dictionary<string, string> -> FieldTemplate -> unit
  
  /// Represents a field in an Index.
  type FieldSchema = 
  
negative.code:     member this.TryGetValue(key : string) = this.Dictionary.TryGetValue(key)
      member this.ReadOnlyDictionary = new ReadOnlyDictionary<string, FieldSchema>(this.Dictionary)
  
  /// Helpers for creating Lucene field types
  [<RequireQualifiedAccess>]
  module CreateField = 
      /// A field that is indexed but not tokenized: the entire String value is indexed as a single token. 
      /// For example this might be used for a 'country' field or an 'id' field, or any field that you 
      /// intend to use for sorting or access through the field cache.
      let string fieldName = new StringField(fieldName, Constants.StringDefaultValue, FieldStore.YES) :> LuceneField
      
      /// A field that is indexed and tokenized, without term vectors. For example this would be used on a 
      /// 'body' field, that contains the bulk of a document's text.
      let text fieldName = new TextField(fieldName, Constants.StringDefaultValue, FieldStore.YES) :> LuceneField
      
      let long fieldName = new LongField(fieldName, 0L, FieldStore.YES) :> LuceneField
      let longDV fieldName = new NumericDocValuesField(fieldName, 0L) :> LuceneField
      let int fieldName = new IntField(fieldName, 0, FieldStore.YES) :> LuceneField
      let intDV fieldName = new NumericDocValuesField(fieldName, 0L) :> LuceneField
      let double fieldName = new DoubleField(fieldName, 0.0, FieldStore.YES) :> LuceneField
      let doubleDV fieldName = new DoubleDocValuesField(fieldName, 0.0) :> LuceneField
      let float fieldName = new FloatField(fieldName, float32 0.0, FieldStore.YES) :> LuceneField
      let floatDV fieldName = new FloatDocValuesField(fieldName, float32 0.0) :> LuceneField
      let stored fieldName = new StoredField(fieldName, Constants.StringDefaultValue) :> LuceneField
      let binary fieldName = new StoredField(fieldName, [||]) :> LuceneField
      let custom (fieldName, value : string, template : FlexLucene.Document.FieldType) = 
          new LuceneField(fieldName, value, template)
      let bytesForNullString = System.Text.Encoding.Unicode.GetBytes(Constants.StringDefaultValue)
  
  