anchor.diff:  
   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
  
positive.code:                                             |> 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 operationTypeName : TypeName =
                                      match operationTypeRef.Name with
                                      | Some name -> name
  
negative.code:                                 else failwithf "Could not find schema type based on the query. Type \"%s\" does not exist on the schema definition." typeName
                              let metadata : ProvidedTypeMetadata = { Name = itype.Name; Description = itype.Description }
                              let tdef = ProvidedRecord.preBuildProvidedType(metadata, Some (upcast baseType))
                              includeType path tdef
                              ProvidedRecord.makeProvidedType(tdef, properties)
                          fragmentProperties
                          |> List.map createFragmentType
                      fragmentTypes |> List.iter (fun fragmentType -> providedTypes := (!providedTypes).Add((path, fragmentType.Name), fragmentType))
                      Types.makeOption baseType
              | _ -> failwith "Could not find a schema type based on a type reference. The reference has an invalid or unsupported combination of Name, Kind and OfType fields."
          (getProvidedType providedTypes schemaTypes [] operationAstFields operationTypeRef), !providedTypes, rootWrapper
  
      let getSchemaProvidedTypes(schema : IntrospectionSchema, uploadInputTypeName : string option) =
          let providedTypes = ref Map.empty<TypeName, ProvidedTypeDefinition>
  