From f730d3f7fac30bb72094fa4813480b71bcbbfd27 Mon Sep 17 00:00:00 2001
From: Fanit Kolchina <kolchfa@amazon.com>
Date: Fri, 14 Oct 2022 09:18:20 -0400
Subject: [PATCH 1/9] Adds xy point and shape documentation

Signed-off-by: Fanit Kolchina <kolchfa@amazon.com>
---
 _opensearch/query-dsl/xy.md                   | 184 +++++++++
 _opensearch/supported-field-types/xy-point.md |  85 ++++
 _opensearch/supported-field-types/xy-shape.md | 379 ++++++++++++++++++
 _opensearch/supported-field-types/xy.md       |  26 ++
 4 files changed, 674 insertions(+)
 create mode 100644 _opensearch/query-dsl/xy.md
 create mode 100644 _opensearch/supported-field-types/xy-point.md
 create mode 100644 _opensearch/supported-field-types/xy-shape.md
 create mode 100644 _opensearch/supported-field-types/xy.md

diff --git a/_opensearch/query-dsl/xy.md b/_opensearch/query-dsl/xy.md
new file mode 100644
index 0000000000..3868a4e562
--- /dev/null
+++ b/_opensearch/query-dsl/xy.md
@@ -0,0 +1,184 @@
+---
+layout: default
+title: xy queries
+parent: Query DSL
+nav_order: 65
+---
+
+# xy queries
+
+To search for documents that contain xy point and xy shape fields, use an xy query. 
+
+## Spatial relations
+
+When you provide an xy shape to the xy query, the xy fields are matched using following spatial relationships to the provided shape:
+
+Relation | Description | Supporting xy Field Type
+:--- | :--- | :--- | :--- 
+`INTERSECTS` | (Default) Matches documents whose xy point or xy shape intersects the shape provided in the query. | `xy_point`, `xy_shape`
+`DISJOINT` | Matches documents whose xy shape does not intersect with the shape provided in the query. | `xy_shape`
+`WITHIN` | Matches documents whose xy shape is completely within the shape provided in the query. | `xy_shape`
+`CONTAINS` | Matches documents whose xy shape completely contains the shape provided in the query. | `xy_shape`
+
+## Defining the shape in an xy query
+
+You can define the shape in an xy query either by providing a new shape definition at query time, or by referencing the name of a shape pre-indexed in another index.  
+
+### Using a new shape definition
+
+To provide a new shape to an xy query, define it in the `xy_shape` field.
+
+The following example illustrates searching for documents that match an xy shape defined at query time.
+
+First, create an index and map the `point` field as an `xy_point` and the `rectangle` field as an `xy_shape`:
+
+```json
+PUT testindex1
+{
+  "mappings": {
+    "properties": {
+      "point": {
+        "type": "xy_point"
+      },
+      "rectangle": {
+        "type": "xy_shape"
+      }
+    }
+  }
+}
+```
+
+Index a document with an xy point and a document with an xy shape:
+
+```json
+PUT testindex1/_doc/1
+{
+  "point": { 
+    "x": 0.5,
+    "y": 4.5
+  }
+}
+
+PUT testindex1/_doc/2
+{
+  "location" : {
+    "type" : "polygon",
+    "coordinates" : [
+      [[2.5, 6.0], 
+      [1.5, 2.0], 
+      [3.5, 3.5],
+      [0.5, 4.5]]
+    ]
+  }
+}
+```
+
+Define an [`envelope`]({{site.url}}{{site.baseurl}}/opensearch/supported-field-types/xy-shape#envelope)&mdash;a bounding rectangle in the `[[minX, maxY], [maxX, minY]]` format. Search for documents with xy points or shapes that intersect that envelope:
+
+```json
+GET testindex1/_search
+{
+  "query": {
+    "xy_shape": {
+      "geometry": {
+        "query_shape": {
+          "type": "envelope",
+          "coordinates": [ [ 0.0, 6.0], [ 4.0, 2.0] ]
+        },
+        "relation": "intersect"
+      }
+    }
+  }
+}
+
+The response contains both documents:
+
+```json
+```
+
+### Using a pre-indexed shape definition
+
+When constructing an xy query, you can also reference the name of a shape pre-indexed in another index. Using this method, you can define an xy shape at index time and refer to it by name, providing the following parameters in the `indexed_shape` object:
+
+Parameter | Description
+:--- | :---
+index | The name of the index that contains the pre-indexed shape.
+id | The document ID of the document that contains the pre-indexed shape.
+path | The field name of the field that contains the pre-indexed shape as a path.
+
+The following example illustrates referencing the name of a shape pre-indexed in another index.
+
+First, create an index `pre-indexed-shapes` and map the `geometry` field for this index as an `xy_shape`:
+
+```json
+PUT pre-indexed-shapes
+{
+  "mappings": {
+    "properties": {
+      "geometry": {
+        "type": "xy_shape"
+      }
+    }
+  }
+}
+```
+
+Index an envelope and name it `rectangle`:
+
+```json
+PUT testindex1/_doc/rectangle
+{
+  "geometry": {
+    "type": "envelope",
+    "coordinates" : [ [ 0.0, 6.0], [ 4.0, 2.0] ]
+  }
+}
+```
+
+Index a document with an xy point and a document with an xy shape into the index `testindex1`:
+
+```json
+PUT testindex1/_doc/1
+{
+  "point": { 
+    "x": 0.5,
+    "y": 4.5
+  }
+}
+
+PUT testindex1/_doc/2
+{
+  "location" : {
+    "type" : "polygon",
+    "coordinates" : [
+      [[2.5, 6.0], 
+      [1.5, 2.0], 
+      [3.5, 3.5],
+      [0.5, 4.5]]
+    ]
+  }
+}
+```
+
+Search for documents with shapes that intersect `rectangle` in the index `testindex1` using a filter:
+
+```json
+GET testindex1/_search
+{
+  "query": {
+    "bool": {
+      "filter": {
+        "xy_shape": {
+          "geometry": {
+            "indexed_shape": {
+              "index": "pre-indexed-shapes",
+              "id": "rectangle",
+              "path": "geometry"
+            }
+          }
+        }
+      }
+    }
+  }
+}
+```
\ No newline at end of file
diff --git a/_opensearch/supported-field-types/xy-point.md b/_opensearch/supported-field-types/xy-point.md
new file mode 100644
index 0000000000..a3b3f66219
--- /dev/null
+++ b/_opensearch/supported-field-types/xy-point.md
@@ -0,0 +1,85 @@
+---
+layout: default
+title: xy point
+nav_order: 58
+has_children: false
+parent: Cartesian field types
+grand_parent: Supported field types
+---
+
+# xy point field type
+
+An xy point field type contains a point in a two-dimensional Cartesian coordinate system, specified by x and y coordinates. It is based on the Lucene [XYPoint](https://lucene.apache.org/core/8_5_1/core/org/apache/lucene/geo/XYPoint.html) field type. The xy point field type is similar to the [geopoint]({{site.url}}{{site.baseurl}}/opensearch/supported-field-types/geo-point/) field type, but does not have the range limitations of geopoint. The coordinates of an xy point are single-precision floating point values. For information about the range and precision of floating-point values, see [Numeric field types]({{site.url}}{{site.baseurl}}/opensearch/supported-field-types/numeric/).
+
+## Example
+
+Create a mapping with an xy point field type:
+
+```json
+PUT testindex1
+{
+  "mappings": {
+    "properties": {
+      "point": {
+        "type": "xy_point"
+      }
+    }
+  }
+}
+```
+
+## Formats
+
+xy points can be indexed in the following formats:
+
+- An object with an x and y coordinate
+
+```json
+PUT testindex1/_doc/1
+{
+  "point": { 
+    "x": 0.5,
+    "y": 4.5
+  }
+}
+```
+
+- A string in the "`x`,`y`" format
+
+```json
+PUT testindex1/_doc/2
+{
+  "point": "0.5,4.5" 
+}
+```
+
+- An array in the [`x`, `y`] format
+
+```json
+PUT testindex1/_doc/3
+{
+  "point": [0.5, 4.5] 
+}
+```
+
+- A [Well-Known Text](https://docs.opengeospatial.org/is/12-063r5/12-063r5.html) POINT in the "POINT(`x` `y`)" format
+
+```json
+PUT testindex1/_doc/4
+{
+  "point": "POINT (0.5 4.5)"
+}
+```
+
+In all xy point formats the coordinates must be specified in the `x, y` order. 
+{: .note}
+
+## Parameters
+
+The following table lists the parameters accepted by xy point field types. All parameters are optional.
+
+Parameter | Description 
+:--- | :--- 
+`ignore_malformed` | A Boolean value that specifies to ignore malformed values and not to throw an exception. Default is `false`.
+`ignore_z_value` | Specific to points with three coordinates. If `ignore_z_value` is `true`, the third coordinate is not indexed but is still stored in the _source field. If `ignore_z_value` is `false`, an exception is thrown.
+[`null_value`]({{site.url}}{{site.baseurl}}/opensearch/supported-field-types/index#null-value) | A  value to be used in place of `null`. Must be of the same type as the field. If this parameter is not specified, the field is treated as missing when its value is `null`. Default is `null`.
\ No newline at end of file
diff --git a/_opensearch/supported-field-types/xy-shape.md b/_opensearch/supported-field-types/xy-shape.md
new file mode 100644
index 0000000000..c0ec23524e
--- /dev/null
+++ b/_opensearch/supported-field-types/xy-shape.md
@@ -0,0 +1,379 @@
+---
+layout: default
+title: xy shape
+nav_order: 59
+has_children: false
+parent: Cartesian field types
+grand_parent: Supported field types
+---
+
+# xy shape field type
+
+An xy shape field type contains a shape, such as a polygon or a collection of xy points. It is based on the Lucene [XYShape](https://lucene.apache.org/core/8_3_0/sandbox/org/apache/lucene/document/XYShape.html) field type. To index a geoshape, OpenSearch tesselates the shape into a triangular mesh and stores each triangle in a BKD tree. This provides a 10<sup>-7</sup>decimal degree of precision, which represents near-perfect spatial resolution.
+
+The xy shape field type is similar to the [geoshape]({{site.url}}{{site.baseurl}}/opensearch/supported-field-types/geo-shape/) field type, but it represents shapes on the Cartesian plane, which is not based on the earth-fixed terrestrial reference system. The coordinates of an xy shape are single-precision floating point values. For information about the range and precision of floating-point values, see [Numeric field types]({{site.url}}{{site.baseurl}}/opensearch/supported-field-types/numeric/).
+
+## Example
+
+Create a mapping with an xy shape field type:
+
+```json
+PUT testindex
+{
+  "mappings": {
+    "properties": {
+      "location": {
+        "type": "xy_shape"
+      }
+    }
+  }
+}
+```
+
+## Formats
+
+xy shapes can be indexed in the following formats:
+
+- [GeoJSON](https://geojson.org/)
+- [Well-Known Text (WKT)](https://docs.opengeospatial.org/is/12-063r5/12-063r5.html)
+
+In both GeoJSON and WKT, the coordinates must be specified in the `x, y` order within coordinate arrays.
+{: .note}
+
+## xy shape types
+
+The following table describes the possible xy shape types and their relationship to the GeoJSON and WKT types.
+
+OpenSearch type | GeoJSON type | WKT type | Description 
+:--- | :--- | :--- | :--- 
+[`point`](#point) | Point | POINT | A geographic point specified by the x and y coordinates. 
+[`linestring`](#line-string) | LineString | LINESTRING | A line specified by two or more points. May be a straight line or a path of connected line segments.
+[`polygon`](#polygon) | Polygon | POLYGON | A polygon specified by a list of vertices in coordinate form. The polygon must be closed, meaning the last point must be the same as the first point. Therefore, to create an n-gon, n+1 vertices are required. The minimum number of vertices is four, which creates a triangle.
+[`multipoint`](#multi-point) | MultiPoint | MULTIPOINT | An array of discrete related points that are not connected.
+[`multilinestring`](#multiline-string) | MultiLineString | MULTILINESTRING | An array of linestrings.
+[`multipolygon`](#multi-polygon) | MultiPolygon | MULTIPOLYGON | An array of polygons.
+[`geometrycollection`](#geometry-collection) | GeometryCollection | GEOMETRYCOLLECTION | A collection of xy shapes that may be of different types.
+[`envelope`](#envelope) | N/A | BBOX | A bounding rectangle specified by top-left and bottom-right vertices.
+
+## Point
+
+A point is specified by a single pair of coordinates. 
+
+Index a point in GeoJSON format:
+
+```json
+PUT testindex/_doc/1
+{
+  "location" : {
+    "type" : "point",
+    "coordinates" : [0.5, 4.5]        
+  }
+}
+```
+
+Index a point in WKT format:
+
+```json
+PUT testindex/_doc/1
+{
+  "location" : "POINT (0.5 4.5)"        
+}
+```
+
+## Line string
+
+A line string is a line specified by two or more points. If the points are collinear, the line string is a straight line. Otherwise, the line string represents a path made of line segments.
+
+Index a line string in GeoJSON format:
+
+```json
+PUT testindex/_doc/2
+{
+  "location" : {
+    "type" : "linestring",
+    "coordinates" : [[0.5, 4.5], [-1.5, 2.3]]
+  }
+}
+```
+
+Index a line string in WKT format:
+
+```json
+PUT testindex/_doc/2
+{
+  "location" : "LINESTRING (0.5 4.5, -1.5 2.3)"
+}
+```
+
+## Polygon
+
+A polygon is specified by a list of vertices in coordinate form. The polygon must be closed, meaning the last point must be the same as the first point. In the following example, a triangle is created using four points. 
+
+GeoJSON requires that you list the vertices of the polygon counterclockwise. WKT does not impose a specific order on vertices.
+{: .note}
+
+Index a polygon (triangle) in GeoJSON format:
+
+```json
+PUT testindex/_doc/3
+{
+  "location" : {
+    "type" : "polygon",
+    "coordinates" : [
+      [[0.5, 4.5], 
+      [2.5, 6.0], 
+      [1.5, 2.0], 
+      [0.5, 4.5]]
+    ]
+  }
+}
+```
+
+Index a polygon (triangle) in WKT format:
+
+```json
+PUT testindex/_doc/3
+{
+  "location" : "POLYGON ((0.5 4.5, 2.5 6.0, 1.5 2.0, 0.5 4.5))"
+}
+```
+
+The polygon may have holes inside. In this case, the `coordinates` field will contain multiple arrays. The first array represents the outer polygon, and each subsequent array represents a hole. Holes are represented as polygons and specified as arrays of coordinates.
+
+GeoJSON requires that you list the vertices of the polygon counterclockwise and the vertices of the hole clockwise. WKT does not impose a specific order on vertices.
+{: .note}
+
+Index a polygon (triangle) with a triangular hole in GeoJSON format:
+
+```json
+PUT testindex/_doc/4
+{
+  "location" : {
+    "type" : "polygon",
+    "coordinates" : [
+      [[0.5, 4.5], 
+      [2.5, 6.0], 
+      [1.5, 2.0], 
+      [0.5, 4.5]],
+      
+      [[1.0, 4.5], 
+      [1.5, 4.5], 
+      [1.5, 4.0], 
+      [1.0, 4.5]]
+    ]
+  }
+}
+```
+
+Index a polygon (triangle) with a triangular hole in WKT format:
+
+```json
+PUT testindex/_doc/4
+{
+  "location" : "POLYGON ((0.5 4.5, 2.5 6.0, 1.5 2.0, 0.5 4.5), (1.0 4.5, 1.5 4.5, 1.5 4.0, 1.0 4.5))"
+}
+```
+By default, the vertices of the polygon are traversed in a counterclockwise order. You can define an [`orientation`](#parameters) parameter to specify the vertex traversal order at mapping time:
+
+```json
+PUT testindex
+{
+  "mappings": {
+    "properties": {
+      "location": {
+        "type": "xy_shape",
+        "orientation" : "left"
+      }
+    }
+  }
+}
+```
+
+Subsequently indexed documents can override the `orientation` setting:
+
+```json
+PUT testindex/_doc/3
+{
+  "location" : {
+    "type" : "polygon",
+    "orientation" : "cw",
+    "coordinates" : [
+      [[0.5, 4.5], 
+      [2.5, 6.0], 
+      [1.5, 2.0], 
+      [0.5, 4.5]]
+    ]
+  }
+}
+```
+
+## Multi point
+
+A multi point is an array of discrete related points that are not connected. 
+
+Index a multi point in GeoJSON format:
+
+```json
+PUT testindex/_doc/6
+{
+  "location" : {
+    "type" : "multipoint",
+    "coordinates" : [
+      [0.5, 4.5], 
+      [2.5, 6.0]
+    ]
+  }
+}
+```
+
+Index a multi point in WKT format:
+
+```json
+PUT testindex/_doc/6
+{
+  "location" : "MULTIPOINT (0.5 4.5, 2.5 6.0)"
+}
+```
+
+## Multiline string
+
+A multiline string is an array of line strings.
+
+Index a line string in GeoJSON format:
+
+```json
+PUT testindex/_doc/2
+{
+  "location" : {
+    "type" : "multilinestring",
+    "coordinates" : [
+      [[0.5, 4.5], [2.5, 6.0]],
+      [[1.5, 2.0], [3.5, 3.5]]
+      ]
+  }
+}
+```
+
+Index a line string in WKT format:
+
+```json
+PUT testindex/_doc/2
+{
+  "location" : "MULTILINESTRING ((0.5 4.5, 2.5 6.0), (1.5 2.0, 3.5 3.5))"
+}
+```
+
+## Multi polygon
+
+A multi polygon is an array of polygons. In this example, the first polygon contains a hole, and the second does not. 
+
+Index a multi polygon in GeoJSON format:
+
+```json
+PUT testindex/_doc/4
+{
+  "location" : {
+    "type" : "multipolygon",
+    "coordinates" : [
+    [
+      [[0.5, 4.5], 
+      [2.5, 6.0], 
+      [1.5, 2.0], 
+      [0.5, 4.5]],
+      
+      [[1.0, 4.5], 
+      [1.5, 4.5], 
+      [1.5, 4.0], 
+      [1.0, 4.5]]
+    ],
+    [
+      [[2.0, 0.0], 
+      [1.0, 2.0], 
+      [3.0, 1.0], 
+      [2.0, 0.0]]
+      ]
+    ]
+  }
+}
+```
+
+Index a multi polygon in WKT format:
+
+```json
+PUT testindex/_doc/4
+{
+  "location" : "MULTIPOLYGON (((0.5 4.5, 2.5 6.0, 1.5 2.0, 0.5 4.5), (1.0 4.5, 1.5 4.5, 1.5 4.0, 1.0 4.5)), ((2.0 0.0, 1.0 2.0, 3.0 1.0, 2.0 0.0)))"
+}
+```
+
+## Geometry collection
+
+A geometry collection is a collection of xy shapes that may be of different types.
+
+Index a geometry collection in GeoJSON format:
+
+```json
+PUT testindex/_doc/7
+{
+  "location" : {
+    "type": "geometrycollection",
+    "geometries": [
+      {
+        "type": "point",
+        "coordinates": [0.5, 4.5]
+      },
+      {
+        "type": "linestring",
+        "coordinates": [[2.5, 6.0], [1.5, 2.0]]
+      }
+    ]
+  }
+}
+```
+
+Index a geometry collection in WKT format:
+
+```json
+PUT testindex/_doc/7
+{
+  "location" : "GEOMETRYCOLLECTION (POINT (0.5 4.5), LINESTRING(2.5 6.0, 1.5 2.0))"
+}
+```
+
+## Envelope
+
+An envelope is a bounding rectangle specified by top-left and bottom-right vertices. The GeoJSON format is `[[minX, maxY], [maxX, minY]]`.
+
+Index an envelope in GeoJSON format:
+
+```json
+PUT testindex/_doc/2
+{
+  "location" : {
+    "type" : "envelope",
+    "coordinates" : [[3.0, 2.0], [6.0, 0.0]]
+  }
+}
+```
+
+In WKT format, use `BBOX (minX, maxX, maxY, minY)`.
+
+Index an envelope in WKT BBOX format:
+
+```json
+PUT testindex/_doc/8
+{
+  "location" : "BBOX (3.0, 6.0, 2.0, 0.0)"
+}
+```
+
+## Parameters
+
+The following table lists the parameters accepted by xy shape field types. All parameters are optional.
+
+Parameter | Description 
+:--- | :--- 
+`coerce` | A Boolean value that specifies whether to automatically close unclosed linear rings. Default is `false`.
+`ignore_malformed` | A Boolean value that specifies to ignore malformed GeoJSON or WKT xy shapes and not to throw an exception. Default is `false` (throw an exception when xy shapes are malformed).
+`ignore_z_value` | Specific to points with three coordinates. If `ignore_z_value` is `true`, the third coordinate is not indexed but is still stored in the _source field. If `ignore_z_value` is `false`, an exception is thrown. Default is `true`.
+`orientation` | Specifies the traversal order of the vertices in the xy shape's list of coordinates. `orientation` takes the following values: <br> 1. RIGHT: counterclockwise. Specify RIGHT orientation by using one of the following strings (uppercase or lowercase): `right`, `counterclockwise`, `ccw`. <br> 2. LEFT: clockwise. Specify LEFT orientation by using one of the following strings (uppercase or lowercase): `left`, `clockwise`, `cw`.  This value can be overridden by individual documents.<br> Default is `RIGHT`.
diff --git a/_opensearch/supported-field-types/xy.md b/_opensearch/supported-field-types/xy.md
new file mode 100644
index 0000000000..ab332b5ed1
--- /dev/null
+++ b/_opensearch/supported-field-types/xy.md
@@ -0,0 +1,26 @@
+---
+layout: default
+title: Cartesian field types
+nav_order: 57
+has_children: true
+has_toc: false
+parent: Supported field types
+---
+
+# Cartesian field types
+
+Cartesian field types facilitate indexing and searching of points and shapes in a two-dimensional Cartesian coordinate system. Cartesian field types are similar to [geographic]({{site.url}}{{site.baseurl}}/opensearch/supported-field-types/geographic/) field types, except they represent points and shapes on the Cartesian plane, which is not based on the earth-fixed terrestrial reference system. Calculating distances on a plane is more efficient than calculating distances on a sphere, so distance sorting is faster for Cartesian field types. 
+
+Cartesian field types work well for spatial applications like virtual reality, CAD, and amusement park and sporting venue mapping. 
+
+The coordinates for the Cartesian field types are single-precision floating point values. For information about the range and precision of floating-point values, see [Numeric field types]({{site.url}}{{site.baseurl}}/opensearch/supported-field-types/numeric/).
+
+Currently, OpenSearch supports indexing and searching cartesian field types, but not aggregations on cartesian field types. If you'd like to see aggregations implemented, open a [GitHub issue](https://github.com/opensearch-project/geospatial).
+{: .note}
+
+The following table lists all Cartesian field types that OpenSearch supports.
+
+Field data type | Description
+:--- | :---  
+[`xy_point`]({{site.url}}{{site.baseurl}}/opensearch/supported-field-types/xy-point/) | A point in a two-dimensional Cartesian coordinate system, specified by x and y coordinates. 
+[`xy_shape`]({{site.url}}{{site.baseurl}}/opensearch/supported-field-types/xy-shape/) | A shape, such as a polygon or a collection of xy points, in a two-dimensional Cartesian coordinate system. 

From 2791105f6bb8d020ee4a493617db9cb9a6e3ba06 Mon Sep 17 00:00:00 2001
From: Fanit Kolchina <kolchfa@amazon.com>
Date: Fri, 14 Oct 2022 09:28:33 -0400
Subject: [PATCH 2/9] Moved the github link

Signed-off-by: Fanit Kolchina <kolchfa@amazon.com>
---
 _opensearch/supported-field-types/xy.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/_opensearch/supported-field-types/xy.md b/_opensearch/supported-field-types/xy.md
index ab332b5ed1..cb70c7e564 100644
--- a/_opensearch/supported-field-types/xy.md
+++ b/_opensearch/supported-field-types/xy.md
@@ -15,12 +15,12 @@ Cartesian field types work well for spatial applications like virtual reality, C
 
 The coordinates for the Cartesian field types are single-precision floating point values. For information about the range and precision of floating-point values, see [Numeric field types]({{site.url}}{{site.baseurl}}/opensearch/supported-field-types/numeric/).
 
-Currently, OpenSearch supports indexing and searching cartesian field types, but not aggregations on cartesian field types. If you'd like to see aggregations implemented, open a [GitHub issue](https://github.com/opensearch-project/geospatial).
-{: .note}
-
 The following table lists all Cartesian field types that OpenSearch supports.
 
 Field data type | Description
 :--- | :---  
 [`xy_point`]({{site.url}}{{site.baseurl}}/opensearch/supported-field-types/xy-point/) | A point in a two-dimensional Cartesian coordinate system, specified by x and y coordinates. 
 [`xy_shape`]({{site.url}}{{site.baseurl}}/opensearch/supported-field-types/xy-shape/) | A shape, such as a polygon or a collection of xy points, in a two-dimensional Cartesian coordinate system. 
+
+Currently OpenSearch supports indexing and searching Cartesian field types, but not aggregations on Cartesian field types. If you'd like to see aggregations implemented, open a [GitHub issue](https://github.com/opensearch-project/geospatial).
+{: .note}
\ No newline at end of file

From c6ed43f3acbd96ec9c39a10497aedd412591e9bc Mon Sep 17 00:00:00 2001
From: Fanit Kolchina <kolchfa@amazon.com>
Date: Thu, 27 Oct 2022 11:55:43 -0400
Subject: [PATCH 3/9] Adds documentation for cartesian shapes

Signed-off-by: Fanit Kolchina <kolchfa@amazon.com>
---
 _opensearch/query-dsl/xy.md                   | 320 ++++++++++++++++--
 _opensearch/supported-field-types/xy-point.md |   4 +-
 _opensearch/supported-field-types/xy-shape.md |   2 +-
 images/xy_query.png                           | Bin 0 -> 14737 bytes
 images/xy_query_point.png                     | Bin 0 -> 13201 bytes
 5 files changed, 288 insertions(+), 38 deletions(-)
 create mode 100644 images/xy_query.png
 create mode 100644 images/xy_query_point.png

diff --git a/_opensearch/query-dsl/xy.md b/_opensearch/query-dsl/xy.md
index 3868a4e562..18c8da27e4 100644
--- a/_opensearch/query-dsl/xy.md
+++ b/_opensearch/query-dsl/xy.md
@@ -7,11 +7,11 @@ nav_order: 65
 
 # xy queries
 
-To search for documents that contain xy point and xy shape fields, use an xy query. 
+To search for documents that contain [xy point]({{site.url}}{{site.baseurl}}/opensearch/supported-field-types/xy-point) and [xy shape]({{site.url}}{{site.baseurl}}/opensearch/supported-field-types/xy-shape) fields, use an xy query. 
 
 ## Spatial relations
 
-When you provide an xy shape to the xy query, the xy fields are matched using following spatial relationships to the provided shape:
+When you provide an xy shape to the xy query, the xy fields are matched using following spatial relations to the provided shape:
 
 Relation | Description | Supporting xy Field Type
 :--- | :--- | :--- | :--- 
@@ -20,6 +20,8 @@ Relation | Description | Supporting xy Field Type
 `WITHIN` | Matches documents whose xy shape is completely within the shape provided in the query. | `xy_shape`
 `CONTAINS` | Matches documents whose xy shape completely contains the shape provided in the query. | `xy_shape`
 
+The examples below illustrate searching for documents that contain xy shapes. To learn how to search for documents that contain xy points, see the [Querying xy points](#querying-xy-points) section.
+
 ## Defining the shape in an xy query
 
 You can define the shape in an xy query either by providing a new shape definition at query time, or by referencing the name of a shape pre-indexed in another index.  
@@ -28,19 +30,16 @@ You can define the shape in an xy query either by providing a new shape definiti
 
 To provide a new shape to an xy query, define it in the `xy_shape` field.
 
-The following example illustrates searching for documents that match an xy shape defined at query time.
+The following example illustrates searching for documents with xy shapes that match an xy shape defined at query time.
 
-First, create an index and map the `point` field as an `xy_point` and the `rectangle` field as an `xy_shape`:
+First, create an index and map the `geometry` field as an `xy_shape`:
 
 ```json
-PUT testindex1
+PUT testindex
 {
   "mappings": {
     "properties": {
-      "point": {
-        "type": "xy_point"
-      },
-      "rectangle": {
+      "geometry": {
         "type": "xy_shape"
       }
     }
@@ -48,26 +47,27 @@ PUT testindex1
 }
 ```
 
-Index a document with an xy point and a document with an xy shape:
+Index a document with a point and a document with a polygon:
 
 ```json
-PUT testindex1/_doc/1
+PUT testindex/_doc/1
 {
-  "point": { 
-    "x": 0.5,
-    "y": 4.5
+  "geometry": { 
+    "type": "point",
+    "coordinates": [0.5, 3.0]
   }
 }
 
-PUT testindex1/_doc/2
+PUT testindex/_doc/2
 {
-  "location" : {
+  "geometry" : {
     "type" : "polygon",
     "coordinates" : [
-      [[2.5, 6.0], 
+      [[2.5, 6.0],
+      [0.5, 4.5], 
       [1.5, 2.0], 
       [3.5, 3.5],
-      [0.5, 4.5]]
+      [2.5, 6.0]]
     ]
   }
 }
@@ -76,24 +76,97 @@ PUT testindex1/_doc/2
 Define an [`envelope`]({{site.url}}{{site.baseurl}}/opensearch/supported-field-types/xy-shape#envelope)&mdash;a bounding rectangle in the `[[minX, maxY], [maxX, minY]]` format. Search for documents with xy points or shapes that intersect that envelope:
 
 ```json
-GET testindex1/_search
+GET testindex/_search
 {
   "query": {
     "xy_shape": {
       "geometry": {
-        "query_shape": {
+        "shape": {
           "type": "envelope",
           "coordinates": [ [ 0.0, 6.0], [ 4.0, 2.0] ]
         },
-        "relation": "intersect"
+        "relation": "WITHIN"
       }
     }
   }
 }
+```
+
+Refer to the following image to visualize the example. Both the point and the polygon are within the bounding envelope:
+
+<img src="{{site.url}}{{site.baseurl}}/images/xy_query.png" alt="xy shape query" width="250">
+
 
 The response contains both documents:
 
 ```json
+{
+  "took" : 363,
+  "timed_out" : false,
+  "_shards" : {
+    "total" : 1,
+    "successful" : 1,
+    "skipped" : 0,
+    "failed" : 0
+  },
+  "hits" : {
+    "total" : {
+      "value" : 2,
+      "relation" : "eq"
+    },
+    "max_score" : 0.0,
+    "hits" : [
+      {
+        "_index" : "testindex",
+        "_id" : "1",
+        "_score" : 0.0,
+        "_source" : {
+          "geometry" : {
+            "type" : "point",
+            "coordinates" : [
+              0.5,
+              3.0
+            ]
+          }
+        }
+      },
+      {
+        "_index" : "testindex",
+        "_id" : "2",
+        "_score" : 0.0,
+        "_source" : {
+          "geometry" : {
+            "type" : "polygon",
+            "coordinates" : [
+              [
+                [
+                  2.5,
+                  6.0
+                ],
+                [
+                  0.5,
+                  4.5
+                ],
+                [
+                  1.5,
+                  2.0
+                ],
+                [
+                  3.5,
+                  3.5
+                ],
+                [
+                  2.5,
+                  6.0
+                ]
+              ]
+            ]
+          }
+        }
+      }
+    ]
+  }
+}
 ```
 
 ### Using a pre-indexed shape definition
@@ -106,7 +179,7 @@ index | The name of the index that contains the pre-indexed shape.
 id | The document ID of the document that contains the pre-indexed shape.
 path | The field name of the field that contains the pre-indexed shape as a path.
 
-The following example illustrates referencing the name of a shape pre-indexed in another index.
+The following example illustrates referencing the name of a shape pre-indexed in another index. In this example, the index `pre-indexed-shapes` contains the shape that defines the boundaries, and the index `testindex` contains the shapes whose locations are checked against those boundaries.
 
 First, create an index `pre-indexed-shapes` and map the `geometry` field for this index as an `xy_shape`:
 
@@ -123,10 +196,10 @@ PUT pre-indexed-shapes
 }
 ```
 
-Index an envelope and name it `rectangle`:
+Index an envelope that specifies the boundaries and name it `rectangle`:
 
 ```json
-PUT testindex1/_doc/rectangle
+PUT pre-indexed-shapes/_doc/rectangle
 {
   "geometry": {
     "type": "envelope",
@@ -135,35 +208,36 @@ PUT testindex1/_doc/rectangle
 }
 ```
 
-Index a document with an xy point and a document with an xy shape into the index `testindex1`:
+Index a document with a point and a document with a polygon into the index `testindex`:
 
 ```json
-PUT testindex1/_doc/1
+PUT testindex/_doc/1
 {
-  "point": { 
-    "x": 0.5,
-    "y": 4.5
+  "geometry": { 
+    "type": "point",
+    "coordinates": [0.5, 3.0]
   }
 }
 
-PUT testindex1/_doc/2
+PUT testindex/_doc/2
 {
-  "location" : {
+  "geometry" : {
     "type" : "polygon",
     "coordinates" : [
-      [[2.5, 6.0], 
+      [[2.5, 6.0],
+      [0.5, 4.5], 
       [1.5, 2.0], 
       [3.5, 3.5],
-      [0.5, 4.5]]
+      [2.5, 6.0]]
     ]
   }
 }
 ```
 
-Search for documents with shapes that intersect `rectangle` in the index `testindex1` using a filter:
+Search for documents with shapes that intersect `rectangle` in the index `testindex` using a filter:
 
 ```json
-GET testindex1/_search
+GET testindex/_search
 {
   "query": {
     "bool": {
@@ -181,4 +255,180 @@ GET testindex1/_search
     }
   }
 }
+```
+
+The above query uses the default spatial relation `INTERSECTS` and returns both the point and the polygon:
+
+```json
+{
+  "took" : 26,
+  "timed_out" : false,
+  "_shards" : {
+    "total" : 1,
+    "successful" : 1,
+    "skipped" : 0,
+    "failed" : 0
+  },
+  "hits" : {
+    "total" : {
+      "value" : 2,
+      "relation" : "eq"
+    },
+    "max_score" : 0.0,
+    "hits" : [
+      {
+        "_index" : "testindex",
+        "_id" : "1",
+        "_score" : 0.0,
+        "_source" : {
+          "geometry" : {
+            "type" : "point",
+            "coordinates" : [
+              0.5,
+              3.0
+            ]
+          }
+        }
+      },
+      {
+        "_index" : "testindex",
+        "_id" : "2",
+        "_score" : 0.0,
+        "_source" : {
+          "geometry" : {
+            "type" : "polygon",
+            "coordinates" : [
+              [
+                [
+                  2.5,
+                  6.0
+                ],
+                [
+                  0.5,
+                  4.5
+                ],
+                [
+                  1.5,
+                  2.0
+                ],
+                [
+                  3.5,
+                  3.5
+                ],
+                [
+                  2.5,
+                  6.0
+                ]
+              ]
+            ]
+          }
+        }
+      }
+    ]
+  }
+}
+```
+
+## Querying xy points
+
+You can also use an xy query to search for documents that contain xy points. 
+
+Create a mapping with `point` as `xy_point`:
+
+```json
+PUT testindex1
+{
+  "mappings": {
+    "properties": {
+      "point": {
+        "type": "xy_point"
+      }
+    }
+  }
+}
+```
+
+Index three points:
+
+```json
+PUT testindex1/_doc/1
+{
+  "point": "1.0, 1.0" 
+}
+
+PUT testindex1/_doc/2
+{
+  "point": "2.0, 0.0" 
+}
+
+PUT testindex1/_doc/3
+{
+  "point": "-2.0, 2.0" 
+}
+```
+
+Search for points that lie within the circle with the center (0, 0) and radius 2:
+
+```json
+GET testindex1/_search
+{
+  "query": {
+    "xy_shape": {
+      "point": {
+        "shape": {
+          "type": "circle",
+          "coordinates": [0.0, 0.0],
+          "radius": 2
+        }
+      }
+    }
+  }
+}
+```
+
+xy point only supports the default `INTERSECTS` spatial relation, so you don't need to provide the `relation` parameter.
+{: .note}
+
+Refer to the following image to visualize the example. Points 1 and 2 are within the circle, and point 3 is outside the circle:
+
+<img src="{{site.url}}{{site.baseurl}}/images/xy_query_point.png" alt="xy point query" width="300">
+
+The response returns documents 1 and 2:
+
+```json
+{
+  "took" : 575,
+  "timed_out" : false,
+  "_shards" : {
+    "total" : 1,
+    "successful" : 1,
+    "skipped" : 0,
+    "failed" : 0
+  },
+  "hits" : {
+    "total" : {
+      "value" : 2,
+      "relation" : "eq"
+    },
+    "max_score" : 0.0,
+    "hits" : [
+      {
+        "_index" : "testindex1",
+        "_id" : "1",
+        "_score" : 0.0,
+        "_source" : {
+          "point" : "1.0, 1.0"
+        }
+      },
+      {
+        "_index" : "testindex1",
+        "_id" : "2",
+        "_score" : 0.0,
+        "_source" : {
+          "point" : "2.0, 0.0"
+        }
+      }
+    ]
+  }
+}
 ```
\ No newline at end of file
diff --git a/_opensearch/supported-field-types/xy-point.md b/_opensearch/supported-field-types/xy-point.md
index a3b3f66219..d042985e47 100644
--- a/_opensearch/supported-field-types/xy-point.md
+++ b/_opensearch/supported-field-types/xy-point.md
@@ -44,12 +44,12 @@ PUT testindex1/_doc/1
 }
 ```
 
-- A string in the "`x`,`y`" format
+- A string in the "`x`, `y`" format
 
 ```json
 PUT testindex1/_doc/2
 {
-  "point": "0.5,4.5" 
+  "point": "0.5, 4.5" 
 }
 ```
 
diff --git a/_opensearch/supported-field-types/xy-shape.md b/_opensearch/supported-field-types/xy-shape.md
index c0ec23524e..8f9224b6d3 100644
--- a/_opensearch/supported-field-types/xy-shape.md
+++ b/_opensearch/supported-field-types/xy-shape.md
@@ -376,4 +376,4 @@ Parameter | Description
 `coerce` | A Boolean value that specifies whether to automatically close unclosed linear rings. Default is `false`.
 `ignore_malformed` | A Boolean value that specifies to ignore malformed GeoJSON or WKT xy shapes and not to throw an exception. Default is `false` (throw an exception when xy shapes are malformed).
 `ignore_z_value` | Specific to points with three coordinates. If `ignore_z_value` is `true`, the third coordinate is not indexed but is still stored in the _source field. If `ignore_z_value` is `false`, an exception is thrown. Default is `true`.
-`orientation` | Specifies the traversal order of the vertices in the xy shape's list of coordinates. `orientation` takes the following values: <br> 1. RIGHT: counterclockwise. Specify RIGHT orientation by using one of the following strings (uppercase or lowercase): `right`, `counterclockwise`, `ccw`. <br> 2. LEFT: clockwise. Specify LEFT orientation by using one of the following strings (uppercase or lowercase): `left`, `clockwise`, `cw`.  This value can be overridden by individual documents.<br> Default is `RIGHT`.
+`orientation` | Specifies the traversal order of the vertices in the xy shape's list of coordinates. `orientation` takes the following values: <br> 1. RIGHT: counterclockwise. Specify RIGHT orientation by using one of the following strings (uppercase or lowercase): `right`, `counterclockwise`, `ccw`. <br> 2. LEFT: clockwise. Specify LEFT orientation by using one of the following strings (uppercase or lowercase): `left`, `clockwise`, `cw`.  This value can be overridden by individual documents.<br> Default is `RIGHT`.
\ No newline at end of file
diff --git a/images/xy_query.png b/images/xy_query.png
new file mode 100644
index 0000000000000000000000000000000000000000..6888c1938a2ca5a186180c75947ae54de3c3cc20
GIT binary patch
literal 14737
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

literal 0
HcmV?d00001

diff --git a/images/xy_query_point.png b/images/xy_query_point.png
new file mode 100644
index 0000000000000000000000000000000000000000..dbfc3a9aa0c1b1719df93986758c7728fad16f45
GIT binary patch
literal 13201
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

literal 0
HcmV?d00001


From 56acf45e07bc5c5d124b58c6bfca1ec5655b2318 Mon Sep 17 00:00:00 2001
From: Fanit Kolchina <kolchfa@amazon.com>
Date: Thu, 27 Oct 2022 16:10:21 -0400
Subject: [PATCH 4/9] Updated BBOX coordinates

Signed-off-by: Fanit Kolchina <kolchfa@amazon.com>
---
 _opensearch/supported-field-types/xy-shape.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/_opensearch/supported-field-types/xy-shape.md b/_opensearch/supported-field-types/xy-shape.md
index 8f9224b6d3..b1fb29134a 100644
--- a/_opensearch/supported-field-types/xy-shape.md
+++ b/_opensearch/supported-field-types/xy-shape.md
@@ -356,14 +356,14 @@ PUT testindex/_doc/2
 }
 ```
 
-In WKT format, use `BBOX (minX, maxX, maxY, minY)`.
+In WKT format, use `BBOX (minX, maxY, maxX, minY)`.
 
 Index an envelope in WKT BBOX format:
 
 ```json
 PUT testindex/_doc/8
 {
-  "location" : "BBOX (3.0, 6.0, 2.0, 0.0)"
+  "location" : "BBOX (3.0, 2.0, 6.0, 0.0)"
 }
 ```
 

From 69ae4326e561067687f6da0473ad91f9e1d17dc9 Mon Sep 17 00:00:00 2001
From: Fanit Kolchina <kolchfa@amazon.com>
Date: Fri, 28 Oct 2022 09:26:26 -0400
Subject: [PATCH 5/9] Fixed typo

Signed-off-by: Fanit Kolchina <kolchfa@amazon.com>
---
 _opensearch/supported-field-types/xy-shape.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/_opensearch/supported-field-types/xy-shape.md b/_opensearch/supported-field-types/xy-shape.md
index b1fb29134a..64b02f47c7 100644
--- a/_opensearch/supported-field-types/xy-shape.md
+++ b/_opensearch/supported-field-types/xy-shape.md
@@ -9,7 +9,7 @@ grand_parent: Supported field types
 
 # xy shape field type
 
-An xy shape field type contains a shape, such as a polygon or a collection of xy points. It is based on the Lucene [XYShape](https://lucene.apache.org/core/8_3_0/sandbox/org/apache/lucene/document/XYShape.html) field type. To index a geoshape, OpenSearch tesselates the shape into a triangular mesh and stores each triangle in a BKD tree. This provides a 10<sup>-7</sup>decimal degree of precision, which represents near-perfect spatial resolution.
+An xy shape field type contains a shape, such as a polygon or a collection of xy points. It is based on the Lucene [XYShape](https://lucene.apache.org/core/8_3_0/sandbox/org/apache/lucene/document/XYShape.html) field type. To index an xy shape, OpenSearch tesselates the shape into a triangular mesh and stores each triangle in a BKD tree. This provides a 10<sup>-7</sup>decimal degree of precision, which represents near-perfect spatial resolution.
 
 The xy shape field type is similar to the [geoshape]({{site.url}}{{site.baseurl}}/opensearch/supported-field-types/geo-shape/) field type, but it represents shapes on the Cartesian plane, which is not based on the earth-fixed terrestrial reference system. The coordinates of an xy shape are single-precision floating point values. For information about the range and precision of floating-point values, see [Numeric field types]({{site.url}}{{site.baseurl}}/opensearch/supported-field-types/numeric/).
 

From e38233a544272553268406d06e4213156fb7d8b1 Mon Sep 17 00:00:00 2001
From: Fanit Kolchina <kolchfa@amazon.com>
Date: Fri, 28 Oct 2022 12:10:02 -0400
Subject: [PATCH 6/9] Updated links and GeoJSON

Signed-off-by: Fanit Kolchina <kolchfa@amazon.com>
---
 _opensearch/supported-field-types/xy-point.md | 14 +++++++++++++-
 _opensearch/supported-field-types/xy-shape.md |  2 +-
 2 files changed, 14 insertions(+), 2 deletions(-)

diff --git a/_opensearch/supported-field-types/xy-point.md b/_opensearch/supported-field-types/xy-point.md
index d042985e47..7d429f7d78 100644
--- a/_opensearch/supported-field-types/xy-point.md
+++ b/_opensearch/supported-field-types/xy-point.md
@@ -9,7 +9,7 @@ grand_parent: Supported field types
 
 # xy point field type
 
-An xy point field type contains a point in a two-dimensional Cartesian coordinate system, specified by x and y coordinates. It is based on the Lucene [XYPoint](https://lucene.apache.org/core/8_5_1/core/org/apache/lucene/geo/XYPoint.html) field type. The xy point field type is similar to the [geopoint]({{site.url}}{{site.baseurl}}/opensearch/supported-field-types/geo-point/) field type, but does not have the range limitations of geopoint. The coordinates of an xy point are single-precision floating point values. For information about the range and precision of floating-point values, see [Numeric field types]({{site.url}}{{site.baseurl}}/opensearch/supported-field-types/numeric/).
+An xy point field type contains a point in a two-dimensional Cartesian coordinate system, specified by x and y coordinates. It is based on the Lucene [XYPoint](https://lucene.apache.org/core/9_3_0/core/org/apache/lucene/geo/XYPoint.html) field type. The xy point field type is similar to the [geopoint]({{site.url}}{{site.baseurl}}/opensearch/supported-field-types/geo-point/) field type, but does not have the range limitations of geopoint. The coordinates of an xy point are single-precision floating point values. For information about the range and precision of floating-point values, see [Numeric field types]({{site.url}}{{site.baseurl}}/opensearch/supported-field-types/numeric/).
 
 ## Example
 
@@ -71,6 +71,18 @@ PUT testindex1/_doc/4
 }
 ```
 
+- GeoJSON format
+
+```json
+PUT testindex1/_doc/5
+{
+  "point" : {
+    "type" : "Point",
+    "coordinates" : [0.5, 4.5]        
+  }
+}
+```
+
 In all xy point formats the coordinates must be specified in the `x, y` order. 
 {: .note}
 
diff --git a/_opensearch/supported-field-types/xy-shape.md b/_opensearch/supported-field-types/xy-shape.md
index 64b02f47c7..0664f5d96d 100644
--- a/_opensearch/supported-field-types/xy-shape.md
+++ b/_opensearch/supported-field-types/xy-shape.md
@@ -9,7 +9,7 @@ grand_parent: Supported field types
 
 # xy shape field type
 
-An xy shape field type contains a shape, such as a polygon or a collection of xy points. It is based on the Lucene [XYShape](https://lucene.apache.org/core/8_3_0/sandbox/org/apache/lucene/document/XYShape.html) field type. To index an xy shape, OpenSearch tesselates the shape into a triangular mesh and stores each triangle in a BKD tree. This provides a 10<sup>-7</sup>decimal degree of precision, which represents near-perfect spatial resolution.
+An xy shape field type contains a shape, such as a polygon or a collection of xy points. It is based on the Lucene [XYShape](https://lucene.apache.org/core/9_3_0/core/org/apache/lucene/document/XYShape.html) field type. To index an xy shape, OpenSearch tesselates the shape into a triangular mesh and stores each triangle in a BKD tree. This provides a 10<sup>-7</sup>decimal degree of precision, which represents near-perfect spatial resolution.
 
 The xy shape field type is similar to the [geoshape]({{site.url}}{{site.baseurl}}/opensearch/supported-field-types/geo-shape/) field type, but it represents shapes on the Cartesian plane, which is not based on the earth-fixed terrestrial reference system. The coordinates of an xy shape are single-precision floating point values. For information about the range and precision of floating-point values, see [Numeric field types]({{site.url}}{{site.baseurl}}/opensearch/supported-field-types/numeric/).
 

From f340f087f6aa1f5553847c07f23d35dc753299c4 Mon Sep 17 00:00:00 2001
From: Fanit Kolchina <kolchfa@amazon.com>
Date: Wed, 2 Nov 2022 20:24:30 -0400
Subject: [PATCH 7/9] Incorporated doc review comments

Signed-off-by: Fanit Kolchina <kolchfa@amazon.com>
---
 _opensearch/query-dsl/xy.md                   | 8 ++++----
 _opensearch/supported-field-types/xy-point.md | 2 +-
 _opensearch/supported-field-types/xy-shape.md | 6 +++---
 _opensearch/supported-field-types/xy.md       | 4 ++--
 4 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/_opensearch/query-dsl/xy.md b/_opensearch/query-dsl/xy.md
index 18c8da27e4..a30cd2fbe2 100644
--- a/_opensearch/query-dsl/xy.md
+++ b/_opensearch/query-dsl/xy.md
@@ -11,10 +11,10 @@ To search for documents that contain [xy point]({{site.url}}{{site.baseurl}}/ope
 
 ## Spatial relations
 
-When you provide an xy shape to the xy query, the xy fields are matched using following spatial relations to the provided shape:
+When you provide an xy shape to the xy query, the xy fields are matched using the following spatial relations to the provided shape:
 
 Relation | Description | Supporting xy Field Type
-:--- | :--- | :--- | :--- 
+:--- | :--- | :--- 
 `INTERSECTS` | (Default) Matches documents whose xy point or xy shape intersects the shape provided in the query. | `xy_point`, `xy_shape`
 `DISJOINT` | Matches documents whose xy shape does not intersect with the shape provided in the query. | `xy_shape`
 `WITHIN` | Matches documents whose xy shape is completely within the shape provided in the query. | `xy_shape`
@@ -24,7 +24,7 @@ The examples below illustrate searching for documents that contain xy shapes. To
 
 ## Defining the shape in an xy query
 
-You can define the shape in an xy query either by providing a new shape definition at query time, or by referencing the name of a shape pre-indexed in another index.  
+You can define the shape in an xy query either by providing a new shape definition at query time or by referencing the name of a shape pre-indexed in another index.  
 
 ### Using a new shape definition
 
@@ -367,7 +367,7 @@ PUT testindex1/_doc/3
 }
 ```
 
-Search for points that lie within the circle with the center (0, 0) and radius 2:
+Search for points that lie within the circle with the center (0, 0) and radius of 2:
 
 ```json
 GET testindex1/_search
diff --git a/_opensearch/supported-field-types/xy-point.md b/_opensearch/supported-field-types/xy-point.md
index 7d429f7d78..c99a454353 100644
--- a/_opensearch/supported-field-types/xy-point.md
+++ b/_opensearch/supported-field-types/xy-point.md
@@ -94,4 +94,4 @@ Parameter | Description
 :--- | :--- 
 `ignore_malformed` | A Boolean value that specifies to ignore malformed values and not to throw an exception. Default is `false`.
 `ignore_z_value` | Specific to points with three coordinates. If `ignore_z_value` is `true`, the third coordinate is not indexed but is still stored in the _source field. If `ignore_z_value` is `false`, an exception is thrown.
-[`null_value`]({{site.url}}{{site.baseurl}}/opensearch/supported-field-types/index#null-value) | A  value to be used in place of `null`. Must be of the same type as the field. If this parameter is not specified, the field is treated as missing when its value is `null`. Default is `null`.
\ No newline at end of file
+[`null_value`]({{site.url}}{{site.baseurl}}/opensearch/supported-field-types/index#null-value) | A  value to be used in place of `null`. The value must be of the same type as the field. If this parameter is not specified, the field is treated as missing when its value is `null`. Default is `null`.
\ No newline at end of file
diff --git a/_opensearch/supported-field-types/xy-shape.md b/_opensearch/supported-field-types/xy-shape.md
index 0664f5d96d..56a445b0cc 100644
--- a/_opensearch/supported-field-types/xy-shape.md
+++ b/_opensearch/supported-field-types/xy-shape.md
@@ -9,9 +9,9 @@ grand_parent: Supported field types
 
 # xy shape field type
 
-An xy shape field type contains a shape, such as a polygon or a collection of xy points. It is based on the Lucene [XYShape](https://lucene.apache.org/core/9_3_0/core/org/apache/lucene/document/XYShape.html) field type. To index an xy shape, OpenSearch tesselates the shape into a triangular mesh and stores each triangle in a BKD tree. This provides a 10<sup>-7</sup>decimal degree of precision, which represents near-perfect spatial resolution.
+An xy shape field type contains a shape, such as a polygon or a collection of xy points. It is based on the Lucene [XYShape](https://lucene.apache.org/core/9_3_0/core/org/apache/lucene/document/XYShape.html) field type. To index an xy shape, OpenSearch tessellates the shape into a triangular mesh and stores each triangle in a BKD tree. This provides a 10<sup>-7</sup>decimal degree of precision, which represents near-perfect spatial resolution.
 
-The xy shape field type is similar to the [geoshape]({{site.url}}{{site.baseurl}}/opensearch/supported-field-types/geo-shape/) field type, but it represents shapes on the Cartesian plane, which is not based on the earth-fixed terrestrial reference system. The coordinates of an xy shape are single-precision floating point values. For information about the range and precision of floating-point values, see [Numeric field types]({{site.url}}{{site.baseurl}}/opensearch/supported-field-types/numeric/).
+The xy shape field type is similar to the [geoshape]({{site.url}}{{site.baseurl}}/opensearch/supported-field-types/geo-shape/) field type, but it represents shapes on the Cartesian plane, which is not based on the earth-fixed terrestrial reference system. The coordinates of an xy shape are single-precision floating-point values. For information about the range and precision of floating-point values, see [Numeric field types]({{site.url}}{{site.baseurl}}/opensearch/supported-field-types/numeric/).
 
 ## Example
 
@@ -239,7 +239,7 @@ PUT testindex/_doc/6
 
 A multiline string is an array of line strings.
 
-Index a line string in GeoJSON format:
+Index a multiline string in GeoJSON format:
 
 ```json
 PUT testindex/_doc/2
diff --git a/_opensearch/supported-field-types/xy.md b/_opensearch/supported-field-types/xy.md
index cb70c7e564..1060a3ece8 100644
--- a/_opensearch/supported-field-types/xy.md
+++ b/_opensearch/supported-field-types/xy.md
@@ -11,9 +11,9 @@ parent: Supported field types
 
 Cartesian field types facilitate indexing and searching of points and shapes in a two-dimensional Cartesian coordinate system. Cartesian field types are similar to [geographic]({{site.url}}{{site.baseurl}}/opensearch/supported-field-types/geographic/) field types, except they represent points and shapes on the Cartesian plane, which is not based on the earth-fixed terrestrial reference system. Calculating distances on a plane is more efficient than calculating distances on a sphere, so distance sorting is faster for Cartesian field types. 
 
-Cartesian field types work well for spatial applications like virtual reality, CAD, and amusement park and sporting venue mapping. 
+Cartesian field types work well for spatial applications like virtual reality, computer-aided design (CAD), and amusement park and sporting venue mapping. 
 
-The coordinates for the Cartesian field types are single-precision floating point values. For information about the range and precision of floating-point values, see [Numeric field types]({{site.url}}{{site.baseurl}}/opensearch/supported-field-types/numeric/).
+The coordinates for the Cartesian field types are single-precision floating-point values. For information about the range and precision of floating-point values, see [Numeric field types]({{site.url}}{{site.baseurl}}/opensearch/supported-field-types/numeric/).
 
 The following table lists all Cartesian field types that OpenSearch supports.
 

From eac1d883ddcedaa588bf9debd382c5683885befd Mon Sep 17 00:00:00 2001
From: Fanit Kolchina <kolchfa@amazon.com>
Date: Wed, 2 Nov 2022 21:01:25 -0400
Subject: [PATCH 8/9] One more doc review comment

Signed-off-by: Fanit Kolchina <kolchfa@amazon.com>
---
 _opensearch/supported-field-types/xy.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/_opensearch/supported-field-types/xy.md b/_opensearch/supported-field-types/xy.md
index 1060a3ece8..aaa942b8f1 100644
--- a/_opensearch/supported-field-types/xy.md
+++ b/_opensearch/supported-field-types/xy.md
@@ -22,5 +22,5 @@ Field data type | Description
 [`xy_point`]({{site.url}}{{site.baseurl}}/opensearch/supported-field-types/xy-point/) | A point in a two-dimensional Cartesian coordinate system, specified by x and y coordinates. 
 [`xy_shape`]({{site.url}}{{site.baseurl}}/opensearch/supported-field-types/xy-shape/) | A shape, such as a polygon or a collection of xy points, in a two-dimensional Cartesian coordinate system. 
 
-Currently OpenSearch supports indexing and searching Cartesian field types, but not aggregations on Cartesian field types. If you'd like to see aggregations implemented, open a [GitHub issue](https://github.com/opensearch-project/geospatial).
+Currently, OpenSearch supports indexing and searching Cartesian field types, but not aggregations on Cartesian field types. If you'd like to see aggregations implemented, open a [GitHub issue](https://github.com/opensearch-project/geospatial).
 {: .note}
\ No newline at end of file

From e98f233c05fd2da752e6f0959ee625b4f096c348 Mon Sep 17 00:00:00 2001
From: Fanit Kolchina <kolchfa@amazon.com>
Date: Thu, 3 Nov 2022 21:16:19 -0400
Subject: [PATCH 9/9] Incorporated editorial comments

Signed-off-by: Fanit Kolchina <kolchfa@amazon.com>
---
 _opensearch/query-dsl/xy.md                   | 14 +++----
 .../supported-field-types/geo-shape.md        | 36 ++++++++--------
 _opensearch/supported-field-types/xy-point.md |  8 ++--
 _opensearch/supported-field-types/xy-shape.md | 42 +++++++++----------
 _opensearch/supported-field-types/xy.md       |  6 +--
 5 files changed, 53 insertions(+), 53 deletions(-)

diff --git a/_opensearch/query-dsl/xy.md b/_opensearch/query-dsl/xy.md
index a30cd2fbe2..bf0bb8b982 100644
--- a/_opensearch/query-dsl/xy.md
+++ b/_opensearch/query-dsl/xy.md
@@ -11,7 +11,7 @@ To search for documents that contain [xy point]({{site.url}}{{site.baseurl}}/ope
 
 ## Spatial relations
 
-When you provide an xy shape to the xy query, the xy fields are matched using the following spatial relations to the provided shape:
+When you provide an xy shape to the xy query, the xy fields are matched using the following spatial relations to the provided shape.
 
 Relation | Description | Supporting xy Field Type
 :--- | :--- | :--- 
@@ -20,7 +20,7 @@ Relation | Description | Supporting xy Field Type
 `WITHIN` | Matches documents whose xy shape is completely within the shape provided in the query. | `xy_shape`
 `CONTAINS` | Matches documents whose xy shape completely contains the shape provided in the query. | `xy_shape`
 
-The examples below illustrate searching for documents that contain xy shapes. To learn how to search for documents that contain xy points, see the [Querying xy points](#querying-xy-points) section.
+The following examples illustrate searching for documents that contain xy shapes. To learn how to search for documents that contain xy points, see the [Querying xy points](#querying-xy-points) section.
 
 ## Defining the shape in an xy query
 
@@ -92,7 +92,7 @@ GET testindex/_search
 }
 ```
 
-Refer to the following image to visualize the example. Both the point and the polygon are within the bounding envelope:
+The following image depicts the example. Both the point and the polygon are within the bounding envelope.
 
 <img src="{{site.url}}{{site.baseurl}}/images/xy_query.png" alt="xy shape query" width="250">
 
@@ -171,7 +171,7 @@ The response contains both documents:
 
 ### Using a pre-indexed shape definition
 
-When constructing an xy query, you can also reference the name of a shape pre-indexed in another index. Using this method, you can define an xy shape at index time and refer to it by name, providing the following parameters in the `indexed_shape` object:
+When constructing an xy query, you can also reference the name of a shape pre-indexed in another index. Using this method, you can define an xy shape at index time and refer to it by name, providing the following parameters in the `indexed_shape` object.
 
 Parameter | Description
 :--- | :---
@@ -257,7 +257,7 @@ GET testindex/_search
 }
 ```
 
-The above query uses the default spatial relation `INTERSECTS` and returns both the point and the polygon:
+The preceding query uses the default spatial relation `INTERSECTS` and returns both the point and the polygon:
 
 ```json
 {
@@ -367,7 +367,7 @@ PUT testindex1/_doc/3
 }
 ```
 
-Search for points that lie within the circle with the center (0, 0) and radius of 2:
+Search for points that lie within the circle with the center at (0, 0) and a radius of 2:
 
 ```json
 GET testindex1/_search
@@ -389,7 +389,7 @@ GET testindex1/_search
 xy point only supports the default `INTERSECTS` spatial relation, so you don't need to provide the `relation` parameter.
 {: .note}
 
-Refer to the following image to visualize the example. Points 1 and 2 are within the circle, and point 3 is outside the circle:
+The following image depicts the example. Points 1 and 2 are within the circle, and point 3 is outside the circle.
 
 <img src="{{site.url}}{{site.baseurl}}/images/xy_query_point.png" alt="xy point query" width="300">
 
diff --git a/_opensearch/supported-field-types/geo-shape.md b/_opensearch/supported-field-types/geo-shape.md
index 2f4c51e545..674822c726 100644
--- a/_opensearch/supported-field-types/geo-shape.md
+++ b/_opensearch/supported-field-types/geo-shape.md
@@ -51,7 +51,7 @@ OpenSearch type | GeoJSON type | WKT type | Description
 [`multilinestring`](#multiline-string) | MultiLineString | MULTILINESTRING | An array of linestrings.
 [`multipolygon`](#multi-polygon) | MultiPolygon | MULTIPOLYGON | An array of polygons.
 [`geometrycollection`](#geometry-collection) | GeometryCollection | GEOMETRYCOLLECTION | A collection of geoshapes that may be of different types.
-[`envelope`](#envelope) | N/A | BBOX | A bounding rectangle specified by top-left and bottom-right vertices.
+[`envelope`](#envelope) | N/A | BBOX | A bounding rectangle specified by upper-left and lower-right vertices.
 
 ## Point
 
@@ -78,11 +78,11 @@ PUT testindex/_doc/1
 }
 ```
 
-## Line string
+## Linestring
 
-A line string is a line specified by two or more points. If the points are collinear, the line string is a straight line. Otherwise, the line string represents a path made of line segments.
+A linestring is a line specified by two or more points. If the points are collinear, the linestring is a straight line. Otherwise, the linestring represents a path made of line segments.
 
-Index a line string in GeoJSON format:
+Index a linestring in GeoJSON format:
 
 ```json
 PUT testindex/_doc/2
@@ -94,7 +94,7 @@ PUT testindex/_doc/2
 }
 ```
 
-Index a line string in WKT format:
+Index a linestring in WKT format:
 
 ```json
 PUT testindex/_doc/2
@@ -208,11 +208,11 @@ PUT testindex/_doc/3
 }
 ```
 
-## Multi point
+## Multipoint
 
-A multi point is an array of discrete related points that are not connected. 
+A multipoint is an array of discrete related points that are not connected. 
 
-Index a multi point in GeoJSON format:
+Index a multipoint in GeoJSON format:
 
 ```json
 PUT testindex/_doc/6
@@ -227,7 +227,7 @@ PUT testindex/_doc/6
 }
 ```
 
-Index a multi point in WKT format:
+Index a multipoint in WKT format:
 
 ```json
 PUT testindex/_doc/6
@@ -236,11 +236,11 @@ PUT testindex/_doc/6
 }
 ```
 
-## Multiline string
+## Multilinestring
 
-A multiline string is an array of line strings.
+A multilinestring is an array of linestrings.
 
-Index a line string in GeoJSON format:
+Index a linestring in GeoJSON format:
 
 ```json
 PUT testindex/_doc/2
@@ -255,7 +255,7 @@ PUT testindex/_doc/2
 }
 ```
 
-Index a line string in WKT format:
+Index a linestring in WKT format:
 
 ```json
 PUT testindex/_doc/2
@@ -264,11 +264,11 @@ PUT testindex/_doc/2
 }
 ```
 
-## Multi polygon
+## Multipolygon
 
-A multi polygon is an array of polygons. In this example, the first polygon contains a hole, and the second does not. 
+A multipolygon is an array of polygons. In this example, the first polygon contains a hole, and the second does not. 
 
-Index a multi polygon in GeoJSON format:
+Index a multipolygon in GeoJSON format:
 
 ```json
 PUT testindex/_doc/4
@@ -298,7 +298,7 @@ PUT testindex/_doc/4
 }
 ```
 
-Index a multi polygon in WKT format:
+Index a multipolygon in WKT format:
 
 ```json
 PUT testindex/_doc/4
@@ -336,7 +336,7 @@ PUT testindex/_doc/7
 
 ## Envelope
 
-An envelope is a bounding rectangle specified by top-left and bottom-right vertices. The GeoJSON format is `[[minLon, maxLat], [maxLon, minLat]]`.
+An envelope is a bounding rectangle specified by upper-left and lower-right vertices. The GeoJSON format is `[[minLon, maxLat], [maxLon, minLat]]`.
 
 Index an envelope in GeoJSON format:
 
diff --git a/_opensearch/supported-field-types/xy-point.md b/_opensearch/supported-field-types/xy-point.md
index c99a454353..bcafa2c31f 100644
--- a/_opensearch/supported-field-types/xy-point.md
+++ b/_opensearch/supported-field-types/xy-point.md
@@ -9,7 +9,7 @@ grand_parent: Supported field types
 
 # xy point field type
 
-An xy point field type contains a point in a two-dimensional Cartesian coordinate system, specified by x and y coordinates. It is based on the Lucene [XYPoint](https://lucene.apache.org/core/9_3_0/core/org/apache/lucene/geo/XYPoint.html) field type. The xy point field type is similar to the [geopoint]({{site.url}}{{site.baseurl}}/opensearch/supported-field-types/geo-point/) field type, but does not have the range limitations of geopoint. The coordinates of an xy point are single-precision floating point values. For information about the range and precision of floating-point values, see [Numeric field types]({{site.url}}{{site.baseurl}}/opensearch/supported-field-types/numeric/).
+An xy point field type contains a point in a two-dimensional Cartesian coordinate system, specified by x and y coordinates. It is based on the Lucene [XYPoint](https://lucene.apache.org/core/9_3_0/core/org/apache/lucene/geo/XYPoint.html) field type. The xy point field type is similar to the [geopoint]({{site.url}}{{site.baseurl}}/opensearch/supported-field-types/geo-point/) field type, but does not have the range limitations of geopoint. The coordinates of an xy point are single-precision floating-point values. For information about the range and precision of floating-point values, see [Numeric field types]({{site.url}}{{site.baseurl}}/opensearch/supported-field-types/numeric/).
 
 ## Example
 
@@ -32,7 +32,7 @@ PUT testindex1
 
 xy points can be indexed in the following formats:
 
-- An object with an x and y coordinate
+- An object with x and y coordinates
 
 ```json
 PUT testindex1/_doc/1
@@ -62,7 +62,7 @@ PUT testindex1/_doc/3
 }
 ```
 
-- A [Well-Known Text](https://docs.opengeospatial.org/is/12-063r5/12-063r5.html) POINT in the "POINT(`x` `y`)" format
+- A [well-known text (WKT)](https://docs.opengeospatial.org/is/12-063r5/12-063r5.html) POINT in the "POINT(`x` `y`)" format
 
 ```json
 PUT testindex1/_doc/4
@@ -83,7 +83,7 @@ PUT testindex1/_doc/5
 }
 ```
 
-In all xy point formats the coordinates must be specified in the `x, y` order. 
+In all xy point formats, the coordinates must be specified in the `x, y` order. 
 {: .note}
 
 ## Parameters
diff --git a/_opensearch/supported-field-types/xy-shape.md b/_opensearch/supported-field-types/xy-shape.md
index 56a445b0cc..510868e72d 100644
--- a/_opensearch/supported-field-types/xy-shape.md
+++ b/_opensearch/supported-field-types/xy-shape.md
@@ -9,9 +9,9 @@ grand_parent: Supported field types
 
 # xy shape field type
 
-An xy shape field type contains a shape, such as a polygon or a collection of xy points. It is based on the Lucene [XYShape](https://lucene.apache.org/core/9_3_0/core/org/apache/lucene/document/XYShape.html) field type. To index an xy shape, OpenSearch tessellates the shape into a triangular mesh and stores each triangle in a BKD tree. This provides a 10<sup>-7</sup>decimal degree of precision, which represents near-perfect spatial resolution.
+An xy shape field type contains a shape, such as a polygon or a collection of xy points. It is based on the Lucene [XYShape](https://lucene.apache.org/core/9_3_0/core/org/apache/lucene/document/XYShape.html) field type. To index an xy shape, OpenSearch tessellates the shape into a triangular mesh and stores each triangle in a BKD tree (a set of balanced k-dimensional trees). This provides a 10<sup>-7</sup>decimal degree of precision, which represents near-perfect spatial resolution.
 
-The xy shape field type is similar to the [geoshape]({{site.url}}{{site.baseurl}}/opensearch/supported-field-types/geo-shape/) field type, but it represents shapes on the Cartesian plane, which is not based on the earth-fixed terrestrial reference system. The coordinates of an xy shape are single-precision floating-point values. For information about the range and precision of floating-point values, see [Numeric field types]({{site.url}}{{site.baseurl}}/opensearch/supported-field-types/numeric/).
+The xy shape field type is similar to the [geoshape]({{site.url}}{{site.baseurl}}/opensearch/supported-field-types/geo-shape/) field type, but it represents shapes on the Cartesian plane, which is not based on the Earth-fixed terrestrial reference system. The coordinates of an xy shape are single-precision floating-point values. For information about the range and precision of floating-point values, see [Numeric field types]({{site.url}}{{site.baseurl}}/opensearch/supported-field-types/numeric/).
 
 ## Example
 
@@ -35,7 +35,7 @@ PUT testindex
 xy shapes can be indexed in the following formats:
 
 - [GeoJSON](https://geojson.org/)
-- [Well-Known Text (WKT)](https://docs.opengeospatial.org/is/12-063r5/12-063r5.html)
+- [Well-known text (WKT)](https://docs.opengeospatial.org/is/12-063r5/12-063r5.html)
 
 In both GeoJSON and WKT, the coordinates must be specified in the `x, y` order within coordinate arrays.
 {: .note}
@@ -53,7 +53,7 @@ OpenSearch type | GeoJSON type | WKT type | Description
 [`multilinestring`](#multiline-string) | MultiLineString | MULTILINESTRING | An array of linestrings.
 [`multipolygon`](#multi-polygon) | MultiPolygon | MULTIPOLYGON | An array of polygons.
 [`geometrycollection`](#geometry-collection) | GeometryCollection | GEOMETRYCOLLECTION | A collection of xy shapes that may be of different types.
-[`envelope`](#envelope) | N/A | BBOX | A bounding rectangle specified by top-left and bottom-right vertices.
+[`envelope`](#envelope) | N/A | BBOX | A bounding rectangle specified by upper-left and lower-right vertices.
 
 ## Point
 
@@ -80,11 +80,11 @@ PUT testindex/_doc/1
 }
 ```
 
-## Line string
+## Linestring
 
-A line string is a line specified by two or more points. If the points are collinear, the line string is a straight line. Otherwise, the line string represents a path made of line segments.
+A linestring is a line specified by two or more points. If the points are collinear, the linestring is a straight line. Otherwise, the linestring represents a path made of line segments.
 
-Index a line string in GeoJSON format:
+Index a linestring in GeoJSON format:
 
 ```json
 PUT testindex/_doc/2
@@ -96,7 +96,7 @@ PUT testindex/_doc/2
 }
 ```
 
-Index a line string in WKT format:
+Index a linestring in WKT format:
 
 ```json
 PUT testindex/_doc/2
@@ -207,11 +207,11 @@ PUT testindex/_doc/3
 }
 ```
 
-## Multi point
+## Multipoint
 
-A multi point is an array of discrete related points that are not connected. 
+A multipoint is an array of discrete related points that are not connected. 
 
-Index a multi point in GeoJSON format:
+Index a multipoint in GeoJSON format:
 
 ```json
 PUT testindex/_doc/6
@@ -226,7 +226,7 @@ PUT testindex/_doc/6
 }
 ```
 
-Index a multi point in WKT format:
+Index a multipoint in WKT format:
 
 ```json
 PUT testindex/_doc/6
@@ -235,11 +235,11 @@ PUT testindex/_doc/6
 }
 ```
 
-## Multiline string
+## Multilinestring
 
-A multiline string is an array of line strings.
+A multilinestring is an array of linestrings.
 
-Index a multiline string in GeoJSON format:
+Index a multilinestring in GeoJSON format:
 
 ```json
 PUT testindex/_doc/2
@@ -254,7 +254,7 @@ PUT testindex/_doc/2
 }
 ```
 
-Index a line string in WKT format:
+Index a linestring in WKT format:
 
 ```json
 PUT testindex/_doc/2
@@ -263,11 +263,11 @@ PUT testindex/_doc/2
 }
 ```
 
-## Multi polygon
+## Multipolygon
 
-A multi polygon is an array of polygons. In this example, the first polygon contains a hole, and the second does not. 
+A multipolygon is an array of polygons. In this example, the first polygon contains a hole, and the second does not. 
 
-Index a multi polygon in GeoJSON format:
+Index a multipolygon in GeoJSON format:
 
 ```json
 PUT testindex/_doc/4
@@ -297,7 +297,7 @@ PUT testindex/_doc/4
 }
 ```
 
-Index a multi polygon in WKT format:
+Index a multipolygon in WKT format:
 
 ```json
 PUT testindex/_doc/4
@@ -342,7 +342,7 @@ PUT testindex/_doc/7
 
 ## Envelope
 
-An envelope is a bounding rectangle specified by top-left and bottom-right vertices. The GeoJSON format is `[[minX, maxY], [maxX, minY]]`.
+An envelope is a bounding rectangle specified by upper-left and lower-right vertices. The GeoJSON format is `[[minX, maxY], [maxX, minY]]`.
 
 Index an envelope in GeoJSON format:
 
diff --git a/_opensearch/supported-field-types/xy.md b/_opensearch/supported-field-types/xy.md
index aaa942b8f1..79750eefa3 100644
--- a/_opensearch/supported-field-types/xy.md
+++ b/_opensearch/supported-field-types/xy.md
@@ -9,7 +9,7 @@ parent: Supported field types
 
 # Cartesian field types
 
-Cartesian field types facilitate indexing and searching of points and shapes in a two-dimensional Cartesian coordinate system. Cartesian field types are similar to [geographic]({{site.url}}{{site.baseurl}}/opensearch/supported-field-types/geographic/) field types, except they represent points and shapes on the Cartesian plane, which is not based on the earth-fixed terrestrial reference system. Calculating distances on a plane is more efficient than calculating distances on a sphere, so distance sorting is faster for Cartesian field types. 
+Cartesian field types facilitate indexing and searching of points and shapes in a two-dimensional Cartesian coordinate system. Cartesian field types are similar to [geographic]({{site.url}}{{site.baseurl}}/opensearch/supported-field-types/geographic/) field types, except they represent points and shapes on the Cartesian plane, which is not based on the Earth-fixed terrestrial reference system. Calculating distances on a plane is more efficient than calculating distances on a sphere, so distance sorting is faster for Cartesian field types. 
 
 Cartesian field types work well for spatial applications like virtual reality, computer-aided design (CAD), and amusement park and sporting venue mapping. 
 
@@ -17,10 +17,10 @@ The coordinates for the Cartesian field types are single-precision floating-poin
 
 The following table lists all Cartesian field types that OpenSearch supports.
 
-Field data type | Description
+Field Data Type | Description
 :--- | :---  
 [`xy_point`]({{site.url}}{{site.baseurl}}/opensearch/supported-field-types/xy-point/) | A point in a two-dimensional Cartesian coordinate system, specified by x and y coordinates. 
 [`xy_shape`]({{site.url}}{{site.baseurl}}/opensearch/supported-field-types/xy-shape/) | A shape, such as a polygon or a collection of xy points, in a two-dimensional Cartesian coordinate system. 
 
-Currently, OpenSearch supports indexing and searching Cartesian field types, but not aggregations on Cartesian field types. If you'd like to see aggregations implemented, open a [GitHub issue](https://github.com/opensearch-project/geospatial).
+Currently, OpenSearch supports indexing and searching of Cartesian field types but not aggregations on Cartesian field types. If you'd like to see aggregations implemented, open a [GitHub issue](https://github.com/opensearch-project/geospatial).
 {: .note}
\ No newline at end of file