Update the documentation to remove the builder API (#550) (#551)

Co-authored-by: Laurent Saint-Félix <laurent.saintfelix@elastic.co>

Author: github-actions[bot]

.doc/installation.asciidoc

@@ -1,18 +1,18 @@
 [[installation]]
 == Installation
 
-To install the 7.x version of the client, add the package to your `go.mod` file:
+To install the 8.x version of the client, add the package to your `go.mod` file:
 
 [source,text]
 ------------------------------------
-require github.com/elastic/go-elasticsearch/v7 7.16
+require github.com/elastic/go-elasticsearch/v8 8.5
 ------------------------------------
 
 Or, clone the repository:
 
 [source,text]
 ------------------------------------
-git clone --branch 7.16 https://github.com/elastic/go-elasticsearch.git $GOPATH/src/github
+git clone --branch 8.5 https://github.com/elastic/go-elasticsearch.git $GOPATH/src/github
 ------------------------------------
 
 To install another version, modify the path or the branch name accordingly. The 

.doc/typedapi/conventions/endpoints.asciidoc

@@ -3,7 +3,7 @@
 
 All the available endpoints are generated in separate packages and assembled in the client. The `core` namespace is duplicated at the root of the client for convenient access.
 
-Each endpoint follows a factory pattern which returns a pointer to a new instance each time. This leads to a builder pattern allowing to directly chain the options before running your query.
+Each endpoint follows a factory pattern which returns a pointer to a new instance each time.
 
 [source,go]
 -----

.doc/typedapi/conventions/naming.asciidoc

@@ -3,5 +3,5 @@
 
 Whenever appropriate, names may be suffixed with an underscore:
 
-* To avoid collision with protected keywords (`range, `if`, `type`, and so on).
+* To avoid collision with protected keywords (`range`, `if`, `type`, and so on).
 * To reflect the presence of a leading underscore in the API like `\_index` vs `Index_` or `\_source` vs `Source_`.

.doc/typedapi/conventions/requests.asciidoc

@@ -4,18 +4,11 @@
 Requests are modeled around structures that follows as closely as possible the {es} API and uses the standard `json/encoding` for serialization.
 Corresponding request can be found withing the same package as its endpoint and comes with a Builder that allows you to deep dive into the API by following the types.
 
-The builder is particularly useful around pointer fields and is embeddable within a standard struct declaration, such that these two declarations give you the same result:
-
 [source,go]
 ------------------------------------
-types.QueryContainer{
-    Term: map[types.Field]types.TermQuery{
+types.Query{
+    Term: map[string]types.TermQuery{
         "name": {Value: "Foo"},
     },
 }
-types.QueryContainer{
-    Term: map[types.Field]types.TermQuery{
-        "name": types.NewTermQueryBuilder().Value(types.NewFieldValueBuilder().String("Foo")).Build(),
-    },
-}
 ------------------------------------

.doc/typedapi/conventions/structure.asciidoc

@@ -5,7 +5,6 @@ The Typed client lives in the `typedapi` package within the `go-elasticsearch` r
 
 The entire client is summed in an index at the root of the package for convenient access after instantiation.
 
-Each endpoint resides in its own package within `typedapi` and contains the client for this endpoint, the `Request` struct along with its builder, if applicable.
+Each endpoint resides in its own package within `typedapi` and contains the client for this endpoint, and the `Request` struct if applicable.
 
-The requests are based on a collection of structures generated from the https://github.com/elastic/elasticsearch-specification[elasticsearch-specification] repository and gathered in a `types` package within `typedapi`.
-Each type comes with a fluent builder for convenient creation and discoverability.
+The requests are based on a collection of structures generated from the https://github.com/elastic/elasticsearch-specification[elasticsearch-specification] repository and gathered in a `types` package within `typedapi`.

.doc/typedapi/conventions/types.asciidoc

@@ -2,7 +2,7 @@
 ==== Types
 
 Requests and responses are relying on a collection of structures generated from the https://github.com/elastic/elasticsearch-specification[elasticsearch-specification] in the `types` package.
-Each type comes with json tags and a builder.
+Each type comes with json tags.
 
 ==== Enums
 
@@ -19,5 +19,4 @@ refresh.Waitfor => "wait_for"
 
 ==== Unions
 
-To capture the expressiveness of the API union fields are represented by a type alias to an interface.
-Each type alias comes with a builder that lists the possible types for the underlying value.
+To capture the expressiveness of the API union fields are represented by a type alias to an interface.

.doc/typedapi/examples/aggregations.asciidoc

@@ -5,19 +5,21 @@ Given documents with a `price` field, we run a sum aggregation on `index_name`:
 [source,go]
 -----
 totalPricesAgg, err := es.Search().
-	Index("index_name"). // <1>
-	Request(
-		search.NewRequestBuilder().
-			Size(0). // <2>
-			Aggregations(
-				map[string]*types.AggregationContainerBuilder{
-					"total_prices": types.NewAggregationContainerBuilder(). // <3>
-						Sum(types.NewSumAggregationBuilder().Field("price")), // <4>
-				}).
-			Build(),
-	).Do(context.Background())
+    Index("index_name"). // <1>
+    Request(
+        &search.Request{
+            Size: some.Int(0), // <2>
+            Aggregations: map[string]types.Aggregations{
+                "total_prices": { // <3>
+                    Sum: &types.SumAggregation{
+                        Field: some.String("price"), // <4>
+                    },
+                },
+            },
+        },
+    ).Do(context.Background())
 -----
 <1> Specifies the index name.
 <2> Sets the size to 0 to retrieve only the result of the aggregation.
 <3> Specifies the field name on which the sum aggregation runs.
-<4> The `SumAggregation` is part of the `AggregationContainer` map.
+<4> The `SumAggregation` is part of the `Aggregations` map.

.doc/typedapi/examples/indices.asciidoc

@@ -9,8 +9,8 @@ Notice how using the builder for the `IntegerNumberProperty` will automatically
 res, err := es.Indices.Create("test-index").
     Request(&create.Request{
         Mappings: &types.TypeMapping{
-            Properties: map[types.PropertyName]types.PropertyBuilder{
-                "price": types.NewIntegerNumberPropertyBuilder().Build(),
+            Properties: map[string]types.Property{
+                "price": types.NewIntegerNumberProperty(),
             },
         },
     }).

.doc/typedapi/examples/search.asciidoc

@@ -9,8 +9,8 @@ With a struct request:
 res, err := es.Search().
     Index("index_name"). // <1>
     Request(&search.Request{ // <2>
-        Query: &types.QueryContainer{
-            Match: map[types.Field]types.MatchQuery{
+        Query: &types.Query{
+            Match: map[string]types.MatchQuery{
                 "name": {Query: "Foo"}, // <3>
             },
         },
@@ -21,22 +21,7 @@ res, err := es.Search().
 <3> Match query specifies that `name` should match `Foo`.
 <4> The query is run with a `context.Background` and returns the response.
 
-The same query using the builder:
-[source,go]
------
-res, err := es.Search().
-	Index("index_name").
-	Request(search.NewRequestBuilder().
-		Query(types.NewQueryContainerBuilder().
-			Match(map[types.Field]types.MatchQueryBuilder{
-				"name": types.NewMatchQueryBuilder().
-					Query("Foo"),
-			})).
-		Build(),
-	).Do(context.Background())
------
-
-Both of the examples produce the following JSON:
+It produces the following JSON:
 
 [source,json]
 -----

.doc/typedapi/queries.asciidoc

@@ -9,33 +9,14 @@ For example, a simple search request for a term "Foo" in the `name` field could
 [source,go]
 -----
 search.Request{
-    Query: &types.QueryContainer{
-        Term: map[types.Field]types.TermQuery{
+    Query: &types.Query{
+        Term: map[string]types.TermQuery{
             "name": {Value: "Foo"},
         },
     },
 }
 -----
 
-==== Query Builder
-
-Although the structure syntax is lightweight, the types will sometimes lead you to pointers of string or even type aliases which ultimately are interfaces.
-For all those occasions as well as discoverability, we provide for the entire API a builder for each type; the request above can be written like this:
-
-[source,go]
------
-ss := search.NewRequest().
-    Query(
-        types.NewQueryContainer().
-            Term(map[types.Field]types.TermQuery{
-                "name": types.NewTermQuery().Value("Foo").Build(),
-            }).
-            Build()).
-    Build()
------
-
-The builders are designed to take value arguments for easier inline use, you can mix at will the structures and the builder as you see fit depending on your usage.
-
 ==== Raw JSON
 
 Lastly if you want to use your own pre-baked JSON queries using templates or even a specific encoder, you can pass the body directly to the `Raw` method of the endpoint: