From 40cf8ef604bbdb1a0ddac9966ea9a33927c1cfe9 Mon Sep 17 00:00:00 2001
From: Alison Goryachev <alisonmllr20@gmail.com>
Date: Tue, 14 Jan 2020 14:44:16 -0500
Subject: [PATCH 1/2] add description text for numeric types

---
 .../constants/data_types_definition.tsx       | 100 ++++++++++++++++++
 1 file changed, 100 insertions(+)

diff --git a/x-pack/legacy/plugins/index_management/public/app/components/mappings_editor/constants/data_types_definition.tsx b/x-pack/legacy/plugins/index_management/public/app/components/mappings_editor/constants/data_types_definition.tsx
index b4f599c3efce9..d13b0c4ce685d 100644
--- a/x-pack/legacy/plugins/index_management/public/app/components/mappings_editor/constants/data_types_definition.tsx
+++ b/x-pack/legacy/plugins/index_management/public/app/components/mappings_editor/constants/data_types_definition.tsx
@@ -71,48 +71,148 @@ export const TYPE_DEFINITION: { [key in DataType]: DataTypeDefinition } = {
       defaultMessage: 'Byte',
     }),
     value: 'byte',
+    description: () => (
+      <p>
+        <FormattedMessage
+          id="xpack.idxMgmt.mappingsEditor.dataType.byteLongDescription"
+          defaultMessage="Byte fields accept a signed 8-bit integer with a minimum value of {minValue} and a maximum value of {maxValue}."
+          values={{
+            minValue: <EuiCode>-128</EuiCode>,
+            maxValue: <EuiCode>127</EuiCode>,
+          }}
+        />
+      </p>
+    ),
   },
   double: {
     label: i18n.translate('xpack.idxMgmt.mappingsEditor.dataType.doubleDescription', {
       defaultMessage: 'Double',
     }),
     value: 'double',
+    description: () => (
+      <p>
+        <FormattedMessage
+          id="xpack.idxMgmt.mappingsEditor.dataType.doubleLongDescription"
+          defaultMessage="Double fields accept a double-precision 64-bit floating point number, restricted to finite values (IEEE 754)."
+        />
+      </p>
+    ),
   },
   integer: {
     label: i18n.translate('xpack.idxMgmt.mappingsEditor.dataType.integerDescription', {
       defaultMessage: 'Integer',
     }),
     value: 'integer',
+    description: () => (
+      <p>
+        <FormattedMessage
+          id="xpack.idxMgmt.mappingsEditor.dataType.integerLongDescription"
+          defaultMessage="Integer fields accept a signed 32-bit integer with a minimum value of {minValue} and a maximum value of {maxValue}."
+          values={{
+            minValue: (
+              <EuiCode>
+                -2<sup className="eui-alignTop">31</sup>
+              </EuiCode>
+            ),
+            maxValue: (
+              <EuiCode>
+                2<sup className="eui-alignTop">31</sup>-1
+              </EuiCode>
+            ),
+          }}
+        />
+      </p>
+    ),
   },
   long: {
     label: i18n.translate('xpack.idxMgmt.mappingsEditor.dataType.longDescription', {
       defaultMessage: 'Long',
     }),
     value: 'long',
+    description: () => (
+      <p>
+        <FormattedMessage
+          id="xpack.idxMgmt.mappingsEditor.dataType.longLongDescription"
+          defaultMessage="Long fields accept a signed 64-bit integer with a minimum value of {minValue} and a maximum value of {maxValue}."
+          values={{
+            minValue: (
+              <EuiCode>
+                -2<sup className="eui-alignTop">63</sup>
+              </EuiCode>
+            ),
+            maxValue: (
+              <EuiCode>
+                2<sup className="eui-alignTop">63</sup>-1
+              </EuiCode>
+            ),
+          }}
+        />
+      </p>
+    ),
   },
   float: {
     label: i18n.translate('xpack.idxMgmt.mappingsEditor.dataType.floatDescription', {
       defaultMessage: 'Float',
     }),
     value: 'float',
+    description: () => (
+      <p>
+        <FormattedMessage
+          id="xpack.idxMgmt.mappingsEditor.dataType.floatLongDescription"
+          defaultMessage="Float fields accept a single-precision 32-bit floating point number, restricted to finite values (IEEE 754)."
+        />
+      </p>
+    ),
   },
   half_float: {
     label: i18n.translate('xpack.idxMgmt.mappingsEditor.dataType.halfFloatDescription', {
       defaultMessage: 'Half float',
     }),
     value: 'half_float',
+    description: () => (
+      <p>
+        <FormattedMessage
+          id="xpack.idxMgmt.mappingsEditor.dataType.halfFloatLongDescription"
+          defaultMessage="Half-float fields accept a half-precision 16-bit floating point number, restricted to finite values (IEEE 754)."
+        />
+      </p>
+    ),
   },
   scaled_float: {
     label: i18n.translate('xpack.idxMgmt.mappingsEditor.dataType.scaledFloatDescription', {
       defaultMessage: 'Scaled float',
     }),
     value: 'scaled_float',
+    description: () => (
+      <p>
+        <FormattedMessage
+          id="xpack.idxMgmt.mappingsEditor.dataType.scaledFloatLongDescription"
+          defaultMessage="Scaled-float fields accept a floating point number that is backed by a {longType} and scaled by a fixed {doubleType} scaling factor. Use this data type to store floating-point data into an integer using a scaling factor. This is helpful to save disk space, but will affect accuracy."
+          values={{
+            longType: <EuiCode>long</EuiCode>,
+            doubleType: <EuiCode>double</EuiCode>,
+          }}
+        />
+      </p>
+    ),
   },
   short: {
     label: i18n.translate('xpack.idxMgmt.mappingsEditor.dataType.shortDescription', {
       defaultMessage: 'Short',
     }),
     value: 'short',
+    description: () => (
+      <p>
+        <FormattedMessage
+          id="xpack.idxMgmt.mappingsEditor.dataType.shortLongDescription"
+          defaultMessage="Short fields accept a signed 16-bit integer with a minimum value of {minValue} and a maximum value of {maxValue}."
+          values={{
+            minValue: <EuiCode>-32,768</EuiCode>,
+            maxValue: <EuiCode>32,767</EuiCode>,
+          }}
+        />
+      </p>
+    ),
   },
   date: {
     label: i18n.translate('xpack.idxMgmt.mappingsEditor.dataType.dateDescription', {

From 7d45742b76236829a7dbdc002e926d737ba0a106 Mon Sep 17 00:00:00 2001
From: Alison Goryachev <alisonmllr20@gmail.com>
Date: Tue, 14 Jan 2020 16:06:44 -0500
Subject: [PATCH 2/2] address review feedback

---
 .../mappings_editor/constants/data_types_definition.tsx         | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/x-pack/legacy/plugins/index_management/public/app/components/mappings_editor/constants/data_types_definition.tsx b/x-pack/legacy/plugins/index_management/public/app/components/mappings_editor/constants/data_types_definition.tsx
index d13b0c4ce685d..954236f8144fa 100644
--- a/x-pack/legacy/plugins/index_management/public/app/components/mappings_editor/constants/data_types_definition.tsx
+++ b/x-pack/legacy/plugins/index_management/public/app/components/mappings_editor/constants/data_types_definition.tsx
@@ -187,7 +187,7 @@ export const TYPE_DEFINITION: { [key in DataType]: DataTypeDefinition } = {
       <p>
         <FormattedMessage
           id="xpack.idxMgmt.mappingsEditor.dataType.scaledFloatLongDescription"
-          defaultMessage="Scaled-float fields accept a floating point number that is backed by a {longType} and scaled by a fixed {doubleType} scaling factor. Use this data type to store floating-point data into an integer using a scaling factor. This is helpful to save disk space, but will affect accuracy."
+          defaultMessage="Scaled-float fields accept a floating point number that is backed by a {longType} and scaled by a fixed {doubleType} scaling factor. Use this data type to store floating point data into an integer using a scaling factor. This saves disk space, but affects accuracy."
           values={{
             longType: <EuiCode>long</EuiCode>,
             doubleType: <EuiCode>double</EuiCode>,