anchor.diff:                                              |> Array.map (fun x -> x.ToString("x2"))
                                               |> Array.reduce (+)
                                           "Operation" + hash
  -                                let (operationType, operationTypes) = getOperationProvidedTypes(schemaTypes, uploadInputTypeName, enumProvidedTypes, operationAstFields, operationTypeRef)
  -                                let generateWrapper name = ProvidedTypeDefinition(name, None, isSealed = true)
  -                                let wrappersByPath = Dictionary<string list, ProvidedTypeDefinition>()
  -                                let rootWrapper = generateWrapper "Types"
  -                                wrappersByPath.Add([], rootWrapper)
  -                                let rec getWrapper (path : string list) =
  -                                    if wrappersByPath.ContainsKey path
  -                                    then wrappersByPath.[path]
  -                                    else
  -                                        let wrapper = generateWrapper (path.Head.FirstCharUpper())
  -                                        let upperWrapper =
  -                                            let path = path.Tail
  -                                            if wrappersByPath.ContainsKey(path)
  -                                            then wrappersByPath.[path]
  -                                            else getWrapper path
  -                                        upperWrapper.AddMember(wrapper)
  -                                        wrappersByPath.Add(path, wrapper)
  -                                        wrapper
  -                                let includeType (path : string list) (t : ProvidedTypeDefinition) =
  -                                    let wrapper = getWrapper path
  -                                    wrapper.AddMember(t)
  -                                operationTypes |> Map.iter (fun (path, _) t -> includeType path t)
  +                                let (operationType, operationTypes, rootWrapper) = getOperationProvidedTypes(schemaTypes, uploadInputTypeName, enumProvidedTypes, operationAstFields, operationTypeRef)
                                   let operationTypeName : TypeName =
                                       match operationTypeRef.Name with
                                       | Some name -> name
  
positive.code:                         let metadata : ProvidedTypeMetadata = { Name = tref.Name.Value; Description = tref.Description }
                          let tdef = ProvidedRecord.preBuildProvidedType(metadata, None)
                          providedTypes := (!providedTypes).Add((path, tref.Name.Value), tdef)
                          let properties =
                              astFields
                              |> List.filter (function | TypeField _ -> true | _ -> false)
  
negative.code: 
  module internal Provider =
      let getOperationProvidedTypes(schemaTypes : Map<TypeName, IntrospectionType>, uploadInputTypeName : string option, enumProvidedTypes : Map<TypeName, ProvidedTypeDefinition>, operationAstFields, operationTypeRef) =
          let generateWrapper name = ProvidedTypeDefinition(name, None, isSealed = true)
          let wrappersByPath = Dictionary<string list, ProvidedTypeDefinition>()
          let rootWrapper = generateWrapper "Types"
          wrappersByPath.Add([], rootWrapper)
          let rec getWrapper (path : string list) =
              if wrappersByPath.ContainsKey path
              then wrappersByPath.[path]
              else
                  let wrapper = generateWrapper (path.Head.FirstCharUpper())
                  let upperWrapper =
                      let path = path.Tail
                      if wrappersByPath.ContainsKey(path)
                      then wrappersByPath.[path]
                      else getWrapper path
                  upperWrapper.AddMember(wrapper)
                  wrappersByPath.Add(path, wrapper)
                  wrapper
          let includeType (path : string list) (t : ProvidedTypeDefinition) =
              let wrapper = getWrapper path
              wrapper.AddMember(t)
          let providedTypes = ref Map.empty<Path * TypeName, ProvidedTypeDefinition>
          let rec getProvidedType (providedTypes : Map<Path * TypeName, ProvidedTypeDefinition> ref) (schemaTypes : Map<TypeName, IntrospectionType>) (path : Path) (astFields : AstFieldInfo list) (tref : IntrospectionTypeRef) : Type =
              match tref.Kind with
  