anchor.diff:              | [| :? string as prefix |] ->
                   let typedSearch = runtimeType<obj> typeName
                   typedSearch.AddXmlDoc(sprintf "A strongly typed interface to a S3 search with prefix [%s]" prefix)
  -                typedSearch.AddMembersDelayed(fun () ->
  -                    getObjects client bucket (Prefix prefix)
  -                    |> Seq.map (createTypedS3Entry typedSearch client bucket isVersioned)
  -                    |> Seq.toList)
  +                typedSearch.AddMembersDelayed(fun () -> createTypedS3Entries typedSearch client bucket isVersioned prefix)
   
                   ownerType.AddMember(typedSearch)
                   typedSearch
  
positive.code:         | "Enabled" | "Suspended" -> true
          | _ -> false
  
      /// Returns all the S3 objects in the specified S3 bucket
      let getObjects (client : Amazon.S3.IAmazonS3) (bucket : Amazon.S3.Model.S3Bucket) (Prefix prefix) =
          let rec loop marker = seq {
              let req = new Amazon.S3.Model.ListObjectsRequest()
              req.BucketName <- bucket.BucketName
              req.Prefix     <- prefix
              req.Delimiter  <- "/"
              if not <| String.IsNullOrWhiteSpace marker then req.Marker <- marker
  
              let response = client.ListObjects(req)
              yield! response.CommonPrefixes |> Seq.map (fun folderName -> Folder(Prefix folderName))
              yield! response.S3Objects |> Seq.map S3Object
          
              if not <| String.IsNullOrWhiteSpace response.NextMarker then yield! loop response.NextMarker
          }
  
          loop ""
  
      /// Returns all the versions for the specified S3 object
      let getObjectVersions (client : Amazon.S3.IAmazonS3) (bucket : Amazon.S3.Model.S3Bucket) (s3Object : Amazon.S3.Model.S3Object) =
  
negative.code:         typedS3Object
  
      /// Create a nested type to represent a S3 folder
      let rec createTypedS3Folder (ownerType : ProvidedTypeDefinition) client (bucket : Amazon.S3.Model.S3Bucket) isVersioned prefix folderName =
          let typedFolder = runtimeType<obj> folderName
          typedFolder.AddXmlDoc(sprintf "A strongly typed interface to a S3 folder %s" prefix)
  
          typedFolder.AddMembersDelayed(fun () -> createTypedS3Entries typedFolder client bucket isVersioned prefix)
  
          typedFolder
  
      /// Create a nested type to represent a S3 entry (either Folder or S3Object)
      and createTypedS3Entry (ownerType : ProvidedTypeDefinition) client bucket isVersioned = function
          | Folder(Prefix prefix, FolderName folderName) -> createTypedS3Folder ownerType client bucket isVersioned prefix folderName
          | S3Object(s3Object) when isVersioned -> createTypedVersionedS3Object ownerType client bucket s3Object
          | S3Object(s3Object) -> createTypedS3Object ownerType client bucket None s3Object
  
      /// Create and return the list of nested types representing entries that are returned by the given prefix
      and createTypedS3Entries (ownerType : ProvidedTypeDefinition) client bucket isVersioned prefix =
          let (isTruncated, entries) = getObjects client bucket (Prefix prefix)
  
          seq {
              yield! entries |> Seq.map (createTypedS3Entry ownerType client bucket isVersioned)
              if isTruncated then yield runtimeType<obj> "Too many results, use Search<...> instead"
          }
          |> Seq.toList
  
      /// Create a nested parametric type to represent a Search
      let createTypedSearch (ownerType : ProvidedTypeDefinition) client (bucket : Amazon.S3.Model.S3Bucket) isVersioned =
  