[Transform] rename data frame transform to transform for hlrc client (#46933)

rename data frame transform to transform for hlrc

client/rest-high-level/src/main/java/org/elasticsearch/client/RestHighLevelClient.java

@@ -256,7 +256,7 @@ public class RestHighLevelClient implements Closeable {
     private final IndexLifecycleClient ilmClient = new IndexLifecycleClient(this);
     private final RollupClient rollupClient = new RollupClient(this);
     private final CcrClient ccrClient = new CcrClient(this);
-    private final DataFrameClient dataFrameClient = new DataFrameClient(this);
+    private final TransformClient transformClient = new TransformClient(this);
 
     /**
      * Creates a {@link RestHighLevelClient} given the low level {@link RestClientBuilder} that allows to build the
@@ -477,8 +477,8 @@ public class RestHighLevelClient implements Closeable {
      *
      * @return the client wrapper for making Data Frame API calls
      */
-    public DataFrameClient dataFrame() {
-        return dataFrameClient;
+    public TransformClient transform() {
+        return transformClient;
     }
 
     /**

client/rest-high-level/src/main/java/org/elasticsearch/client/TransformClient.java

@@ -21,29 +21,29 @@ package org.elasticsearch.client;
 
 import org.elasticsearch.action.ActionListener;
 import org.elasticsearch.client.core.AcknowledgedResponse;
-import org.elasticsearch.client.transform.DeleteDataFrameTransformRequest;
-import org.elasticsearch.client.transform.GetDataFrameTransformRequest;
-import org.elasticsearch.client.transform.GetDataFrameTransformResponse;
-import org.elasticsearch.client.transform.GetDataFrameTransformStatsRequest;
-import org.elasticsearch.client.transform.GetDataFrameTransformStatsResponse;
-import org.elasticsearch.client.transform.PreviewDataFrameTransformRequest;
-import org.elasticsearch.client.transform.PreviewDataFrameTransformResponse;
-import org.elasticsearch.client.transform.PutDataFrameTransformRequest;
-import org.elasticsearch.client.transform.StartDataFrameTransformRequest;
-import org.elasticsearch.client.transform.StartDataFrameTransformResponse;
-import org.elasticsearch.client.transform.StopDataFrameTransformRequest;
-import org.elasticsearch.client.transform.StopDataFrameTransformResponse;
-import org.elasticsearch.client.transform.UpdateDataFrameTransformRequest;
-import org.elasticsearch.client.transform.UpdateDataFrameTransformResponse;
+import org.elasticsearch.client.transform.DeleteTransformRequest;
+import org.elasticsearch.client.transform.GetTransformRequest;
+import org.elasticsearch.client.transform.GetTransformResponse;
+import org.elasticsearch.client.transform.GetTransformStatsRequest;
+import org.elasticsearch.client.transform.GetTransformStatsResponse;
+import org.elasticsearch.client.transform.PreviewTransformRequest;
+import org.elasticsearch.client.transform.PreviewTransformResponse;
+import org.elasticsearch.client.transform.PutTransformRequest;
+import org.elasticsearch.client.transform.StartTransformRequest;
+import org.elasticsearch.client.transform.StartTransformResponse;
+import org.elasticsearch.client.transform.StopTransformRequest;
+import org.elasticsearch.client.transform.StopTransformResponse;
+import org.elasticsearch.client.transform.UpdateTransformRequest;
+import org.elasticsearch.client.transform.UpdateTransformResponse;
 
 import java.io.IOException;
 import java.util.Collections;
 
-public final class DataFrameClient {
+public final class TransformClient {
 
     private final RestHighLevelClient restHighLevelClient;
 
-    DataFrameClient(RestHighLevelClient restHighLevelClient) {
+    TransformClient(RestHighLevelClient restHighLevelClient) {
         this.restHighLevelClient = restHighLevelClient;
     }
 
@@ -54,15 +54,15 @@ public final class DataFrameClient {
      * see <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/put-transform.html">
      *     Create transform documentation</a>
      *
-     * @param request The PutDataFrameTransformRequest containing the
-     * {@link org.elasticsearch.client.transform.transforms.DataFrameTransformConfig}.
+     * @param request The PutTransformRequest containing the
+     * {@link org.elasticsearch.client.transform.transforms.TransformConfig}.
      * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
      * @return An AcknowledgedResponse object indicating request success
      * @throws IOException when there is a serialization issue sending the request or receiving the response
      */
-    public AcknowledgedResponse putDataFrameTransform(PutDataFrameTransformRequest request, RequestOptions options) throws IOException {
+    public AcknowledgedResponse putTransform(PutTransformRequest request, RequestOptions options) throws IOException {
         return restHighLevelClient.performRequestAndParseEntity(request,
-                DataFrameRequestConverters::putDataFrameTransform,
+                TransformRequestConverters::putTransform,
                 options,
                 AcknowledgedResponse::fromXContent,
                 Collections.emptySet());
@@ -74,16 +74,16 @@ public final class DataFrameClient {
      * For additional info
      * see <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/put-transform.html">
      *     Create transform documentation</a>
-     * @param request The PutDataFrameTransformRequest containing the
-     * {@link org.elasticsearch.client.transform.transforms.DataFrameTransformConfig}.
+     * @param request The PutTransformRequest containing the
+     * {@link org.elasticsearch.client.transform.transforms.TransformConfig}.
      * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
      * @param listener Listener to be notified upon request completion
      * @return cancellable that may be used to cancel the request
      */
-    public Cancellable putDataFrameTransformAsync(PutDataFrameTransformRequest request, RequestOptions options,
+    public Cancellable putTransformAsync(PutTransformRequest request, RequestOptions options,
                                          ActionListener<AcknowledgedResponse> listener) {
         return restHighLevelClient.performRequestAsyncAndParseEntity(request,
-                DataFrameRequestConverters::putDataFrameTransform,
+                TransformRequestConverters::putTransform,
                 options,
                 AcknowledgedResponse::fromXContent,
                 listener,
@@ -97,18 +97,18 @@ public final class DataFrameClient {
      * see <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/update-transform.html">
      *     Create transform documentation</a>
      *
-     * @param request The UpdateDataFrameTransformRequest containing the
-     * {@link org.elasticsearch.client.transform.transforms.DataFrameTransformConfigUpdate}.
+     * @param request The UpdateTransformRequest containing the
+     * {@link org.elasticsearch.client.transform.transforms.TransformConfigUpdate}.
      * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
-     * @return An UpdateDataFrameTransformResponse object containing the updated configuration
+     * @return An UpdateTransformResponse object containing the updated configuration
      * @throws IOException when there is a serialization issue sending the request or receiving the response
      */
-    public UpdateDataFrameTransformResponse updateDataFrameTransform(UpdateDataFrameTransformRequest request,
+    public UpdateTransformResponse updateTransform(UpdateTransformRequest request,
                                                    RequestOptions options) throws IOException {
         return restHighLevelClient.performRequestAndParseEntity(request,
-            DataFrameRequestConverters::updateDataFrameTransform,
+            TransformRequestConverters::updateTransform,
             options,
-            UpdateDataFrameTransformResponse::fromXContent,
+            UpdateTransformResponse::fromXContent,
             Collections.emptySet());
     }
 
@@ -118,19 +118,19 @@ public final class DataFrameClient {
      * For additional info
      * see <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/update-transform.html">
      *     Create transform documentation</a>
-     * @param request The UpdateDataFrameTransformRequest containing the
-     * {@link org.elasticsearch.client.transform.transforms.DataFrameTransformConfigUpdate}.
+     * @param request The UpdateTransformRequest containing the
+     * {@link org.elasticsearch.client.transform.transforms.TransformConfigUpdate}.
      * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
      * @param listener Listener to be notified upon request completion
      * @return cancellable that may be used to cancel the request
      */
-    public Cancellable updateDataFrameTransformAsync(UpdateDataFrameTransformRequest request,
+    public Cancellable updateTransformAsync(UpdateTransformRequest request,
                                             RequestOptions options,
-                                                     ActionListener<UpdateDataFrameTransformResponse> listener) {
+                                            ActionListener<UpdateTransformResponse> listener) {
         return restHighLevelClient.performRequestAsyncAndParseEntity(request,
-            DataFrameRequestConverters::updateDataFrameTransform,
+            TransformRequestConverters::updateTransform,
             options,
-            UpdateDataFrameTransformResponse::fromXContent,
+            UpdateTransformResponse::fromXContent,
             listener,
             Collections.emptySet());
     }
@@ -142,17 +142,17 @@ public final class DataFrameClient {
      * see <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/get-transform-stats.html">
      *     Get transform stats documentation</a>
      *
-     * @param request Specifies the which transforms to get the stats for
+     * @param request Specifies which transforms to get the stats for
      * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
      * @return The transform stats
      * @throws IOException when there is a serialization issue sending the request or receiving the response
      */
-    public GetDataFrameTransformStatsResponse getDataFrameTransformStats(GetDataFrameTransformStatsRequest request, RequestOptions options)
+    public GetTransformStatsResponse getTransformStats(GetTransformStatsRequest request, RequestOptions options)
             throws IOException {
         return restHighLevelClient.performRequestAndParseEntity(request,
-                DataFrameRequestConverters::getDataFrameTransformStats,
+                TransformRequestConverters::getTransformStats,
                 options,
-                GetDataFrameTransformStatsResponse::fromXContent,
+                GetTransformStatsResponse::fromXContent,
                 Collections.emptySet());
     }
 
@@ -162,17 +162,17 @@ public final class DataFrameClient {
      * For additional info
      * see <a href="https://www.elastic.co/guide/en/elasticsearch/reference/current/get-transform-stats.html">
      *     Get transform stats documentation</a>
-     * @param request Specifies the which transforms to get the stats for
+     * @param request Specifies which transforms to get the stats for
      * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
      * @param listener Listener to be notified upon request completion
      * @return cancellable that may be used to cancel the request
      */
-    public Cancellable getDataFrameTransformStatsAsync(GetDataFrameTransformStatsRequest request, RequestOptions options,
-                                                       ActionListener<GetDataFrameTransformStatsResponse> listener) {
+    public Cancellable getTransformStatsAsync(GetTransformStatsRequest request, RequestOptions options,
+                                              ActionListener<GetTransformStatsResponse> listener) {
         return restHighLevelClient.performRequestAsyncAndParseEntity(request,
-                DataFrameRequestConverters::getDataFrameTransformStats,
+                TransformRequestConverters::getTransformStats,
                 options,
-                GetDataFrameTransformStatsResponse::fromXContent,
+                GetTransformStatsResponse::fromXContent,
                 listener,
                 Collections.emptySet());
     }
@@ -189,10 +189,10 @@ public final class DataFrameClient {
      * @return An AcknowledgedResponse object indicating request success
      * @throws IOException when there is a serialization issue sending the request or receiving the response
      */
-    public AcknowledgedResponse deleteDataFrameTransform(DeleteDataFrameTransformRequest request, RequestOptions options)
+    public AcknowledgedResponse deleteTransform(DeleteTransformRequest request, RequestOptions options)
             throws IOException {
         return restHighLevelClient.performRequestAndParseEntity(request,
-                DataFrameRequestConverters::deleteDataFrameTransform,
+                TransformRequestConverters::deleteTransform,
                 options,
                 AcknowledgedResponse::fromXContent,
                 Collections.emptySet());
@@ -209,10 +209,10 @@ public final class DataFrameClient {
      * @param listener Listener to be notified upon request completion
      * @return cancellable that may be used to cancel the request
      */
-    public Cancellable deleteDataFrameTransformAsync(DeleteDataFrameTransformRequest request, RequestOptions options,
+    public Cancellable deleteTransformAsync(DeleteTransformRequest request, RequestOptions options,
                                             ActionListener<AcknowledgedResponse> listener) {
         return restHighLevelClient.performRequestAsyncAndParseEntity(request,
-                DataFrameRequestConverters::deleteDataFrameTransform,
+                TransformRequestConverters::deleteTransform,
                 options,
                 AcknowledgedResponse::fromXContent,
                 listener,
@@ -231,12 +231,12 @@ public final class DataFrameClient {
      * @return A response containing the results of the applied transform
      * @throws IOException when there is a serialization issue sending the request or receiving the response
      */
-    public PreviewDataFrameTransformResponse previewDataFrameTransform(PreviewDataFrameTransformRequest request, RequestOptions options)
+    public PreviewTransformResponse previewTransform(PreviewTransformRequest request, RequestOptions options)
             throws IOException {
         return restHighLevelClient.performRequestAndParseEntity(request,
-                DataFrameRequestConverters::previewDataFrameTransform,
+                TransformRequestConverters::previewTransform,
                 options,
-                PreviewDataFrameTransformResponse::fromXContent,
+                PreviewTransformResponse::fromXContent,
                 Collections.emptySet());
     }
 
@@ -250,12 +250,12 @@ public final class DataFrameClient {
      * @param listener Listener to be notified upon request completion
      * @return cancellable that may be used to cancel the request
      */
-    public Cancellable previewDataFrameTransformAsync(PreviewDataFrameTransformRequest request, RequestOptions options,
-                                                      ActionListener<PreviewDataFrameTransformResponse> listener) {
+    public Cancellable previewTransformAsync(PreviewTransformRequest request, RequestOptions options,
+                                             ActionListener<PreviewTransformResponse> listener) {
         return restHighLevelClient.performRequestAsyncAndParseEntity(request,
-                DataFrameRequestConverters::previewDataFrameTransform,
+                TransformRequestConverters::previewTransform,
                 options,
-                PreviewDataFrameTransformResponse::fromXContent,
+                PreviewTransformResponse::fromXContent,
                 listener,
                 Collections.emptySet());
     }
@@ -272,12 +272,12 @@ public final class DataFrameClient {
      * @return A response object indicating request success
      * @throws IOException when there is a serialization issue sending the request or receiving the response
      */
-    public StartDataFrameTransformResponse startDataFrameTransform(StartDataFrameTransformRequest request, RequestOptions options)
+    public StartTransformResponse startTransform(StartTransformRequest request, RequestOptions options)
             throws IOException {
         return restHighLevelClient.performRequestAndParseEntity(request,
-                DataFrameRequestConverters::startDataFrameTransform,
+                TransformRequestConverters::startTransform,
                 options,
-                StartDataFrameTransformResponse::fromXContent,
+                StartTransformResponse::fromXContent,
                 Collections.emptySet());
     }
 
@@ -292,12 +292,12 @@ public final class DataFrameClient {
      * @param listener Listener to be notified upon request completion
      * @return cancellable that may be used to cancel the request
      */
-    public Cancellable startDataFrameTransformAsync(StartDataFrameTransformRequest request, RequestOptions options,
-                                                    ActionListener<StartDataFrameTransformResponse> listener) {
+    public Cancellable startTransformAsync(StartTransformRequest request, RequestOptions options,
+                                           ActionListener<StartTransformResponse> listener) {
         return restHighLevelClient.performRequestAsyncAndParseEntity(request,
-                DataFrameRequestConverters::startDataFrameTransform,
+                TransformRequestConverters::startTransform,
                 options,
-                StartDataFrameTransformResponse::fromXContent,
+                StartTransformResponse::fromXContent,
                 listener,
                 Collections.emptySet());
     }
@@ -314,12 +314,12 @@ public final class DataFrameClient {
      * @return A response object indicating request success
      * @throws IOException when there is a serialization issue sending the request or receiving the response
      */
-    public StopDataFrameTransformResponse stopDataFrameTransform(StopDataFrameTransformRequest request, RequestOptions options)
+    public StopTransformResponse stopTransform(StopTransformRequest request, RequestOptions options)
             throws IOException {
         return restHighLevelClient.performRequestAndParseEntity(request,
-                DataFrameRequestConverters::stopDataFrameTransform,
+                TransformRequestConverters::stopTransform,
                 options,
-                StopDataFrameTransformResponse::fromXContent,
+                StopTransformResponse::fromXContent,
                 Collections.emptySet());
     }
 
@@ -334,12 +334,12 @@ public final class DataFrameClient {
      * @param listener Listener to be notified upon request completion
      * @return cancellable that may be used to cancel the request
      */
-    public Cancellable stopDataFrameTransformAsync(StopDataFrameTransformRequest request, RequestOptions options,
-                                                   ActionListener<StopDataFrameTransformResponse> listener) {
+    public Cancellable stopTransformAsync(StopTransformRequest request, RequestOptions options,
+                                          ActionListener<StopTransformResponse> listener) {
         return restHighLevelClient.performRequestAsyncAndParseEntity(request,
-                DataFrameRequestConverters::stopDataFrameTransform,
+                TransformRequestConverters::stopTransform,
                 options,
-                StopDataFrameTransformResponse::fromXContent,
+                StopTransformResponse::fromXContent,
                 listener,
                 Collections.emptySet());
     }
@@ -353,15 +353,15 @@ public final class DataFrameClient {
      *
      * @param request The get transform request
      * @param options Additional request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
-     * @return An GetDataFrameTransformResponse containing the requested transforms
+     * @return An GetTransformResponse containing the requested transforms
      * @throws IOException when there is a serialization issue sending the request or receiving the response
      */
-    public GetDataFrameTransformResponse getDataFrameTransform(GetDataFrameTransformRequest request, RequestOptions options)
+    public GetTransformResponse getTransform(GetTransformRequest request, RequestOptions options)
             throws IOException {
         return restHighLevelClient.performRequestAndParseEntity(request,
-                DataFrameRequestConverters::getDataFrameTransform,
+                TransformRequestConverters::getTransform,
                 options,
-                GetDataFrameTransformResponse::fromXContent,
+                GetTransformResponse::fromXContent,
                 Collections.emptySet());
     }
 
@@ -376,12 +376,12 @@ public final class DataFrameClient {
      * @param listener Listener to be notified upon request completion
      * @return cancellable that may be used to cancel the request
      */
-    public Cancellable getDataFrameTransformAsync(GetDataFrameTransformRequest request, RequestOptions options,
-                                                  ActionListener<GetDataFrameTransformResponse> listener) {
+    public Cancellable getTransformAsync(GetTransformRequest request, RequestOptions options,
+                                         ActionListener<GetTransformResponse> listener) {
         return restHighLevelClient.performRequestAsyncAndParseEntity(request,
-                DataFrameRequestConverters::getDataFrameTransform,
+                TransformRequestConverters::getTransform,
                 options,
-                GetDataFrameTransformResponse::fromXContent,
+                GetTransformResponse::fromXContent,
                 listener,
                 Collections.emptySet());
     }

client/rest-high-level/src/main/java/org/elasticsearch/client/TransformRequestConverters.java

@@ -24,29 +24,29 @@ import org.apache.http.client.methods.HttpGet;
 import org.apache.http.client.methods.HttpPost;
 import org.apache.http.client.methods.HttpPut;
 import org.elasticsearch.client.core.PageParams;
-import org.elasticsearch.client.transform.DeleteDataFrameTransformRequest;
-import org.elasticsearch.client.transform.GetDataFrameTransformRequest;
-import org.elasticsearch.client.transform.GetDataFrameTransformStatsRequest;
-import org.elasticsearch.client.transform.PreviewDataFrameTransformRequest;
-import org.elasticsearch.client.transform.PutDataFrameTransformRequest;
-import org.elasticsearch.client.transform.StartDataFrameTransformRequest;
-import org.elasticsearch.client.transform.StopDataFrameTransformRequest;
-import org.elasticsearch.client.transform.UpdateDataFrameTransformRequest;
+import org.elasticsearch.client.transform.DeleteTransformRequest;
+import org.elasticsearch.client.transform.GetTransformRequest;
+import org.elasticsearch.client.transform.GetTransformStatsRequest;
+import org.elasticsearch.client.transform.PreviewTransformRequest;
+import org.elasticsearch.client.transform.PutTransformRequest;
+import org.elasticsearch.client.transform.StartTransformRequest;
+import org.elasticsearch.client.transform.StopTransformRequest;
+import org.elasticsearch.client.transform.UpdateTransformRequest;
 import org.elasticsearch.common.Strings;
 
 import java.io.IOException;
 
 import static org.elasticsearch.client.RequestConverters.REQUEST_BODY_CONTENT_TYPE;
 import static org.elasticsearch.client.RequestConverters.createEntity;
-import static org.elasticsearch.client.transform.DeleteDataFrameTransformRequest.FORCE;
-import static org.elasticsearch.client.transform.GetDataFrameTransformRequest.ALLOW_NO_MATCH;
-import static org.elasticsearch.client.transform.PutDataFrameTransformRequest.DEFER_VALIDATION;
+import static org.elasticsearch.client.transform.DeleteTransformRequest.FORCE;
+import static org.elasticsearch.client.transform.GetTransformRequest.ALLOW_NO_MATCH;
+import static org.elasticsearch.client.transform.PutTransformRequest.DEFER_VALIDATION;
 
-final class DataFrameRequestConverters {
+final class TransformRequestConverters {
 
-    private DataFrameRequestConverters() {}
+    private TransformRequestConverters() {}
 
-    static Request putDataFrameTransform(PutDataFrameTransformRequest putRequest) throws IOException {
+    static Request putTransform(PutTransformRequest putRequest) throws IOException {
         String endpoint = new RequestConverters.EndpointBuilder()
                 .addPathPartAsIs("_data_frame", "transforms")
                 .addPathPart(putRequest.getConfig().getId())
@@ -59,7 +59,7 @@ final class DataFrameRequestConverters {
         return request;
     }
 
-    static Request updateDataFrameTransform(UpdateDataFrameTransformRequest updateDataFrameTransformRequest) throws IOException {
+    static Request updateTransform(UpdateTransformRequest updateDataFrameTransformRequest) throws IOException {
         String endpoint = new RequestConverters.EndpointBuilder()
             .addPathPartAsIs("_data_frame", "transforms")
             .addPathPart(updateDataFrameTransformRequest.getId())
@@ -73,7 +73,7 @@ final class DataFrameRequestConverters {
         return request;
     }
 
-    static Request getDataFrameTransform(GetDataFrameTransformRequest getRequest) {
+    static Request getTransform(GetTransformRequest getRequest) {
         String endpoint = new RequestConverters.EndpointBuilder()
                 .addPathPartAsIs("_data_frame", "transforms")
                 .addPathPart(Strings.collectionToCommaDelimitedString(getRequest.getId()))
@@ -91,7 +91,7 @@ final class DataFrameRequestConverters {
         return request;
     }
 
-    static Request deleteDataFrameTransform(DeleteDataFrameTransformRequest deleteRequest) {
+    static Request deleteTransform(DeleteTransformRequest deleteRequest) {
         String endpoint = new RequestConverters.EndpointBuilder()
                 .addPathPartAsIs("_data_frame", "transforms")
                 .addPathPart(deleteRequest.getId())
@@ -103,7 +103,7 @@ final class DataFrameRequestConverters {
         return request;
     }
 
-    static Request startDataFrameTransform(StartDataFrameTransformRequest startRequest) {
+    static Request startTransform(StartTransformRequest startRequest) {
         String endpoint = new RequestConverters.EndpointBuilder()
                 .addPathPartAsIs("_data_frame", "transforms")
                 .addPathPart(startRequest.getId())
@@ -118,7 +118,7 @@ final class DataFrameRequestConverters {
         return request;
     }
 
-    static Request stopDataFrameTransform(StopDataFrameTransformRequest stopRequest) {
+    static Request stopTransform(StopTransformRequest stopRequest) {
         String endpoint = new RequestConverters.EndpointBuilder()
             .addPathPartAsIs("_data_frame", "transforms")
             .addPathPart(stopRequest.getId())
@@ -139,7 +139,7 @@ final class DataFrameRequestConverters {
         return request;
     }
 
-    static Request previewDataFrameTransform(PreviewDataFrameTransformRequest previewRequest) throws IOException {
+    static Request previewTransform(PreviewTransformRequest previewRequest) throws IOException {
         String endpoint = new RequestConverters.EndpointBuilder()
                 .addPathPartAsIs("_data_frame", "transforms", "_preview")
                 .build();
@@ -148,7 +148,7 @@ final class DataFrameRequestConverters {
         return request;
     }
 
-    static Request getDataFrameTransformStats(GetDataFrameTransformStatsRequest statsRequest) {
+    static Request getTransformStats(GetTransformStatsRequest statsRequest) {
         String endpoint = new RequestConverters.EndpointBuilder()
                 .addPathPartAsIs("_data_frame", "transforms")
                 .addPathPart(statsRequest.getId())

client/rest-high-level/src/main/java/org/elasticsearch/client/transform/DeleteTransformRequest.java

@@ -27,16 +27,16 @@ import java.util.Optional;
 
 
 /**
- * Request to delete a data frame transform
+ * Request to delete a transform
  */
-public class DeleteDataFrameTransformRequest implements Validatable {
+public class DeleteTransformRequest implements Validatable {
 
     public static final String FORCE = "force";
 
     private final String id;
     private Boolean force;
 
-    public DeleteDataFrameTransformRequest(String id) {
+    public DeleteTransformRequest(String id) {
         this.id = id;
     }
 
@@ -56,7 +56,7 @@ public class DeleteDataFrameTransformRequest implements Validatable {
     public Optional<ValidationException> validate() {
         if (id == null) {
             ValidationException validationException = new ValidationException();
-            validationException.addValidationError("data frame transform id must not be null");
+            validationException.addValidationError("transform id must not be null");
             return Optional.of(validationException);
         } else {
             return Optional.empty();
@@ -77,7 +77,7 @@ public class DeleteDataFrameTransformRequest implements Validatable {
         if (obj == null || getClass() != obj.getClass()) {
             return false;
         }
-        DeleteDataFrameTransformRequest other = (DeleteDataFrameTransformRequest) obj;
+        DeleteTransformRequest other = (DeleteTransformRequest) obj;
         return Objects.equals(id, other.id) && Objects.equals(force, other.force);
     }
 }

client/rest-high-level/src/main/java/org/elasticsearch/client/transform/GetTransformRequest.java

@@ -28,22 +28,22 @@ import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
 
-public class GetDataFrameTransformRequest implements Validatable {
+public class GetTransformRequest implements Validatable {
 
     public static final String ALLOW_NO_MATCH = "allow_no_match";
     /**
-     * Helper method to create a request that will get ALL Data Frame Transforms
-     * @return new {@link GetDataFrameTransformRequest} object for the id "_all"
+     * Helper method to create a request that will get ALL Transforms
+     * @return new {@link GetTransformRequest} object for the id "_all"
      */
-    public static GetDataFrameTransformRequest getAllDataFrameTransformsRequest() {
-        return new GetDataFrameTransformRequest("_all");
+    public static GetTransformRequest getAllTransformRequest() {
+        return new GetTransformRequest("_all");
     }
 
     private final List<String> ids;
     private PageParams pageParams;
     private Boolean allowNoMatch;
 
-    public GetDataFrameTransformRequest(String... ids) {
+    public GetTransformRequest(String... ids) {
         this.ids = Arrays.asList(ids);
     }
 
@@ -71,7 +71,7 @@ public class GetDataFrameTransformRequest implements Validatable {
     public Optional<ValidationException> validate() {
         if (ids == null || ids.isEmpty()) {
             ValidationException validationException = new ValidationException();
-            validationException.addValidationError("data frame transform id must not be null");
+            validationException.addValidationError("transform id must not be null");
             return Optional.of(validationException);
         } else {
             return Optional.empty();
@@ -92,7 +92,7 @@ public class GetDataFrameTransformRequest implements Validatable {
         if (obj == null || getClass() != obj.getClass()) {
             return false;
         }
-        GetDataFrameTransformRequest other = (GetDataFrameTransformRequest) obj;
+        GetTransformRequest other = (GetTransformRequest) obj;
         return Objects.equals(ids, other.ids)
             && Objects.equals(pageParams, other.pageParams)
             && Objects.equals(allowNoMatch, other.allowNoMatch);

client/rest-high-level/src/main/java/org/elasticsearch/client/transform/GetTransformResponse.java

@@ -19,7 +19,7 @@
 
 package org.elasticsearch.client.transform;
 
-import org.elasticsearch.client.transform.transforms.DataFrameTransformConfig;
+import org.elasticsearch.client.transform.transforms.TransformConfig;
 import org.elasticsearch.common.Nullable;
 import org.elasticsearch.common.ParseField;
 import org.elasticsearch.common.xcontent.ConstructingObjectParser;
@@ -31,7 +31,7 @@ import java.util.Objects;
 import static org.elasticsearch.common.xcontent.ConstructingObjectParser.constructorArg;
 import static org.elasticsearch.common.xcontent.ConstructingObjectParser.optionalConstructorArg;
 
-public class GetDataFrameTransformResponse {
+public class GetTransformResponse {
 
     public static final ParseField TRANSFORMS = new ParseField("transforms");
     public static final ParseField INVALID_TRANSFORMS = new ParseField("invalid_transforms");
@@ -42,28 +42,28 @@ public class GetDataFrameTransformResponse {
             new ConstructingObjectParser<>("invalid_transforms", true, args -> new InvalidTransforms((List<String>) args[0]));
 
     @SuppressWarnings("unchecked")
-    static final ConstructingObjectParser<GetDataFrameTransformResponse, Void> PARSER = new ConstructingObjectParser<>(
-            "get_data_frame_transform", true, args -> new GetDataFrameTransformResponse(
-                    (List<DataFrameTransformConfig>) args[0], (int) args[1], (InvalidTransforms) args[2]));
+    static final ConstructingObjectParser<GetTransformResponse, Void> PARSER = new ConstructingObjectParser<>(
+            "get_transform", true, args -> new GetTransformResponse(
+                    (List<TransformConfig>) args[0], (int) args[1], (InvalidTransforms) args[2]));
     static {
         // Discard the count field which is the size of the transforms array
         INVALID_TRANSFORMS_PARSER.declareInt((a, b) -> {}, COUNT);
         INVALID_TRANSFORMS_PARSER.declareStringArray(constructorArg(), TRANSFORMS);
 
-        PARSER.declareObjectArray(constructorArg(), DataFrameTransformConfig.PARSER::apply, TRANSFORMS);
+        PARSER.declareObjectArray(constructorArg(), TransformConfig.PARSER::apply, TRANSFORMS);
         PARSER.declareInt(constructorArg(), COUNT);
         PARSER.declareObject(optionalConstructorArg(), INVALID_TRANSFORMS_PARSER::apply, INVALID_TRANSFORMS);
     }
 
-    public static GetDataFrameTransformResponse fromXContent(final XContentParser parser) {
-        return GetDataFrameTransformResponse.PARSER.apply(parser, null);
+    public static GetTransformResponse fromXContent(final XContentParser parser) {
+        return GetTransformResponse.PARSER.apply(parser, null);
     }
 
-    private List<DataFrameTransformConfig> transformConfigurations;
+    private List<TransformConfig> transformConfigurations;
     private int count;
     private InvalidTransforms invalidTransforms;
 
-    public GetDataFrameTransformResponse(List<DataFrameTransformConfig> transformConfigurations,
+    public GetTransformResponse(List<TransformConfig> transformConfigurations,
                                 int count,
                                 @Nullable InvalidTransforms invalidTransforms) {
         this.transformConfigurations = transformConfigurations;
@@ -80,7 +80,7 @@ public class GetDataFrameTransformResponse {
         return count;
     }
 
-    public List<DataFrameTransformConfig> getTransformConfigurations() {
+    public List<TransformConfig> getTransformConfigurations() {
         return transformConfigurations;
     }
 
@@ -99,7 +99,7 @@ public class GetDataFrameTransformResponse {
             return false;
         }
 
-        final GetDataFrameTransformResponse that = (GetDataFrameTransformResponse) other;
+        final GetTransformResponse that = (GetTransformResponse) other;
         return Objects.equals(this.transformConfigurations, that.transformConfigurations)
                 && Objects.equals(this.count, that.count)
                 && Objects.equals(this.invalidTransforms, that.invalidTransforms);

client/rest-high-level/src/main/java/org/elasticsearch/client/transform/GetTransformStatsRequest.java

@@ -26,12 +26,12 @@ import org.elasticsearch.client.core.PageParams;
 import java.util.Objects;
 import java.util.Optional;
 
-public class GetDataFrameTransformStatsRequest implements Validatable {
+public class GetTransformStatsRequest implements Validatable {
     private final String id;
     private PageParams pageParams;
     private Boolean allowNoMatch;
 
-    public GetDataFrameTransformStatsRequest(String id) {
+    public GetTransformStatsRequest(String id) {
         this.id = id;
     }
 
@@ -59,7 +59,7 @@ public class GetDataFrameTransformStatsRequest implements Validatable {
     public Optional<ValidationException> validate() {
         if (id == null) {
             ValidationException validationException = new ValidationException();
-            validationException.addValidationError("data frame transform id must not be null");
+            validationException.addValidationError("transform id must not be null");
             return Optional.of(validationException);
         } else {
             return Optional.empty();
@@ -80,7 +80,7 @@ public class GetDataFrameTransformStatsRequest implements Validatable {
         if (obj == null || getClass() != obj.getClass()) {
             return false;
         }
-        GetDataFrameTransformStatsRequest other = (GetDataFrameTransformStatsRequest) obj;
+        GetTransformStatsRequest other = (GetTransformStatsRequest) obj;
         return Objects.equals(id, other.id)
             && Objects.equals(pageParams, other.pageParams)
             && Objects.equals(allowNoMatch, other.allowNoMatch);

client/rest-high-level/src/main/java/org/elasticsearch/client/transform/GetTransformStatsResponse.java

@@ -21,7 +21,7 @@ package org.elasticsearch.client.transform;
 
 import org.elasticsearch.ElasticsearchException;
 import org.elasticsearch.action.TaskOperationFailure;
-import org.elasticsearch.client.transform.transforms.DataFrameTransformStats;
+import org.elasticsearch.client.transform.transforms.TransformStats;
 import org.elasticsearch.common.Nullable;
 import org.elasticsearch.common.ParseField;
 import org.elasticsearch.common.xcontent.ConstructingObjectParser;
@@ -34,19 +34,19 @@ import java.util.Objects;
 import static org.elasticsearch.common.xcontent.ConstructingObjectParser.constructorArg;
 import static org.elasticsearch.common.xcontent.ConstructingObjectParser.optionalConstructorArg;
 
-public class GetDataFrameTransformStatsResponse {
+public class GetTransformStatsResponse {
 
     public static final ParseField TRANSFORMS = new ParseField("transforms");
     public static final ParseField COUNT = new ParseField("count");
 
     @SuppressWarnings("unchecked")
-    static final ConstructingObjectParser<GetDataFrameTransformStatsResponse, Void> PARSER = new ConstructingObjectParser<>(
-            "get_data_frame_transform_stats_response", true,
-            args -> new GetDataFrameTransformStatsResponse((List<DataFrameTransformStats>) args[0],
+    static final ConstructingObjectParser<GetTransformStatsResponse, Void> PARSER = new ConstructingObjectParser<>(
+            "get_transform_stats_response", true,
+            args -> new GetTransformStatsResponse((List<TransformStats>) args[0],
                     (List<TaskOperationFailure>) args[1], (List<ElasticsearchException>) args[2]));
 
     static {
-        PARSER.declareObjectArray(constructorArg(), DataFrameTransformStats.PARSER::apply, TRANSFORMS);
+        PARSER.declareObjectArray(constructorArg(), TransformStats.PARSER::apply, TRANSFORMS);
         // Discard the count field which is the size of the transforms array
         PARSER.declareInt((a, b) -> {}, COUNT);
         PARSER.declareObjectArray(optionalConstructorArg(), (p, c) -> TaskOperationFailure.fromXContent(p),
@@ -55,15 +55,15 @@ public class GetDataFrameTransformStatsResponse {
                 AcknowledgedTasksResponse.NODE_FAILURES);
     }
 
-    public static GetDataFrameTransformStatsResponse fromXContent(final XContentParser parser) {
-        return GetDataFrameTransformStatsResponse.PARSER.apply(parser, null);
+    public static GetTransformStatsResponse fromXContent(final XContentParser parser) {
+        return GetTransformStatsResponse.PARSER.apply(parser, null);
     }
 
-    private final List<DataFrameTransformStats> transformsStats;
+    private final List<TransformStats> transformsStats;
     private final List<TaskOperationFailure> taskFailures;
     private final List<ElasticsearchException> nodeFailures;
 
-    public GetDataFrameTransformStatsResponse(List<DataFrameTransformStats> transformsStats,
+    public GetTransformStatsResponse(List<TransformStats> transformsStats,
                                               @Nullable List<TaskOperationFailure> taskFailures,
                                               @Nullable List<? extends ElasticsearchException> nodeFailures) {
         this.transformsStats = transformsStats;
@@ -71,7 +71,7 @@ public class GetDataFrameTransformStatsResponse {
         this.nodeFailures = nodeFailures == null ? Collections.emptyList() : Collections.unmodifiableList(nodeFailures);
     }
 
-    public List<DataFrameTransformStats> getTransformsStats() {
+    public List<TransformStats> getTransformsStats() {
         return transformsStats;
     }
 
@@ -98,7 +98,7 @@ public class GetDataFrameTransformStatsResponse {
             return false;
         }
 
-        final GetDataFrameTransformStatsResponse that = (GetDataFrameTransformStatsResponse) other;
+        final GetTransformStatsResponse that = (GetTransformStatsResponse) other;
         return Objects.equals(this.transformsStats, that.transformsStats)
                 && Objects.equals(this.nodeFailures, that.nodeFailures)
                 && Objects.equals(this.taskFailures, that.taskFailures);

client/rest-high-level/src/main/java/org/elasticsearch/client/transform/PreviewTransformRequest.java

@@ -21,7 +21,7 @@ package org.elasticsearch.client.transform;
 
 import org.elasticsearch.client.Validatable;
 import org.elasticsearch.client.ValidationException;
-import org.elasticsearch.client.transform.transforms.DataFrameTransformConfig;
+import org.elasticsearch.client.transform.transforms.TransformConfig;
 import org.elasticsearch.common.xcontent.ToXContent;
 import org.elasticsearch.common.xcontent.ToXContentObject;
 import org.elasticsearch.common.xcontent.XContentBuilder;
@@ -30,15 +30,15 @@ import java.io.IOException;
 import java.util.Objects;
 import java.util.Optional;
 
-public class PreviewDataFrameTransformRequest implements ToXContentObject, Validatable {
+public class PreviewTransformRequest implements ToXContentObject, Validatable {
 
-    private final DataFrameTransformConfig config;
+    private final TransformConfig config;
 
-    public PreviewDataFrameTransformRequest(DataFrameTransformConfig config) {
+    public PreviewTransformRequest(TransformConfig config) {
         this.config = config;
     }
 
-    public DataFrameTransformConfig getConfig() {
+    public TransformConfig getConfig() {
         return config;
     }
 
@@ -51,11 +51,11 @@ public class PreviewDataFrameTransformRequest implements ToXContentObject, Valid
     public Optional<ValidationException> validate() {
         ValidationException validationException = new ValidationException();
         if (config == null) {
-            validationException.addValidationError("preview requires a non-null data frame config");
+            validationException.addValidationError("preview requires a non-null transform config");
             return Optional.of(validationException);
         } else {
             if (config.getSource() == null) {
-                validationException.addValidationError("data frame transform source cannot be null");
+                validationException.addValidationError("transform source cannot be null");
             }
         }
 
@@ -79,7 +79,7 @@ public class PreviewDataFrameTransformRequest implements ToXContentObject, Valid
         if (getClass() != obj.getClass()) {
             return false;
         }
-        PreviewDataFrameTransformRequest other = (PreviewDataFrameTransformRequest) obj;
+        PreviewTransformRequest other = (PreviewTransformRequest) obj;
         return Objects.equals(config, other.config);
     }
 }

client/rest-high-level/src/main/java/org/elasticsearch/client/transform/PreviewTransformResponse.java

@@ -26,23 +26,23 @@ import java.util.List;
 import java.util.Map;
 import java.util.Objects;
 
-public class PreviewDataFrameTransformResponse {
+public class PreviewTransformResponse {
 
     private static final String PREVIEW = "preview";
     private static final String MAPPINGS = "mappings";
 
     @SuppressWarnings("unchecked")
-    public static PreviewDataFrameTransformResponse fromXContent(final XContentParser parser) throws IOException {
+    public static PreviewTransformResponse fromXContent(final XContentParser parser) throws IOException {
         Map<String, Object> previewMap = parser.mapOrdered();
         Object previewDocs = previewMap.get(PREVIEW);
         Object mappings = previewMap.get(MAPPINGS);
-        return new PreviewDataFrameTransformResponse((List<Map<String, Object>>) previewDocs, (Map<String, Object>) mappings);
+        return new PreviewTransformResponse((List<Map<String, Object>>) previewDocs, (Map<String, Object>) mappings);
     }
 
     private List<Map<String, Object>> docs;
     private Map<String, Object> mappings;
 
-    public PreviewDataFrameTransformResponse(List<Map<String, Object>> docs, Map<String, Object> mappings) {
+    public PreviewTransformResponse(List<Map<String, Object>> docs, Map<String, Object> mappings) {
         this.docs = docs;
         this.mappings = mappings;
     }
@@ -65,7 +65,7 @@ public class PreviewDataFrameTransformResponse {
             return false;
         }
 
-        PreviewDataFrameTransformResponse other = (PreviewDataFrameTransformResponse) obj;
+        PreviewTransformResponse other = (PreviewTransformResponse) obj;
         return Objects.equals(other.docs, docs) && Objects.equals(other.mappings, mappings);
     }
 

client/rest-high-level/src/main/java/org/elasticsearch/client/transform/PutTransformRequest.java

@@ -21,7 +21,7 @@ package org.elasticsearch.client.transform;
 
 import org.elasticsearch.client.Validatable;
 import org.elasticsearch.client.ValidationException;
-import org.elasticsearch.client.transform.transforms.DataFrameTransformConfig;
+import org.elasticsearch.client.transform.transforms.TransformConfig;
 import org.elasticsearch.common.xcontent.ToXContentObject;
 import org.elasticsearch.common.xcontent.XContentBuilder;
 
@@ -29,17 +29,17 @@ import java.io.IOException;
 import java.util.Objects;
 import java.util.Optional;
 
-public class PutDataFrameTransformRequest implements ToXContentObject, Validatable {
+public class PutTransformRequest implements ToXContentObject, Validatable {
 
     public static final String DEFER_VALIDATION = "defer_validation";
-    private final DataFrameTransformConfig config;
+    private final TransformConfig config;
     private Boolean deferValidation;
 
-    public PutDataFrameTransformRequest(DataFrameTransformConfig config) {
+    public PutTransformRequest(TransformConfig config) {
         this.config = config;
     }
 
-    public DataFrameTransformConfig getConfig() {
+    public TransformConfig getConfig() {
         return config;
     }
 
@@ -60,17 +60,17 @@ public class PutDataFrameTransformRequest implements ToXContentObject, Validatab
     public Optional<ValidationException> validate() {
         ValidationException validationException = new ValidationException();
         if (config == null) {
-            validationException.addValidationError("put requires a non-null data frame config");
+            validationException.addValidationError("put requires a non-null transform config");
             return Optional.of(validationException);
         } else {
             if (config.getId() == null) {
-                validationException.addValidationError("data frame transform id cannot be null");
+                validationException.addValidationError("transform id cannot be null");
             }
             if (config.getSource() == null) {
-                validationException.addValidationError("data frame transform source cannot be null");
+                validationException.addValidationError("transform source cannot be null");
             }
             if (config.getDestination() == null) {
-                validationException.addValidationError("data frame transform destination cannot be null");
+                validationException.addValidationError("transform destination cannot be null");
             }
         }
 
@@ -99,7 +99,7 @@ public class PutDataFrameTransformRequest implements ToXContentObject, Validatab
         if (getClass() != obj.getClass()) {
             return false;
         }
-        PutDataFrameTransformRequest other = (PutDataFrameTransformRequest) obj;
+        PutTransformRequest other = (PutTransformRequest) obj;
         return Objects.equals(config, other.config);
     }
 }

client/rest-high-level/src/main/java/org/elasticsearch/client/transform/StartTransformRequest.java

@@ -26,16 +26,16 @@ import org.elasticsearch.common.unit.TimeValue;
 import java.util.Objects;
 import java.util.Optional;
 
-public class StartDataFrameTransformRequest implements Validatable {
+public class StartTransformRequest implements Validatable {
 
     private final String id;
     private TimeValue timeout;
 
-    public StartDataFrameTransformRequest(String id) {
+    public StartTransformRequest(String id) {
         this.id = id;
     }
 
-    public StartDataFrameTransformRequest(String id, TimeValue timeout) {
+    public StartTransformRequest(String id, TimeValue timeout) {
         this.id = id;
         this.timeout = timeout;
     }
@@ -56,7 +56,7 @@ public class StartDataFrameTransformRequest implements Validatable {
     public Optional<ValidationException> validate() {
         if (id == null) {
             ValidationException validationException = new ValidationException();
-            validationException.addValidationError("data frame transform id must not be null");
+            validationException.addValidationError("transform id must not be null");
             return Optional.of(validationException);
         } else {
             return Optional.empty();
@@ -77,7 +77,7 @@ public class StartDataFrameTransformRequest implements Validatable {
         if (obj == null || getClass() != obj.getClass()) {
             return false;
         }
-        StartDataFrameTransformRequest other = (StartDataFrameTransformRequest) obj;
+        StartTransformRequest other = (StartTransformRequest) obj;
         return Objects.equals(this.id, other.id)
                 && Objects.equals(this.timeout, other.timeout);
     }

client/rest-high-level/src/main/java/org/elasticsearch/client/transform/StartTransformResponse.java

@@ -28,19 +28,19 @@ import org.elasticsearch.common.xcontent.XContentParser;
 import java.io.IOException;
 import java.util.List;
 
-public class StartDataFrameTransformResponse extends AcknowledgedTasksResponse {
+public class StartTransformResponse extends AcknowledgedTasksResponse {
 
     private static final String ACKNOWLEDGED = "acknowledged";
 
-    private static final ConstructingObjectParser<StartDataFrameTransformResponse, Void> PARSER =
-            AcknowledgedTasksResponse.generateParser("start_data_frame_transform_response", StartDataFrameTransformResponse::new,
+    private static final ConstructingObjectParser<StartTransformResponse, Void> PARSER =
+            AcknowledgedTasksResponse.generateParser("start_transform_response", StartTransformResponse::new,
                     ACKNOWLEDGED);
 
-    public static StartDataFrameTransformResponse fromXContent(final XContentParser parser) throws IOException {
+    public static StartTransformResponse fromXContent(final XContentParser parser) throws IOException {
         return PARSER.parse(parser, null);
     }
 
-    public StartDataFrameTransformResponse(boolean acknowledged, @Nullable List<TaskOperationFailure> taskFailures,
+    public StartTransformResponse(boolean acknowledged, @Nullable List<TaskOperationFailure> taskFailures,
                                   @Nullable List<? extends ElasticsearchException> nodeFailures) {
         super(acknowledged, taskFailures, nodeFailures);
     }

client/rest-high-level/src/main/java/org/elasticsearch/client/transform/StopTransformRequest.java

@@ -26,20 +26,20 @@ import org.elasticsearch.common.unit.TimeValue;
 import java.util.Objects;
 import java.util.Optional;
 
-public class StopDataFrameTransformRequest implements Validatable {
+public class StopTransformRequest implements Validatable {
 
     private final String id;
     private Boolean waitForCompletion;
     private TimeValue timeout;
     private Boolean allowNoMatch;
 
-    public StopDataFrameTransformRequest(String id) {
+    public StopTransformRequest(String id) {
         this.id = id;
         waitForCompletion = null;
         timeout = null;
     }
 
-    public StopDataFrameTransformRequest(String id, Boolean waitForCompletion, TimeValue timeout) {
+    public StopTransformRequest(String id, Boolean waitForCompletion, TimeValue timeout) {
         this.id = id;
         this.waitForCompletion = waitForCompletion;
         this.timeout = timeout;
@@ -77,7 +77,7 @@ public class StopDataFrameTransformRequest implements Validatable {
     public Optional<ValidationException> validate() {
         if (id == null) {
             ValidationException validationException = new ValidationException();
-            validationException.addValidationError("data frame transform id must not be null");
+            validationException.addValidationError("transform id must not be null");
             return Optional.of(validationException);
         } else {
             return Optional.empty();
@@ -98,7 +98,7 @@ public class StopDataFrameTransformRequest implements Validatable {
         if (obj == null || getClass() != obj.getClass()) {
             return false;
         }
-        StopDataFrameTransformRequest other = (StopDataFrameTransformRequest) obj;
+        StopTransformRequest other = (StopTransformRequest) obj;
         return Objects.equals(this.id, other.id)
                 && Objects.equals(this.waitForCompletion, other.waitForCompletion)
                 && Objects.equals(this.timeout, other.timeout)

client/rest-high-level/src/main/java/org/elasticsearch/client/transform/StopTransformResponse.java

@@ -28,18 +28,18 @@ import org.elasticsearch.common.xcontent.XContentParser;
 import java.io.IOException;
 import java.util.List;
 
-public class StopDataFrameTransformResponse extends AcknowledgedTasksResponse {
+public class StopTransformResponse extends AcknowledgedTasksResponse {
 
     private static final String ACKNOWLEDGED = "acknowledged";
 
-    private static final ConstructingObjectParser<StopDataFrameTransformResponse, Void> PARSER = AcknowledgedTasksResponse
-            .generateParser("stop_data_frame_transform_response", StopDataFrameTransformResponse::new, ACKNOWLEDGED);
+    private static final ConstructingObjectParser<StopTransformResponse, Void> PARSER = AcknowledgedTasksResponse
+            .generateParser("stop_transform_response", StopTransformResponse::new, ACKNOWLEDGED);
 
-    public static StopDataFrameTransformResponse fromXContent(final XContentParser parser) throws IOException {
+    public static StopTransformResponse fromXContent(final XContentParser parser) throws IOException {
         return PARSER.parse(parser, null);
     }
 
-    public StopDataFrameTransformResponse(boolean acknowledged, @Nullable List<TaskOperationFailure> taskFailures,
+    public StopTransformResponse(boolean acknowledged, @Nullable List<TaskOperationFailure> taskFailures,
                                  @Nullable List<? extends ElasticsearchException> nodeFailures) {
         super(acknowledged, taskFailures, nodeFailures);
     }

client/rest-high-level/src/main/java/org/elasticsearch/client/transform/TransformNamedXContentProvider.java

@@ -28,7 +28,7 @@ import org.elasticsearch.plugins.spi.NamedXContentProvider;
 import java.util.Arrays;
 import java.util.List;
 
-public class DataFrameNamedXContentProvider implements NamedXContentProvider {
+public class TransformNamedXContentProvider implements NamedXContentProvider {
 
     @Override
     public List<NamedXContentRegistry.Entry> getNamedXContentParsers() {

client/rest-high-level/src/main/java/org/elasticsearch/client/transform/UpdateTransformRequest.java

@@ -21,7 +21,7 @@ package org.elasticsearch.client.transform;
 
 import org.elasticsearch.client.Validatable;
 import org.elasticsearch.client.ValidationException;
-import org.elasticsearch.client.transform.transforms.DataFrameTransformConfigUpdate;
+import org.elasticsearch.client.transform.transforms.TransformConfigUpdate;
 import org.elasticsearch.common.xcontent.ToXContentObject;
 import org.elasticsearch.common.xcontent.XContentBuilder;
 
@@ -29,18 +29,18 @@ import java.io.IOException;
 import java.util.Objects;
 import java.util.Optional;
 
-public class UpdateDataFrameTransformRequest implements ToXContentObject, Validatable {
+public class UpdateTransformRequest implements ToXContentObject, Validatable {
 
-    private final DataFrameTransformConfigUpdate update;
+    private final TransformConfigUpdate update;
     private final String id;
     private Boolean deferValidation;
 
-    public UpdateDataFrameTransformRequest(DataFrameTransformConfigUpdate update, String id) {
+    public UpdateTransformRequest(TransformConfigUpdate update, String id) {
         this.update = update;
         this.id = id;
     }
 
-    public DataFrameTransformConfigUpdate getUpdate() {
+    public TransformConfigUpdate getUpdate() {
         return update;
     }
 
@@ -65,10 +65,10 @@ public class UpdateDataFrameTransformRequest implements ToXContentObject, Valida
     public Optional<ValidationException> validate() {
         ValidationException validationException = new ValidationException();
         if (update == null) {
-            validationException.addValidationError("put requires a non-null data frame config update object");
+            validationException.addValidationError("put requires a non-null transform config update object");
         }
         if (id == null) {
-            validationException.addValidationError("data frame transform id cannot be null");
+            validationException.addValidationError("transform id cannot be null");
         }
         if (validationException.validationErrors().isEmpty()) {
             return Optional.empty();
@@ -95,7 +95,7 @@ public class UpdateDataFrameTransformRequest implements ToXContentObject, Valida
         if (getClass() != obj.getClass()) {
             return false;
         }
-        UpdateDataFrameTransformRequest other = (UpdateDataFrameTransformRequest) obj;
+        UpdateTransformRequest other = (UpdateTransformRequest) obj;
         return Objects.equals(update, other.update)
             && Objects.equals(id, other.id)
             && Objects.equals(deferValidation, other.deferValidation);

client/rest-high-level/src/main/java/org/elasticsearch/client/transform/UpdateTransformResponse.java

@@ -19,24 +19,24 @@
 
 package org.elasticsearch.client.transform;
 
-import org.elasticsearch.client.transform.transforms.DataFrameTransformConfig;
+import org.elasticsearch.client.transform.transforms.TransformConfig;
 import org.elasticsearch.common.xcontent.XContentParser;
 
 import java.util.Objects;
 
-public class UpdateDataFrameTransformResponse {
+public class UpdateTransformResponse {
 
-    public static UpdateDataFrameTransformResponse fromXContent(final XContentParser parser) {
-        return new UpdateDataFrameTransformResponse(DataFrameTransformConfig.PARSER.apply(parser, null));
+    public static UpdateTransformResponse fromXContent(final XContentParser parser) {
+        return new UpdateTransformResponse(TransformConfig.PARSER.apply(parser, null));
     }
 
-    private DataFrameTransformConfig transformConfiguration;
+    private TransformConfig transformConfiguration;
 
-    public UpdateDataFrameTransformResponse(DataFrameTransformConfig transformConfiguration) {
+    public UpdateTransformResponse(TransformConfig transformConfiguration) {
         this.transformConfiguration = transformConfiguration;
     }
 
-    public DataFrameTransformConfig getTransformConfiguration() {
+    public TransformConfig getTransformConfiguration() {
         return transformConfiguration;
     }
 
@@ -55,7 +55,7 @@ public class UpdateDataFrameTransformResponse {
             return false;
         }
 
-        final UpdateDataFrameTransformResponse that = (UpdateDataFrameTransformResponse) other;
+        final UpdateTransformResponse that = (UpdateTransformResponse) other;
         return Objects.equals(this.transformConfiguration, that.transformConfiguration);
     }
 }

client/rest-high-level/src/main/java/org/elasticsearch/client/transform/transforms/DestConfig.java

@@ -31,14 +31,14 @@ import static org.elasticsearch.common.xcontent.ConstructingObjectParser.constru
 import static org.elasticsearch.common.xcontent.ConstructingObjectParser.optionalConstructorArg;
 
 /**
- * Configuration containing the destination index for the {@link DataFrameTransformConfig}
+ * Configuration containing the destination index for the {@link TransformConfig}
  */
 public class DestConfig implements ToXContentObject {
 
     public static final ParseField INDEX = new ParseField("index");
     public static final ParseField PIPELINE = new ParseField("pipeline");
 
-    public static final ConstructingObjectParser<DestConfig, Void> PARSER = new ConstructingObjectParser<>("data_frame_config_dest",
+    public static final ConstructingObjectParser<DestConfig, Void> PARSER = new ConstructingObjectParser<>("transform_config_dest",
         true,
         args -> new DestConfig((String)args[0], (String)args[1]));
 

client/rest-high-level/src/main/java/org/elasticsearch/client/transform/transforms/QueryConfig.java

@@ -29,7 +29,7 @@ import java.io.IOException;
 import java.util.Objects;
 
 /**
- * Object for encapsulating the desired Query for a DataFrameTransform
+ * Object for encapsulating the desired Query for a Transform
  */
 public class QueryConfig implements ToXContentObject {
 

client/rest-high-level/src/main/java/org/elasticsearch/client/transform/transforms/SourceConfig.java

@@ -35,14 +35,14 @@ import static org.elasticsearch.common.xcontent.ConstructingObjectParser.optiona
 
 
 /**
- * Class encapsulating all options for a {@link DataFrameTransformConfig} gathering data
+ * Class encapsulating all options for a {@link TransformConfig} gathering data
  */
 public class SourceConfig implements ToXContentObject {
 
     public static final ParseField QUERY = new ParseField("query");
     public static final ParseField INDEX = new ParseField("index");
 
-    public static final ConstructingObjectParser<SourceConfig, Void> PARSER = new ConstructingObjectParser<>("data_frame_config_source",
+    public static final ConstructingObjectParser<SourceConfig, Void> PARSER = new ConstructingObjectParser<>("transform_config_source",
     true,
     args -> {
         @SuppressWarnings("unchecked")

client/rest-high-level/src/main/java/org/elasticsearch/client/transform/transforms/TransformCheckpointStats.java

@@ -28,7 +28,7 @@ import java.util.Objects;
 
 import static org.elasticsearch.common.xcontent.ConstructingObjectParser.optionalConstructorArg;
 
-public class DataFrameTransformCheckpointStats {
+public class TransformCheckpointStats {
 
     public static final ParseField CHECKPOINT = new ParseField("checkpoint");
     public static final ParseField POSITION = new ParseField("position");
@@ -36,39 +36,39 @@ public class DataFrameTransformCheckpointStats {
     public static final ParseField TIMESTAMP_MILLIS = new ParseField("timestamp_millis");
     public static final ParseField TIME_UPPER_BOUND_MILLIS = new ParseField("time_upper_bound_millis");
 
-    public static final DataFrameTransformCheckpointStats EMPTY = new DataFrameTransformCheckpointStats(0L, null, null, 0L, 0L);
+    public static final TransformCheckpointStats EMPTY = new TransformCheckpointStats(0L, null, null, 0L, 0L);
 
     private final long checkpoint;
-    private final DataFrameIndexerPosition position;
-    private final DataFrameTransformProgress checkpointProgress;
+    private final TransformIndexerPosition position;
+    private final TransformProgress checkpointProgress;
     private final long timestampMillis;
     private final long timeUpperBoundMillis;
 
-    public static final ConstructingObjectParser<DataFrameTransformCheckpointStats, Void> LENIENT_PARSER = new ConstructingObjectParser<>(
-            "data_frame_transform_checkpoint_stats", true, args -> {
+    public static final ConstructingObjectParser<TransformCheckpointStats, Void> LENIENT_PARSER = new ConstructingObjectParser<>(
+            "transform_checkpoint_stats", true, args -> {
         long checkpoint = args[0] == null ? 0L : (Long) args[0];
-        DataFrameIndexerPosition position = (DataFrameIndexerPosition) args[1];
-        DataFrameTransformProgress checkpointProgress = (DataFrameTransformProgress) args[2];
+        TransformIndexerPosition position = (TransformIndexerPosition) args[1];
+        TransformProgress checkpointProgress = (TransformProgress) args[2];
         long timestamp = args[3] == null ? 0L : (Long) args[3];
         long timeUpperBound = args[4] == null ? 0L : (Long) args[4];
 
-        return new DataFrameTransformCheckpointStats(checkpoint, position, checkpointProgress, timestamp, timeUpperBound);
+        return new TransformCheckpointStats(checkpoint, position, checkpointProgress, timestamp, timeUpperBound);
     });
 
     static {
         LENIENT_PARSER.declareLong(optionalConstructorArg(), CHECKPOINT);
-        LENIENT_PARSER.declareObject(optionalConstructorArg(), DataFrameIndexerPosition.PARSER, POSITION);
-        LENIENT_PARSER.declareObject(optionalConstructorArg(), DataFrameTransformProgress.PARSER, CHECKPOINT_PROGRESS);
+        LENIENT_PARSER.declareObject(optionalConstructorArg(), TransformIndexerPosition.PARSER, POSITION);
+        LENIENT_PARSER.declareObject(optionalConstructorArg(), TransformProgress.PARSER, CHECKPOINT_PROGRESS);
         LENIENT_PARSER.declareLong(optionalConstructorArg(), TIMESTAMP_MILLIS);
         LENIENT_PARSER.declareLong(optionalConstructorArg(), TIME_UPPER_BOUND_MILLIS);
     }
 
-    public static DataFrameTransformCheckpointStats fromXContent(XContentParser parser) throws IOException {
+    public static TransformCheckpointStats fromXContent(XContentParser parser) throws IOException {
         return LENIENT_PARSER.parse(parser, null);
     }
 
-    public DataFrameTransformCheckpointStats(final long checkpoint, final DataFrameIndexerPosition position,
-                                             final DataFrameTransformProgress checkpointProgress, final long timestampMillis,
+    public TransformCheckpointStats(final long checkpoint, final TransformIndexerPosition position,
+                                    final TransformProgress checkpointProgress, final long timestampMillis,
                                     final long timeUpperBoundMillis) {
         this.checkpoint = checkpoint;
         this.position = position;
@@ -81,11 +81,11 @@ public class DataFrameTransformCheckpointStats {
         return checkpoint;
     }
 
-    public DataFrameIndexerPosition getPosition() {
+    public TransformIndexerPosition getPosition() {
         return position;
     }
 
-    public DataFrameTransformProgress getCheckpointProgress() {
+    public TransformProgress getCheckpointProgress() {
         return checkpointProgress;
     }
 
@@ -112,7 +112,7 @@ public class DataFrameTransformCheckpointStats {
             return false;
         }
 
-        DataFrameTransformCheckpointStats that = (DataFrameTransformCheckpointStats) other;
+        TransformCheckpointStats that = (TransformCheckpointStats) other;
 
         return this.checkpoint == that.checkpoint
             && Objects.equals(this.position, that.position)

client/rest-high-level/src/main/java/org/elasticsearch/client/transform/transforms/TransformCheckpointingInfo.java

@@ -29,37 +29,37 @@ import org.elasticsearch.common.xcontent.XContentParser;
 import java.time.Instant;
 import java.util.Objects;
 
-public class DataFrameTransformCheckpointingInfo {
+public class TransformCheckpointingInfo {
 
     public static final ParseField LAST_CHECKPOINT = new ParseField("last", "current");
     public static final ParseField NEXT_CHECKPOINT = new ParseField("next", "in_progress");
     public static final ParseField OPERATIONS_BEHIND = new ParseField("operations_behind");
     public static final ParseField CHANGES_LAST_DETECTED_AT = new ParseField("changes_last_detected_at");
 
-    private final DataFrameTransformCheckpointStats last;
-    private final DataFrameTransformCheckpointStats next;
+    private final TransformCheckpointStats last;
+    private final TransformCheckpointStats next;
     private final long operationsBehind;
     private final Instant changesLastDetectedAt;
 
-    private static final ConstructingObjectParser<DataFrameTransformCheckpointingInfo, Void> LENIENT_PARSER =
+    private static final ConstructingObjectParser<TransformCheckpointingInfo, Void> LENIENT_PARSER =
             new ConstructingObjectParser<>(
-                "data_frame_transform_checkpointing_info",
+                "transform_checkpointing_info",
                 true,
                 a -> {
                         long behind = a[2] == null ? 0L : (Long) a[2];
                         Instant changesLastDetectedAt = (Instant)a[3];
-                        return new DataFrameTransformCheckpointingInfo(
-                            a[0] == null ? DataFrameTransformCheckpointStats.EMPTY : (DataFrameTransformCheckpointStats) a[0],
-                            a[1] == null ? DataFrameTransformCheckpointStats.EMPTY : (DataFrameTransformCheckpointStats) a[1],
+                        return new TransformCheckpointingInfo(
+                            a[0] == null ? TransformCheckpointStats.EMPTY : (TransformCheckpointStats) a[0],
+                            a[1] == null ? TransformCheckpointStats.EMPTY : (TransformCheckpointStats) a[1],
                             behind,
                             changesLastDetectedAt);
                     });
 
     static {
         LENIENT_PARSER.declareObject(ConstructingObjectParser.optionalConstructorArg(),
-                (p, c) -> DataFrameTransformCheckpointStats.fromXContent(p), LAST_CHECKPOINT);
+                (p, c) -> TransformCheckpointStats.fromXContent(p), LAST_CHECKPOINT);
         LENIENT_PARSER.declareObject(ConstructingObjectParser.optionalConstructorArg(),
-                (p, c) -> DataFrameTransformCheckpointStats.fromXContent(p), NEXT_CHECKPOINT);
+                (p, c) -> TransformCheckpointStats.fromXContent(p), NEXT_CHECKPOINT);
         LENIENT_PARSER.declareLong(ConstructingObjectParser.optionalConstructorArg(), OPERATIONS_BEHIND);
         LENIENT_PARSER.declareField(ConstructingObjectParser.optionalConstructorArg(),
             p -> TimeUtil.parseTimeFieldToInstant(p, CHANGES_LAST_DETECTED_AT.getPreferredName()),
@@ -67,8 +67,8 @@ public class DataFrameTransformCheckpointingInfo {
             ObjectParser.ValueType.VALUE);
     }
 
-    public DataFrameTransformCheckpointingInfo(DataFrameTransformCheckpointStats last,
-                                               DataFrameTransformCheckpointStats next,
+    public TransformCheckpointingInfo(TransformCheckpointStats last,
+                                      TransformCheckpointStats next,
                                       long operationsBehind,
                                       Instant changesLastDetectedAt) {
         this.last = Objects.requireNonNull(last);
@@ -77,11 +77,11 @@ public class DataFrameTransformCheckpointingInfo {
         this.changesLastDetectedAt = changesLastDetectedAt;
     }
 
-    public DataFrameTransformCheckpointStats getLast() {
+    public TransformCheckpointStats getLast() {
         return last;
     }
 
-    public DataFrameTransformCheckpointStats getNext() {
+    public TransformCheckpointStats getNext() {
         return next;
     }
 
@@ -94,7 +94,7 @@ public class DataFrameTransformCheckpointingInfo {
         return changesLastDetectedAt;
     }
 
-    public static DataFrameTransformCheckpointingInfo fromXContent(XContentParser p) {
+    public static TransformCheckpointingInfo fromXContent(XContentParser p) {
         return LENIENT_PARSER.apply(p, null);
     }
 
@@ -113,7 +113,7 @@ public class DataFrameTransformCheckpointingInfo {
             return false;
         }
 
-        DataFrameTransformCheckpointingInfo that = (DataFrameTransformCheckpointingInfo) other;
+        TransformCheckpointingInfo that = (TransformCheckpointingInfo) other;
 
         return Objects.equals(this.last, that.last) &&
             Objects.equals(this.next, that.next) &&

client/rest-high-level/src/main/java/org/elasticsearch/client/transform/transforms/TransformConfig.java

@@ -40,7 +40,7 @@ import java.util.Objects;
 import static org.elasticsearch.common.xcontent.ConstructingObjectParser.constructorArg;
 import static org.elasticsearch.common.xcontent.ConstructingObjectParser.optionalConstructorArg;
 
-public class DataFrameTransformConfig implements ToXContentObject {
+public class TransformConfig implements ToXContentObject {
 
     public static final ParseField ID = new ParseField("id");
     public static final ParseField SOURCE = new ParseField("source");
@@ -63,8 +63,8 @@ public class DataFrameTransformConfig implements ToXContentObject {
     private final Version transformVersion;
     private final Instant createTime;
 
-    public static final ConstructingObjectParser<DataFrameTransformConfig, Void> PARSER =
-            new ConstructingObjectParser<>("data_frame_transform", true,
+    public static final ConstructingObjectParser<TransformConfig, Void> PARSER =
+            new ConstructingObjectParser<>("transform", true,
                 (args) -> {
                     String id = (String) args[0];
                     SourceConfig source = (SourceConfig) args[1];
@@ -75,7 +75,7 @@ public class DataFrameTransformConfig implements ToXContentObject {
                     String description = (String)args[6];
                     Instant createTime = (Instant)args[7];
                     String transformVersion = (String)args[8];
-                    return new DataFrameTransformConfig(id,
+                    return new TransformConfig(id,
                         source,
                         dest,
                         frequency,
@@ -109,26 +109,26 @@ public class DataFrameTransformConfig implements ToXContentObject {
     }
 
 
-    public static DataFrameTransformConfig fromXContent(final XContentParser parser) {
+    public static TransformConfig fromXContent(final XContentParser parser) {
         return PARSER.apply(parser, null);
     }
 
     /**
-     * Helper method for previewing a data frame transform configuration
+     * Helper method for previewing a transform configuration
      *
-     * The DataFrameTransformConfig returned from this method should only be used for previewing the resulting data.
+     * The TransformConfig returned from this method should only be used for previewing the resulting data.
      *
-     * A new, valid, DataFrameTransformConfig with an appropriate destination and ID will have to be constructed to create
+     * A new, valid, TransformConfig with an appropriate destination and ID will have to be constructed to create
      * the transform.
      * @param source Source configuration for gathering the data
      * @param pivotConfig Pivot config to preview
-     * @return A DataFrameTransformConfig to preview, NOTE it will have a {@code null} id, destination and index.
+     * @return A TransformConfig to preview, NOTE it will have a {@code null} id, destination and index.
      */
-    public static DataFrameTransformConfig forPreview(final SourceConfig source, final PivotConfig pivotConfig) {
-        return new DataFrameTransformConfig(null, source, null, null, null, pivotConfig, null, null, null);
+    public static TransformConfig forPreview(final SourceConfig source, final PivotConfig pivotConfig) {
+        return new TransformConfig(null, source, null, null, null, pivotConfig, null, null, null);
     }
 
-    DataFrameTransformConfig(final String id,
+    TransformConfig(final String id,
                     final SourceConfig source,
                     final DestConfig dest,
                     final TimeValue frequency,
@@ -231,7 +231,7 @@ public class DataFrameTransformConfig implements ToXContentObject {
             return false;
         }
 
-        final DataFrameTransformConfig that = (DataFrameTransformConfig) other;
+        final TransformConfig that = (TransformConfig) other;
 
         return Objects.equals(this.id, that.id)
             && Objects.equals(this.source, that.source)
@@ -303,8 +303,8 @@ public class DataFrameTransformConfig implements ToXContentObject {
             return this;
         }
 
-        public DataFrameTransformConfig build() {
-            return new DataFrameTransformConfig(id, source, dest, frequency, syncConfig, pivotConfig, description, null, null);
+        public TransformConfig build() {
+            return new TransformConfig(id, source, dest, frequency, syncConfig, pivotConfig, description, null, null);
         }
     }
 }

client/rest-high-level/src/main/java/org/elasticsearch/client/transform/transforms/TransformConfigUpdate.java

@@ -34,30 +34,30 @@ import java.util.Objects;
 import static org.elasticsearch.common.xcontent.ConstructingObjectParser.optionalConstructorArg;
 
 /**
- * This class holds the mutable configuration items for a data frame transform
+ * This class holds the mutable configuration items for a transform
  */
-public class DataFrameTransformConfigUpdate implements ToXContentObject {
+public class TransformConfigUpdate implements ToXContentObject {
 
-    public static final String NAME = "data_frame_transform_config_update";
-    private static final ConstructingObjectParser<DataFrameTransformConfigUpdate, String> PARSER = new ConstructingObjectParser<>(NAME,
+    public static final String NAME = "transform_config_update";
+    private static final ConstructingObjectParser<TransformConfigUpdate, String> PARSER = new ConstructingObjectParser<>(NAME,
         false,
         (args) -> {
             SourceConfig source = (SourceConfig) args[0];
             DestConfig dest = (DestConfig) args[1];
             TimeValue frequency = args[2] == null ?
                 null :
-                TimeValue.parseTimeValue((String) args[2], DataFrameTransformConfig.FREQUENCY.getPreferredName());
+                TimeValue.parseTimeValue((String) args[2], TransformConfig.FREQUENCY.getPreferredName());
             SyncConfig syncConfig = (SyncConfig) args[3];
             String description = (String) args[4];
-            return new DataFrameTransformConfigUpdate(source, dest, frequency, syncConfig, description);
+            return new TransformConfigUpdate(source, dest, frequency, syncConfig, description);
         });
 
     static {
-        PARSER.declareObject(optionalConstructorArg(), (p, c) -> SourceConfig.PARSER.apply(p, null), DataFrameTransformConfig.SOURCE);
-        PARSER.declareObject(optionalConstructorArg(), (p, c) -> DestConfig.PARSER.apply(p, null), DataFrameTransformConfig.DEST);
-        PARSER.declareString(optionalConstructorArg(), DataFrameTransformConfig.FREQUENCY);
-        PARSER.declareObject(optionalConstructorArg(), (p, c) -> parseSyncConfig(p), DataFrameTransformConfig.SYNC);
-        PARSER.declareString(optionalConstructorArg(), DataFrameTransformConfig.DESCRIPTION);
+        PARSER.declareObject(optionalConstructorArg(), (p, c) -> SourceConfig.PARSER.apply(p, null), TransformConfig.SOURCE);
+        PARSER.declareObject(optionalConstructorArg(), (p, c) -> DestConfig.PARSER.apply(p, null), TransformConfig.DEST);
+        PARSER.declareString(optionalConstructorArg(), TransformConfig.FREQUENCY);
+        PARSER.declareObject(optionalConstructorArg(), (p, c) -> parseSyncConfig(p), TransformConfig.SYNC);
+        PARSER.declareString(optionalConstructorArg(), TransformConfig.DESCRIPTION);
     }
 
     private static SyncConfig parseSyncConfig(XContentParser parser) throws IOException {
@@ -74,11 +74,11 @@ public class DataFrameTransformConfigUpdate implements ToXContentObject {
     private final SyncConfig syncConfig;
     private final String description;
 
-    public DataFrameTransformConfigUpdate(final SourceConfig source,
+    public TransformConfigUpdate(final SourceConfig source,
                                  final DestConfig dest,
                                  final TimeValue frequency,
                                  final SyncConfig syncConfig,
-                                          final String description){
+                                 final String description) {
         this.source = source;
         this.dest = dest;
         this.frequency = frequency;
@@ -111,21 +111,21 @@ public class DataFrameTransformConfigUpdate implements ToXContentObject {
     public XContentBuilder toXContent(final XContentBuilder builder, final Params params) throws IOException {
         builder.startObject();
         if (source != null) {
-            builder.field(DataFrameTransformConfig.SOURCE.getPreferredName(), source);
+            builder.field(TransformConfig.SOURCE.getPreferredName(), source);
         }
         if (dest != null) {
-            builder.field(DataFrameTransformConfig.DEST.getPreferredName(), dest);
+            builder.field(TransformConfig.DEST.getPreferredName(), dest);
         }
         if (frequency != null) {
-            builder.field(DataFrameTransformConfig.FREQUENCY.getPreferredName(), frequency.getStringRep());
+            builder.field(TransformConfig.FREQUENCY.getPreferredName(), frequency.getStringRep());
         }
         if (syncConfig != null) {
-            builder.startObject(DataFrameTransformConfig.SYNC.getPreferredName());
+            builder.startObject(TransformConfig.SYNC.getPreferredName());
             builder.field(syncConfig.getName(), syncConfig);
             builder.endObject();
         }
         if (description != null) {
-            builder.field(DataFrameTransformConfig.DESCRIPTION.getPreferredName(), description);
+            builder.field(TransformConfig.DESCRIPTION.getPreferredName(), description);
         }
         builder.endObject();
         return builder;
@@ -141,7 +141,7 @@ public class DataFrameTransformConfigUpdate implements ToXContentObject {
             return false;
         }
 
-        final DataFrameTransformConfigUpdate that = (DataFrameTransformConfigUpdate) other;
+        final TransformConfigUpdate that = (TransformConfigUpdate) other;
 
         return Objects.equals(this.source, that.source)
             && Objects.equals(this.dest, that.dest)
@@ -164,7 +164,7 @@ public class DataFrameTransformConfigUpdate implements ToXContentObject {
         return new Builder();
     }
 
-    public static DataFrameTransformConfigUpdate fromXContent(final XContentParser parser) {
+    public static TransformConfigUpdate fromXContent(final XContentParser parser) {
         return PARSER.apply(parser, null);
     }
 
@@ -201,8 +201,8 @@ public class DataFrameTransformConfigUpdate implements ToXContentObject {
             return this;
         }
 
-        public DataFrameTransformConfigUpdate build() {
-            return new DataFrameTransformConfigUpdate(source, dest, frequency, syncConfig, description);
+        public TransformConfigUpdate build() {
+            return new TransformConfigUpdate(source, dest, frequency, syncConfig, description);
         }
     }
 }

client/rest-high-level/src/main/java/org/elasticsearch/client/transform/transforms/TransformIndexerPosition.java

@@ -37,7 +37,7 @@ import static org.elasticsearch.common.xcontent.ConstructingObjectParser.optiona
  *  indexer_position: the position of the indexer querying the source
  *  bucket_position: the position used for identifying changes
  */
-public class DataFrameIndexerPosition {
+public class TransformIndexerPosition {
     public static final ParseField INDEXER_POSITION = new ParseField("indexer_position");
     public static final ParseField BUCKET_POSITION = new ParseField("bucket_position");
 
@@ -45,17 +45,17 @@ public class DataFrameIndexerPosition {
     private final Map<String, Object> bucketPosition;
 
     @SuppressWarnings("unchecked")
-    public static final ConstructingObjectParser<DataFrameIndexerPosition, Void> PARSER = new ConstructingObjectParser<>(
-            "data_frame_indexer_position",
+    public static final ConstructingObjectParser<TransformIndexerPosition, Void> PARSER = new ConstructingObjectParser<>(
+            "transform_indexer_position",
             true,
-            args -> new DataFrameIndexerPosition((Map<String, Object>) args[0],(Map<String, Object>) args[1]));
+            args -> new TransformIndexerPosition((Map<String, Object>) args[0],(Map<String, Object>) args[1]));
 
     static {
         PARSER.declareField(optionalConstructorArg(), XContentParser::mapOrdered, INDEXER_POSITION, ValueType.OBJECT);
         PARSER.declareField(optionalConstructorArg(), XContentParser::mapOrdered, BUCKET_POSITION, ValueType.OBJECT);
     }
 
-    public DataFrameIndexerPosition(Map<String, Object> indexerPosition, Map<String, Object> bucketPosition) {
+    public TransformIndexerPosition(Map<String, Object> indexerPosition, Map<String, Object> bucketPosition) {
         this.indexerPosition = indexerPosition == null ? null : Collections.unmodifiableMap(indexerPosition);
         this.bucketPosition = bucketPosition == null ? null : Collections.unmodifiableMap(bucketPosition);
     }
@@ -78,7 +78,7 @@ public class DataFrameIndexerPosition {
             return false;
         }
 
-        DataFrameIndexerPosition that = (DataFrameIndexerPosition) other;
+        TransformIndexerPosition that = (TransformIndexerPosition) other;
 
         return Objects.equals(this.indexerPosition, that.indexerPosition) &&
             Objects.equals(this.bucketPosition, that.bucketPosition);
@@ -89,7 +89,7 @@ public class DataFrameIndexerPosition {
         return Objects.hash(indexerPosition, bucketPosition);
     }
 
-    public static DataFrameIndexerPosition fromXContent(XContentParser parser) {
+    public static TransformIndexerPosition fromXContent(XContentParser parser) {
         try {
             return PARSER.parse(parser, null);
         } catch (IOException e) {

client/rest-high-level/src/main/java/org/elasticsearch/client/transform/transforms/TransformIndexerStats.java

@@ -30,16 +30,16 @@ import java.util.Objects;
 import static org.elasticsearch.common.xcontent.ConstructingObjectParser.constructorArg;
 import static org.elasticsearch.common.xcontent.ConstructingObjectParser.optionalConstructorArg;
 
-public class DataFrameIndexerTransformStats extends IndexerJobStats {
+public class TransformIndexerStats extends IndexerJobStats {
 
     static ParseField EXPONENTIAL_AVG_CHECKPOINT_DURATION_MS = new ParseField("exponential_avg_checkpoint_duration_ms");
     static ParseField EXPONENTIAL_AVG_DOCUMENTS_INDEXED = new ParseField("exponential_avg_documents_indexed");
     static ParseField EXPONENTIAL_AVG_DOCUMENTS_PROCESSED = new ParseField("exponential_avg_documents_processed");
 
-    public static final ConstructingObjectParser<DataFrameIndexerTransformStats, Void> LENIENT_PARSER = new ConstructingObjectParser<>(
+    public static final ConstructingObjectParser<TransformIndexerStats, Void> LENIENT_PARSER = new ConstructingObjectParser<>(
         NAME,
         true,
-        args -> new DataFrameIndexerTransformStats((long) args[0], (long) args[1], (long) args[2],
+        args -> new TransformIndexerStats((long) args[0], (long) args[1], (long) args[2],
             (long) args[3], (long) args[4], (long) args[5], (long) args[6], (long) args[7], (long) args[8], (long) args[9],
             (Double) args[10], (Double) args[11], (Double) args[12]));
 
@@ -59,7 +59,7 @@ public class DataFrameIndexerTransformStats extends IndexerJobStats {
         LENIENT_PARSER.declareDouble(optionalConstructorArg(), EXPONENTIAL_AVG_DOCUMENTS_PROCESSED);
     }
 
-    public static DataFrameIndexerTransformStats fromXContent(XContentParser parser) throws IOException {
+    public static TransformIndexerStats fromXContent(XContentParser parser) throws IOException {
         return LENIENT_PARSER.parse(parser, null);
     }
 
@@ -67,7 +67,7 @@ public class DataFrameIndexerTransformStats extends IndexerJobStats {
     private final double expAvgDocumentsIndexed;
     private final double expAvgDocumentsProcessed;
 
-    public DataFrameIndexerTransformStats(long numPages, long numInputDocuments, long numOuputDocuments,
+    public TransformIndexerStats(long numPages, long numInputDocuments, long numOuputDocuments,
                                  long numInvocations, long indexTime, long searchTime,
                                  long indexTotal, long searchTotal, long indexFailures, long searchFailures,
                                  Double expAvgCheckpointDurationMs, Double expAvgDocumentsIndexed,
@@ -101,7 +101,7 @@ public class DataFrameIndexerTransformStats extends IndexerJobStats {
             return false;
         }
 
-        DataFrameIndexerTransformStats that = (DataFrameIndexerTransformStats) other;
+        TransformIndexerStats that = (TransformIndexerStats) other;
 
         return Objects.equals(this.numPages, that.numPages)
             && Objects.equals(this.numInputDocuments, that.numInputDocuments)

client/rest-high-level/src/main/java/org/elasticsearch/client/transform/transforms/TransformProgress.java

@@ -28,7 +28,7 @@ import java.util.Objects;
 
 import static org.elasticsearch.common.xcontent.ConstructingObjectParser.optionalConstructorArg;
 
-public class DataFrameTransformProgress {
+public class TransformProgress {
 
     public static final ParseField TOTAL_DOCS = new ParseField("total_docs");
     public static final ParseField DOCS_REMAINING = new ParseField("docs_remaining");
@@ -36,10 +36,10 @@ public class DataFrameTransformProgress {
     public static final ParseField DOCS_PROCESSED = new ParseField("docs_processed");
     public static final ParseField DOCS_INDEXED = new ParseField("docs_indexed");
 
-    public static final ConstructingObjectParser<DataFrameTransformProgress, Void> PARSER = new ConstructingObjectParser<>(
-        "data_frame_transform_progress",
+    public static final ConstructingObjectParser<TransformProgress, Void> PARSER = new ConstructingObjectParser<>(
+        "transform_progress",
         true,
-        a -> new DataFrameTransformProgress((Long) a[0], (Long)a[1], (Double)a[2], (Long)a[3], (Long)a[4]));
+        a -> new TransformProgress((Long) a[0], (Long)a[1], (Double)a[2], (Long)a[3], (Long)a[4]));
 
     static {
         PARSER.declareLong(optionalConstructorArg(), TOTAL_DOCS);
@@ -49,7 +49,7 @@ public class DataFrameTransformProgress {
         PARSER.declareLong(optionalConstructorArg(), DOCS_INDEXED);
     }
 
-    public static DataFrameTransformProgress fromXContent(XContentParser parser) {
+    public static TransformProgress fromXContent(XContentParser parser) {
         return PARSER.apply(parser, null);
     }
 
@@ -59,7 +59,7 @@ public class DataFrameTransformProgress {
     private final long documentsProcessed;
     private final long documentsIndexed;
 
-    public DataFrameTransformProgress(Long totalDocs,
+    public TransformProgress(Long totalDocs,
                              Long remainingDocs,
                              Double percentComplete,
                              Long documentsProcessed,
@@ -104,7 +104,7 @@ public class DataFrameTransformProgress {
             return false;
         }
 
-        DataFrameTransformProgress that = (DataFrameTransformProgress) other;
+        TransformProgress that = (TransformProgress) other;
         return Objects.equals(this.remainingDocs, that.remainingDocs)
             && Objects.equals(this.totalDocs, that.totalDocs)
             && Objects.equals(this.percentComplete, that.percentComplete)

client/rest-high-level/src/main/java/org/elasticsearch/client/transform/transforms/TransformStats.java

@@ -31,7 +31,7 @@ import java.util.Objects;
 import static org.elasticsearch.common.xcontent.ConstructingObjectParser.constructorArg;
 import static org.elasticsearch.common.xcontent.ConstructingObjectParser.optionalConstructorArg;
 
-public class DataFrameTransformStats {
+public class TransformStats {
 
     public static final ParseField ID = new ParseField("id");
     public static final ParseField STATE_FIELD = new ParseField("state");
@@ -40,10 +40,10 @@ public class DataFrameTransformStats {
     public static final ParseField STATS_FIELD = new ParseField("stats");
     public static final ParseField CHECKPOINTING_INFO_FIELD = new ParseField("checkpointing");
 
-    public static final ConstructingObjectParser<DataFrameTransformStats, Void> PARSER = new ConstructingObjectParser<>(
+    public static final ConstructingObjectParser<TransformStats, Void> PARSER = new ConstructingObjectParser<>(
         "data_frame_transform_state_and_stats_info", true,
-        a -> new DataFrameTransformStats((String) a[0], (State) a[1], (String) a[2],
-            (NodeAttributes) a[3], (DataFrameIndexerTransformStats) a[4], (DataFrameTransformCheckpointingInfo) a[5]));
+        a -> new TransformStats((String) a[0], (State) a[1], (String) a[2],
+            (NodeAttributes) a[3], (TransformIndexerStats) a[4], (TransformCheckpointingInfo) a[5]));
 
     static {
         PARSER.declareString(constructorArg(), ID);
@@ -51,12 +51,12 @@ public class DataFrameTransformStats {
             ObjectParser.ValueType.STRING);
         PARSER.declareString(optionalConstructorArg(), REASON_FIELD);
         PARSER.declareField(optionalConstructorArg(), NodeAttributes.PARSER::apply, NODE_FIELD, ObjectParser.ValueType.OBJECT);
-        PARSER.declareObject(constructorArg(), (p, c) -> DataFrameIndexerTransformStats.fromXContent(p), STATS_FIELD);
+        PARSER.declareObject(constructorArg(), (p, c) -> TransformIndexerStats.fromXContent(p), STATS_FIELD);
         PARSER.declareObject(optionalConstructorArg(),
-            (p, c) -> DataFrameTransformCheckpointingInfo.fromXContent(p), CHECKPOINTING_INFO_FIELD);
+            (p, c) -> TransformCheckpointingInfo.fromXContent(p), CHECKPOINTING_INFO_FIELD);
     }
 
-    public static DataFrameTransformStats fromXContent(XContentParser parser) throws IOException {
+    public static TransformStats fromXContent(XContentParser parser) throws IOException {
         return PARSER.parse(parser, null);
     }
 
@@ -64,11 +64,11 @@ public class DataFrameTransformStats {
     private final String reason;
     private final State state;
     private final NodeAttributes node;
-    private final DataFrameIndexerTransformStats indexerStats;
-    private final DataFrameTransformCheckpointingInfo checkpointingInfo;
+    private final TransformIndexerStats indexerStats;
+    private final TransformCheckpointingInfo checkpointingInfo;
 
-    public DataFrameTransformStats(String id, State state, String reason, NodeAttributes node, DataFrameIndexerTransformStats stats,
-                                   DataFrameTransformCheckpointingInfo checkpointingInfo) {
+    public TransformStats(String id, State state, String reason, NodeAttributes node, TransformIndexerStats stats,
+                          TransformCheckpointingInfo checkpointingInfo) {
         this.id = id;
         this.state = state;
         this.reason = reason;
@@ -93,11 +93,11 @@ public class DataFrameTransformStats {
         return node;
     }
 
-    public DataFrameIndexerTransformStats getIndexerStats() {
+    public TransformIndexerStats getIndexerStats() {
         return indexerStats;
     }
 
-    public DataFrameTransformCheckpointingInfo getCheckpointingInfo() {
+    public TransformCheckpointingInfo getCheckpointingInfo() {
         return checkpointingInfo;
     }
 
@@ -116,7 +116,7 @@ public class DataFrameTransformStats {
             return false;
         }
 
-        DataFrameTransformStats that = (DataFrameTransformStats) other;
+        TransformStats that = (TransformStats) other;
 
         return Objects.equals(this.id, that.id)
             && Objects.equals(this.state, that.state)

client/rest-high-level/src/main/java/org/elasticsearch/client/transform/transforms/pivot/DateHistogramGroupSource.java

@@ -72,7 +72,7 @@ public class DateHistogramGroupSource extends SingleGroupSource implements ToXCo
      * fixed_interval fixed intervals like 1h, 1m, 1d
      * calendar_interval calendar aware intervals like 1M, 1Y, ...
      *
-     * Note: data frames do not support the deprecated interval option
+     * Note: transform does not support the deprecated interval option
      */
     public interface Interval extends ToXContentFragment {
         String getName();

client/rest-high-level/src/main/resources/META-INF/services/org.elasticsearch.plugins.spi.NamedXContentProvider

@@ -1,4 +1,4 @@
 org.elasticsearch.client.indexlifecycle.IndexLifecycleNamedXContentProvider
 org.elasticsearch.client.ml.dataframe.MlDataFrameAnalysisNamedXContentProvider
 org.elasticsearch.client.ml.dataframe.evaluation.MlEvaluationNamedXContentProvider
-org.elasticsearch.client.transform.DataFrameNamedXContentProvider
+org.elasticsearch.client.transform.TransformNamedXContentProvider

client/rest-high-level/src/test/java/org/elasticsearch/client/DataFrameRequestConvertersTests.java

@@ -24,19 +24,19 @@ import org.apache.http.client.methods.HttpGet;
 import org.apache.http.client.methods.HttpPost;
 import org.apache.http.client.methods.HttpPut;
 import org.elasticsearch.client.core.PageParams;
-import org.elasticsearch.client.transform.DataFrameNamedXContentProvider;
-import org.elasticsearch.client.transform.DeleteDataFrameTransformRequest;
-import org.elasticsearch.client.transform.GetDataFrameTransformRequest;
-import org.elasticsearch.client.transform.GetDataFrameTransformStatsRequest;
-import org.elasticsearch.client.transform.PreviewDataFrameTransformRequest;
-import org.elasticsearch.client.transform.PutDataFrameTransformRequest;
-import org.elasticsearch.client.transform.StartDataFrameTransformRequest;
-import org.elasticsearch.client.transform.StopDataFrameTransformRequest;
-import org.elasticsearch.client.transform.UpdateDataFrameTransformRequest;
-import org.elasticsearch.client.transform.transforms.DataFrameTransformConfig;
-import org.elasticsearch.client.transform.transforms.DataFrameTransformConfigTests;
-import org.elasticsearch.client.transform.transforms.DataFrameTransformConfigUpdate;
-import org.elasticsearch.client.transform.transforms.DataFrameTransformConfigUpdateTests;
+import org.elasticsearch.client.transform.TransformNamedXContentProvider;
+import org.elasticsearch.client.transform.DeleteTransformRequest;
+import org.elasticsearch.client.transform.GetTransformRequest;
+import org.elasticsearch.client.transform.GetTransformStatsRequest;
+import org.elasticsearch.client.transform.PreviewTransformRequest;
+import org.elasticsearch.client.transform.PutTransformRequest;
+import org.elasticsearch.client.transform.StartTransformRequest;
+import org.elasticsearch.client.transform.StopTransformRequest;
+import org.elasticsearch.client.transform.UpdateTransformRequest;
+import org.elasticsearch.client.transform.transforms.TransformConfig;
+import org.elasticsearch.client.transform.transforms.TransformConfigTests;
+import org.elasticsearch.client.transform.transforms.TransformConfigUpdate;
+import org.elasticsearch.client.transform.transforms.TransformConfigUpdateTests;
 import org.elasticsearch.common.settings.Settings;
 import org.elasticsearch.common.unit.TimeValue;
 import org.elasticsearch.common.xcontent.NamedXContentRegistry;
@@ -49,7 +49,7 @@ import java.io.IOException;
 import java.util.Collections;
 import java.util.List;
 
-import static org.elasticsearch.client.transform.GetDataFrameTransformRequest.ALLOW_NO_MATCH;
+import static org.elasticsearch.client.transform.GetTransformRequest.ALLOW_NO_MATCH;
 import static org.hamcrest.Matchers.allOf;
 import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.hasEntry;
@@ -62,50 +62,50 @@ public class DataFrameRequestConvertersTests extends ESTestCase {
     protected NamedXContentRegistry xContentRegistry() {
         SearchModule searchModule = new SearchModule(Settings.EMPTY, false, Collections.emptyList());
         List<NamedXContentRegistry.Entry> namedXContents = searchModule.getNamedXContents();
-        namedXContents.addAll(new DataFrameNamedXContentProvider().getNamedXContentParsers());
+        namedXContents.addAll(new TransformNamedXContentProvider().getNamedXContentParsers());
         return new NamedXContentRegistry(namedXContents);
     }
 
     public void testPutDataFrameTransform() throws IOException {
-        PutDataFrameTransformRequest putRequest = new PutDataFrameTransformRequest(
-                DataFrameTransformConfigTests.randomDataFrameTransformConfig());
-        Request request = DataFrameRequestConverters.putDataFrameTransform(putRequest);
+        PutTransformRequest putRequest = new PutTransformRequest(
+                TransformConfigTests.randomTransformConfig());
+        Request request = TransformRequestConverters.putTransform(putRequest);
         assertThat(request.getParameters(), not(hasKey("defer_validation")));
         assertEquals(HttpPut.METHOD_NAME, request.getMethod());
         assertThat(request.getEndpoint(), equalTo("/_data_frame/transforms/" + putRequest.getConfig().getId()));
 
         try (XContentParser parser = createParser(JsonXContent.jsonXContent, request.getEntity().getContent())) {
-            DataFrameTransformConfig parsedConfig = DataFrameTransformConfig.PARSER.apply(parser, null);
+            TransformConfig parsedConfig = TransformConfig.PARSER.apply(parser, null);
             assertThat(parsedConfig, equalTo(putRequest.getConfig()));
         }
         putRequest.setDeferValidation(true);
-        request = DataFrameRequestConverters.putDataFrameTransform(putRequest);
+        request = TransformRequestConverters.putTransform(putRequest);
         assertThat(request.getParameters(), hasEntry("defer_validation", Boolean.toString(putRequest.getDeferValidation())));
     }
 
     public void testUpdateDataFrameTransform() throws IOException {
         String transformId = randomAlphaOfLength(10);
-        UpdateDataFrameTransformRequest updateDataFrameTransformRequest = new UpdateDataFrameTransformRequest(
-            DataFrameTransformConfigUpdateTests.randomDataFrameTransformConfigUpdate(),
+        UpdateTransformRequest updateDataFrameTransformRequest = new UpdateTransformRequest(
+            TransformConfigUpdateTests.randomTransformConfigUpdate(),
             transformId);
-        Request request = DataFrameRequestConverters.updateDataFrameTransform(updateDataFrameTransformRequest);
+        Request request = TransformRequestConverters.updateTransform(updateDataFrameTransformRequest);
         assertThat(request.getParameters(), not(hasKey("defer_validation")));
         assertEquals(HttpPost.METHOD_NAME, request.getMethod());
         assertThat(request.getEndpoint(), equalTo("/_data_frame/transforms/" + transformId + "/_update"));
 
         try (XContentParser parser = createParser(JsonXContent.jsonXContent, request.getEntity().getContent())) {
-            DataFrameTransformConfigUpdate parsedConfig = DataFrameTransformConfigUpdate.fromXContent(parser);
+            TransformConfigUpdate parsedConfig = TransformConfigUpdate.fromXContent(parser);
             assertThat(parsedConfig, equalTo(updateDataFrameTransformRequest.getUpdate()));
         }
         updateDataFrameTransformRequest.setDeferValidation(true);
-        request = DataFrameRequestConverters.updateDataFrameTransform(updateDataFrameTransformRequest);
+        request = TransformRequestConverters.updateTransform(updateDataFrameTransformRequest);
         assertThat(request.getParameters(),
             hasEntry("defer_validation", Boolean.toString(updateDataFrameTransformRequest.getDeferValidation())));
     }
 
     public void testDeleteDataFrameTransform() {
-        DeleteDataFrameTransformRequest deleteRequest = new DeleteDataFrameTransformRequest("foo");
-        Request request = DataFrameRequestConverters.deleteDataFrameTransform(deleteRequest);
+        DeleteTransformRequest deleteRequest = new DeleteTransformRequest("foo");
+        Request request = TransformRequestConverters.deleteTransform(deleteRequest);
 
         assertEquals(HttpDelete.METHOD_NAME, request.getMethod());
         assertThat(request.getEndpoint(), equalTo("/_data_frame/transforms/foo"));
@@ -113,7 +113,7 @@ public class DataFrameRequestConvertersTests extends ESTestCase {
         assertThat(request.getParameters(), not(hasKey("force")));
 
         deleteRequest.setForce(true);
-        request = DataFrameRequestConverters.deleteDataFrameTransform(deleteRequest);
+        request = TransformRequestConverters.deleteTransform(deleteRequest);
 
         assertThat(request.getParameters(), hasEntry("force", "true"));
     }
@@ -124,9 +124,9 @@ public class DataFrameRequestConvertersTests extends ESTestCase {
         if (randomBoolean()) {
             timeValue = TimeValue.parseTimeValue(randomTimeValue(), "timeout");
         }
-        StartDataFrameTransformRequest startRequest = new StartDataFrameTransformRequest(id, timeValue);
+        StartTransformRequest startRequest = new StartTransformRequest(id, timeValue);
 
-        Request request = DataFrameRequestConverters.startDataFrameTransform(startRequest);
+        Request request = TransformRequestConverters.startTransform(startRequest);
         assertEquals(HttpPost.METHOD_NAME, request.getMethod());
         assertThat(request.getEndpoint(), equalTo("/_data_frame/transforms/" + startRequest.getId() + "/_start"));
 
@@ -148,9 +148,9 @@ public class DataFrameRequestConvertersTests extends ESTestCase {
         if (randomBoolean()) {
             timeValue = TimeValue.parseTimeValue(randomTimeValue(), "timeout");
         }
-        StopDataFrameTransformRequest stopRequest = new StopDataFrameTransformRequest(id, waitForCompletion, timeValue);
+        StopTransformRequest stopRequest = new StopTransformRequest(id, waitForCompletion, timeValue);
 
-        Request request = DataFrameRequestConverters.stopDataFrameTransform(stopRequest);
+        Request request = TransformRequestConverters.stopTransform(stopRequest);
         assertEquals(HttpPost.METHOD_NAME, request.getMethod());
         assertThat(request.getEndpoint(), equalTo("/_data_frame/transforms/" + stopRequest.getId() + "/_stop"));
 
@@ -170,27 +170,27 @@ public class DataFrameRequestConvertersTests extends ESTestCase {
 
         assertFalse(request.getParameters().containsKey(ALLOW_NO_MATCH));
         stopRequest.setAllowNoMatch(randomBoolean());
-        request = DataFrameRequestConverters.stopDataFrameTransform(stopRequest);
+        request = TransformRequestConverters.stopTransform(stopRequest);
         assertEquals(stopRequest.getAllowNoMatch(), Boolean.parseBoolean(request.getParameters().get(ALLOW_NO_MATCH)));
     }
 
     public void testPreviewDataFrameTransform() throws IOException {
-        PreviewDataFrameTransformRequest previewRequest = new PreviewDataFrameTransformRequest(
-                DataFrameTransformConfigTests.randomDataFrameTransformConfig());
-        Request request = DataFrameRequestConverters.previewDataFrameTransform(previewRequest);
+        PreviewTransformRequest previewRequest = new PreviewTransformRequest(
+                TransformConfigTests.randomTransformConfig());
+        Request request = TransformRequestConverters.previewTransform(previewRequest);
 
         assertEquals(HttpPost.METHOD_NAME, request.getMethod());
         assertThat(request.getEndpoint(), equalTo("/_data_frame/transforms/_preview"));
 
         try (XContentParser parser = createParser(JsonXContent.jsonXContent, request.getEntity().getContent())) {
-            DataFrameTransformConfig parsedConfig = DataFrameTransformConfig.PARSER.apply(parser, null);
+            TransformConfig parsedConfig = TransformConfig.PARSER.apply(parser, null);
             assertThat(parsedConfig, equalTo(previewRequest.getConfig()));
         }
     }
 
     public void testGetDataFrameTransformStats() {
-        GetDataFrameTransformStatsRequest getStatsRequest = new GetDataFrameTransformStatsRequest("foo");
-        Request request = DataFrameRequestConverters.getDataFrameTransformStats(getStatsRequest);
+        GetTransformStatsRequest getStatsRequest = new GetTransformStatsRequest("foo");
+        Request request = TransformRequestConverters.getTransformStats(getStatsRequest);
 
         assertEquals(HttpGet.METHOD_NAME, request.getMethod());
         assertThat(request.getEndpoint(), equalTo("/_data_frame/transforms/foo/_stats"));
@@ -200,27 +200,27 @@ public class DataFrameRequestConvertersTests extends ESTestCase {
         assertFalse(request.getParameters().containsKey(ALLOW_NO_MATCH));
 
         getStatsRequest.setPageParams(new PageParams(0, null));
-        request = DataFrameRequestConverters.getDataFrameTransformStats(getStatsRequest);
+        request = TransformRequestConverters.getTransformStats(getStatsRequest);
         assertThat(request.getParameters(), hasEntry("from", "0"));
         assertEquals(null, request.getParameters().get("size"));
 
         getStatsRequest.setPageParams(new PageParams(null, 50));
-        request = DataFrameRequestConverters.getDataFrameTransformStats(getStatsRequest);
+        request = TransformRequestConverters.getTransformStats(getStatsRequest);
         assertEquals(null, request.getParameters().get("from"));
         assertThat(request.getParameters(), hasEntry("size", "50"));
 
         getStatsRequest.setPageParams(new PageParams(0, 10));
-        request = DataFrameRequestConverters.getDataFrameTransformStats(getStatsRequest);
+        request = TransformRequestConverters.getTransformStats(getStatsRequest);
         assertThat(request.getParameters(), allOf(hasEntry("from", "0"), hasEntry("size", "10")));
 
         getStatsRequest.setAllowNoMatch(false);
-        request = DataFrameRequestConverters.getDataFrameTransformStats(getStatsRequest);
+        request = TransformRequestConverters.getTransformStats(getStatsRequest);
         assertThat(request.getParameters(), hasEntry("allow_no_match", "false"));
     }
 
     public void testGetDataFrameTransform() {
-        GetDataFrameTransformRequest getRequest = new GetDataFrameTransformRequest("bar");
-        Request request = DataFrameRequestConverters.getDataFrameTransform(getRequest);
+        GetTransformRequest getRequest = new GetTransformRequest("bar");
+        Request request = TransformRequestConverters.getTransform(getRequest);
 
         assertEquals(HttpGet.METHOD_NAME, request.getMethod());
         assertThat(request.getEndpoint(), equalTo("/_data_frame/transforms/bar"));
@@ -230,27 +230,27 @@ public class DataFrameRequestConvertersTests extends ESTestCase {
         assertFalse(request.getParameters().containsKey(ALLOW_NO_MATCH));
 
         getRequest.setPageParams(new PageParams(0, null));
-        request = DataFrameRequestConverters.getDataFrameTransform(getRequest);
+        request = TransformRequestConverters.getTransform(getRequest);
         assertThat(request.getParameters(), hasEntry("from", "0"));
         assertEquals(null, request.getParameters().get("size"));
 
         getRequest.setPageParams(new PageParams(null, 50));
-        request = DataFrameRequestConverters.getDataFrameTransform(getRequest);
+        request = TransformRequestConverters.getTransform(getRequest);
         assertEquals(null, request.getParameters().get("from"));
         assertThat(request.getParameters(), hasEntry("size", "50"));
 
         getRequest.setPageParams(new PageParams(0, 10));
-        request = DataFrameRequestConverters.getDataFrameTransform(getRequest);
+        request = TransformRequestConverters.getTransform(getRequest);
         assertThat(request.getParameters(), allOf(hasEntry("from", "0"), hasEntry("size", "10")));
 
         getRequest.setAllowNoMatch(false);
-        request = DataFrameRequestConverters.getDataFrameTransform(getRequest);
+        request = TransformRequestConverters.getTransform(getRequest);
         assertThat(request.getParameters(), hasEntry("allow_no_match", "false"));
     }
 
     public void testGetDataFrameTransform_givenMulitpleIds() {
-        GetDataFrameTransformRequest getRequest = new GetDataFrameTransformRequest("foo", "bar", "baz");
-        Request request = DataFrameRequestConverters.getDataFrameTransform(getRequest);
+        GetTransformRequest getRequest = new GetTransformRequest("foo", "bar", "baz");
+        Request request = TransformRequestConverters.getTransform(getRequest);
 
         assertEquals(HttpGet.METHOD_NAME, request.getMethod());
         assertThat(request.getEndpoint(), equalTo("/_data_frame/transforms/foo,bar,baz"));

client/rest-high-level/src/test/java/org/elasticsearch/client/RestHighLevelClientTests.java

@@ -837,7 +837,7 @@ public class RestHighLevelClientTests extends ESTestCase {
                                 apiName.startsWith("security.") == false &&
                                 apiName.startsWith("index_lifecycle.") == false &&
                                 apiName.startsWith("ccr.") == false &&
-                                apiName.startsWith("data_frame") == false &&
+                                apiName.startsWith("transform.") == false &&
                                 apiName.endsWith("freeze") == false &&
                                 apiName.endsWith("reload_analyzers") == false &&
                                 // IndicesClientIT.getIndexTemplate should be renamed "getTemplate" in version 8.0 when we

client/rest-high-level/src/test/java/org/elasticsearch/client/TransformIT.java

@@ -28,24 +28,24 @@ import org.elasticsearch.client.core.AcknowledgedResponse;
 import org.elasticsearch.client.core.PageParams;
 import org.elasticsearch.client.indices.CreateIndexRequest;
 import org.elasticsearch.client.indices.CreateIndexResponse;
-import org.elasticsearch.client.transform.DeleteDataFrameTransformRequest;
-import org.elasticsearch.client.transform.GetDataFrameTransformRequest;
-import org.elasticsearch.client.transform.GetDataFrameTransformResponse;
-import org.elasticsearch.client.transform.GetDataFrameTransformStatsRequest;
-import org.elasticsearch.client.transform.GetDataFrameTransformStatsResponse;
-import org.elasticsearch.client.transform.PreviewDataFrameTransformRequest;
-import org.elasticsearch.client.transform.PreviewDataFrameTransformResponse;
-import org.elasticsearch.client.transform.PutDataFrameTransformRequest;
-import org.elasticsearch.client.transform.StartDataFrameTransformRequest;
-import org.elasticsearch.client.transform.StartDataFrameTransformResponse;
-import org.elasticsearch.client.transform.StopDataFrameTransformRequest;
-import org.elasticsearch.client.transform.StopDataFrameTransformResponse;
-import org.elasticsearch.client.transform.UpdateDataFrameTransformRequest;
-import org.elasticsearch.client.transform.UpdateDataFrameTransformResponse;
-import org.elasticsearch.client.transform.transforms.DataFrameIndexerTransformStats;
-import org.elasticsearch.client.transform.transforms.DataFrameTransformConfig;
-import org.elasticsearch.client.transform.transforms.DataFrameTransformConfigUpdate;
-import org.elasticsearch.client.transform.transforms.DataFrameTransformStats;
+import org.elasticsearch.client.transform.DeleteTransformRequest;
+import org.elasticsearch.client.transform.GetTransformRequest;
+import org.elasticsearch.client.transform.GetTransformResponse;
+import org.elasticsearch.client.transform.GetTransformStatsRequest;
+import org.elasticsearch.client.transform.GetTransformStatsResponse;
+import org.elasticsearch.client.transform.PreviewTransformRequest;
+import org.elasticsearch.client.transform.PreviewTransformResponse;
+import org.elasticsearch.client.transform.PutTransformRequest;
+import org.elasticsearch.client.transform.StartTransformRequest;
+import org.elasticsearch.client.transform.StartTransformResponse;
+import org.elasticsearch.client.transform.StopTransformRequest;
+import org.elasticsearch.client.transform.StopTransformResponse;
+import org.elasticsearch.client.transform.UpdateTransformRequest;
+import org.elasticsearch.client.transform.UpdateTransformResponse;
+import org.elasticsearch.client.transform.transforms.TransformIndexerStats;
+import org.elasticsearch.client.transform.transforms.TransformConfig;
+import org.elasticsearch.client.transform.transforms.TransformConfigUpdate;
+import org.elasticsearch.client.transform.transforms.TransformStats;
 import org.elasticsearch.client.transform.transforms.DestConfig;
 import org.elasticsearch.client.transform.transforms.SourceConfig;
 import org.elasticsearch.client.transform.transforms.TimeSyncConfig;
@@ -79,7 +79,7 @@ import static org.hamcrest.Matchers.hasSize;
 import static org.hamcrest.Matchers.is;
 import static org.hamcrest.Matchers.oneOf;
 
-public class DataFrameTransformIT extends ESRestHighLevelClientTestCase {
+public class TransformIT extends ESRestHighLevelClientTestCase {
 
     private List<String> transformsToClean = new ArrayList<>();
 
@@ -147,13 +147,13 @@ public class DataFrameTransformIT extends ESRestHighLevelClientTestCase {
     @After
     public void cleanUpTransforms() throws Exception {
         for (String transformId : transformsToClean) {
-            highLevelClient().dataFrame().stopDataFrameTransform(
-                    new StopDataFrameTransformRequest(transformId, Boolean.TRUE, null), RequestOptions.DEFAULT);
+            highLevelClient().transform().stopTransform(
+                    new StopTransformRequest(transformId, Boolean.TRUE, null), RequestOptions.DEFAULT);
         }
 
         for (String transformId : transformsToClean) {
-            highLevelClient().dataFrame().deleteDataFrameTransform(
-                    new DeleteDataFrameTransformRequest(transformId), RequestOptions.DEFAULT);
+            highLevelClient().transform().deleteTransform(
+                    new DeleteTransformRequest(transformId), RequestOptions.DEFAULT);
         }
 
         transformsToClean = new ArrayList<>();
@@ -165,21 +165,21 @@ public class DataFrameTransformIT extends ESRestHighLevelClientTestCase {
         createIndex(sourceIndex);
 
         String id = "test-crud";
-        DataFrameTransformConfig transform = validDataFrameTransformConfig(id, sourceIndex, "pivot-dest");
+        TransformConfig transform = validDataFrameTransformConfig(id, sourceIndex, "pivot-dest");
 
-        DataFrameClient client = highLevelClient().dataFrame();
-        AcknowledgedResponse ack = execute(new PutDataFrameTransformRequest(transform), client::putDataFrameTransform,
-                client::putDataFrameTransformAsync);
+        TransformClient client = highLevelClient().transform();
+        AcknowledgedResponse ack = execute(new PutTransformRequest(transform), client::putTransform,
+                client::putTransformAsync);
         assertTrue(ack.isAcknowledged());
 
-        ack = execute(new DeleteDataFrameTransformRequest(transform.getId()), client::deleteDataFrameTransform,
-                client::deleteDataFrameTransformAsync);
+        ack = execute(new DeleteTransformRequest(transform.getId()), client::deleteTransform,
+                client::deleteTransformAsync);
         assertTrue(ack.isAcknowledged());
 
         // The second delete should fail
         ElasticsearchStatusException deleteError = expectThrows(ElasticsearchStatusException.class,
-                () -> execute(new DeleteDataFrameTransformRequest(transform.getId()), client::deleteDataFrameTransform,
-                        client::deleteDataFrameTransformAsync));
+                () -> execute(new DeleteTransformRequest(transform.getId()), client::deleteTransform,
+                        client::deleteTransformAsync));
         assertThat(deleteError.getMessage(), containsString("Transform with id [test-crud] could not be found"));
     }
 
@@ -188,25 +188,25 @@ public class DataFrameTransformIT extends ESRestHighLevelClientTestCase {
         createIndex(sourceIndex);
 
         String id = "test-update";
-        DataFrameTransformConfig transform = validDataFrameTransformConfigBuilder(id, sourceIndex, "pivot-dest")
+        TransformConfig transform = validDataFrameTransformConfigBuilder(id, sourceIndex, "pivot-dest")
             .setSyncConfig(new TimeSyncConfig("timefield", TimeValue.timeValueSeconds(60)))
             .build();
 
-        DataFrameClient client = highLevelClient().dataFrame();
-        AcknowledgedResponse ack = execute(new PutDataFrameTransformRequest(transform), client::putDataFrameTransform,
-            client::putDataFrameTransformAsync);
+        TransformClient client = highLevelClient().transform();
+        AcknowledgedResponse ack = execute(new PutTransformRequest(transform), client::putTransform,
+            client::putTransformAsync);
         assertTrue(ack.isAcknowledged());
 
         String updatedDescription = "my new description";
-        DataFrameTransformConfigUpdate update = DataFrameTransformConfigUpdate.builder().setDescription(updatedDescription).build();
-        UpdateDataFrameTransformResponse response = execute(
-            new UpdateDataFrameTransformRequest(update, id), client::updateDataFrameTransform,
-            client::updateDataFrameTransformAsync);
+        TransformConfigUpdate update = TransformConfigUpdate.builder().setDescription(updatedDescription).build();
+        UpdateTransformResponse response = execute(
+            new UpdateTransformRequest(update, id), client::updateTransform,
+            client::updateTransformAsync);
         assertThat(response.getTransformConfiguration().getDescription(), equalTo(updatedDescription));
 
         ElasticsearchStatusException updateError = expectThrows(ElasticsearchStatusException.class,
-            () -> execute(new UpdateDataFrameTransformRequest(update, "missing-transform"), client::updateDataFrameTransform,
-                client::updateDataFrameTransformAsync));
+            () -> execute(new UpdateTransformRequest(update, "missing-transform"), client::updateTransform,
+                client::updateTransformAsync));
         assertThat(updateError.getMessage(), containsString("Transform with id [missing-transform] could not be found"));
     }
 
@@ -214,15 +214,15 @@ public class DataFrameTransformIT extends ESRestHighLevelClientTestCase {
         String sourceIndex = "missing-source-index";
 
         String id = "test-with-defer";
-        DataFrameTransformConfig transform = validDataFrameTransformConfig(id, sourceIndex, "pivot-dest");
-        DataFrameClient client = highLevelClient().dataFrame();
-        PutDataFrameTransformRequest request = new PutDataFrameTransformRequest(transform);
+        TransformConfig transform = validDataFrameTransformConfig(id, sourceIndex, "pivot-dest");
+        TransformClient client = highLevelClient().transform();
+        PutTransformRequest request = new PutTransformRequest(transform);
         request.setDeferValidation(true);
-        AcknowledgedResponse ack = execute(request, client::putDataFrameTransform, client::putDataFrameTransformAsync);
+        AcknowledgedResponse ack = execute(request, client::putTransform, client::putTransformAsync);
         assertTrue(ack.isAcknowledged());
 
-        ack = execute(new DeleteDataFrameTransformRequest(transform.getId()), client::deleteDataFrameTransform,
-            client::deleteDataFrameTransformAsync);
+        ack = execute(new DeleteTransformRequest(transform.getId()), client::deleteTransform,
+            client::deleteTransformAsync);
         assertTrue(ack.isAcknowledged());
     }
 
@@ -231,14 +231,14 @@ public class DataFrameTransformIT extends ESRestHighLevelClientTestCase {
         createIndex(sourceIndex);
 
         String id = "test-get";
-        DataFrameTransformConfig transform = validDataFrameTransformConfig(id, sourceIndex, "pivot-dest");
+        TransformConfig transform = validDataFrameTransformConfig(id, sourceIndex, "pivot-dest");
 
-        DataFrameClient client = highLevelClient().dataFrame();
+        TransformClient client = highLevelClient().transform();
         putTransform(transform);
 
-        GetDataFrameTransformRequest getRequest = new GetDataFrameTransformRequest(id);
-        GetDataFrameTransformResponse getResponse = execute(getRequest, client::getDataFrameTransform,
-                client::getDataFrameTransformAsync);
+        GetTransformRequest getRequest = new GetTransformRequest(id);
+        GetTransformResponse getResponse = execute(getRequest, client::getTransform,
+                client::getTransformAsync);
         assertNull(getResponse.getInvalidTransforms());
         assertThat(getResponse.getTransformConfigurations(), hasSize(1));
         assertEquals(transform.getId(), getResponse.getTransformConfigurations().get(0).getId());
@@ -248,40 +248,40 @@ public class DataFrameTransformIT extends ESRestHighLevelClientTestCase {
         String sourceIndex = "transform-source";
         createIndex(sourceIndex);
 
-        DataFrameClient client = highLevelClient().dataFrame();
+        TransformClient client = highLevelClient().transform();
 
-        DataFrameTransformConfig transform = validDataFrameTransformConfig("test-get-all-1", sourceIndex, "pivot-dest-1");
+        TransformConfig transform = validDataFrameTransformConfig("test-get-all-1", sourceIndex, "pivot-dest-1");
         putTransform(transform);
 
         transform = validDataFrameTransformConfig("test-get-all-2", sourceIndex, "pivot-dest-2");
         putTransform(transform);
 
-        GetDataFrameTransformRequest getRequest = new GetDataFrameTransformRequest("_all");
-        GetDataFrameTransformResponse getResponse = execute(getRequest, client::getDataFrameTransform,
-                client::getDataFrameTransformAsync);
+        GetTransformRequest getRequest = new GetTransformRequest("_all");
+        GetTransformResponse getResponse = execute(getRequest, client::getTransform,
+                client::getTransformAsync);
         assertNull(getResponse.getInvalidTransforms());
         assertThat(getResponse.getTransformConfigurations(), hasSize(2));
         assertEquals(transform.getId(), getResponse.getTransformConfigurations().get(1).getId());
 
         getRequest.setPageParams(new PageParams(0,1));
-        getResponse = execute(getRequest, client::getDataFrameTransform,
-                client::getDataFrameTransformAsync);
+        getResponse = execute(getRequest, client::getTransform,
+                client::getTransformAsync);
         assertNull(getResponse.getInvalidTransforms());
         assertThat(getResponse.getTransformConfigurations(), hasSize(1));
 
-        GetDataFrameTransformRequest getMulitple = new GetDataFrameTransformRequest("test-get-all-1", "test-get-all-2");
-        getResponse = execute(getMulitple, client::getDataFrameTransform,
-                client::getDataFrameTransformAsync);
+        GetTransformRequest getMulitple = new GetTransformRequest("test-get-all-1", "test-get-all-2");
+        getResponse = execute(getMulitple, client::getTransform,
+                client::getTransformAsync);
         assertNull(getResponse.getInvalidTransforms());
         assertThat(getResponse.getTransformConfigurations(), hasSize(2));
     }
 
     public void testGetMissingTransform() {
-        DataFrameClient client = highLevelClient().dataFrame();
+        TransformClient client = highLevelClient().transform();
 
         ElasticsearchStatusException missingError = expectThrows(ElasticsearchStatusException.class,
-                () -> execute(new GetDataFrameTransformRequest("unknown"), client::getDataFrameTransform,
-                        client::getDataFrameTransformAsync));
+                () -> execute(new GetTransformRequest("unknown"), client::getTransform,
+                        client::getTransformAsync));
         assertThat(missingError.status(), equalTo(RestStatus.NOT_FOUND));
     }
 
@@ -290,39 +290,39 @@ public class DataFrameTransformIT extends ESRestHighLevelClientTestCase {
         createIndex(sourceIndex);
 
         String id = "test-stop-start";
-        DataFrameTransformConfig transform = validDataFrameTransformConfig(id, sourceIndex, "pivot-dest");
+        TransformConfig transform = validDataFrameTransformConfig(id, sourceIndex, "pivot-dest");
 
-        DataFrameClient client = highLevelClient().dataFrame();
+        TransformClient client = highLevelClient().transform();
         putTransform(transform);
 
-        StartDataFrameTransformRequest startRequest = new StartDataFrameTransformRequest(id);
-        StartDataFrameTransformResponse startResponse =
-                execute(startRequest, client::startDataFrameTransform, client::startDataFrameTransformAsync);
+        StartTransformRequest startRequest = new StartTransformRequest(id);
+        StartTransformResponse startResponse =
+                execute(startRequest, client::startTransform, client::startTransformAsync);
         assertTrue(startResponse.isAcknowledged());
         assertThat(startResponse.getNodeFailures(), empty());
         assertThat(startResponse.getTaskFailures(), empty());
 
-        GetDataFrameTransformStatsResponse statsResponse = execute(new GetDataFrameTransformStatsRequest(id),
-                client::getDataFrameTransformStats, client::getDataFrameTransformStatsAsync);
+        GetTransformStatsResponse statsResponse = execute(new GetTransformStatsRequest(id),
+                client::getTransformStats, client::getTransformStatsAsync);
         assertThat(statsResponse.getTransformsStats(), hasSize(1));
-        DataFrameTransformStats.State taskState = statsResponse.getTransformsStats().get(0).getState();
+        TransformStats.State taskState = statsResponse.getTransformsStats().get(0).getState();
 
         // Since we are non-continuous, the transform could auto-stop between being started earlier and us gathering the statistics
-        assertThat(taskState, oneOf(DataFrameTransformStats.State.STARTED, DataFrameTransformStats.State.INDEXING,
-            DataFrameTransformStats.State.STOPPING, DataFrameTransformStats.State.STOPPED));
+        assertThat(taskState, oneOf(TransformStats.State.STARTED, TransformStats.State.INDEXING,
+            TransformStats.State.STOPPING, TransformStats.State.STOPPED));
 
-        StopDataFrameTransformRequest stopRequest = new StopDataFrameTransformRequest(id, Boolean.TRUE, null);
-        StopDataFrameTransformResponse stopResponse =
-                execute(stopRequest, client::stopDataFrameTransform, client::stopDataFrameTransformAsync);
+        StopTransformRequest stopRequest = new StopTransformRequest(id, Boolean.TRUE, null);
+        StopTransformResponse stopResponse =
+                execute(stopRequest, client::stopTransform, client::stopTransformAsync);
         assertTrue(stopResponse.isAcknowledged());
         assertThat(stopResponse.getNodeFailures(), empty());
         assertThat(stopResponse.getTaskFailures(), empty());
 
         // Calling stop with wait_for_completion assures that we will be in the `STOPPED` state for the transform task
-        statsResponse = execute(new GetDataFrameTransformStatsRequest(id),
-            client::getDataFrameTransformStats, client::getDataFrameTransformStatsAsync);
+        statsResponse = execute(new GetTransformStatsRequest(id),
+            client::getTransformStats, client::getTransformStatsAsync);
         taskState = statsResponse.getTransformsStats().get(0).getState();
-        assertThat(taskState, is(DataFrameTransformStats.State.STOPPED));
+        assertThat(taskState, is(TransformStats.State.STOPPED));
     }
 
     @SuppressWarnings("unchecked")
@@ -331,12 +331,12 @@ public class DataFrameTransformIT extends ESRestHighLevelClientTestCase {
         createIndex(sourceIndex);
         indexData(sourceIndex);
 
-        DataFrameTransformConfig transform = validDataFrameTransformConfig("test-preview", sourceIndex, null);
+        TransformConfig transform = validDataFrameTransformConfig("test-preview", sourceIndex, null);
 
-        DataFrameClient client = highLevelClient().dataFrame();
-        PreviewDataFrameTransformResponse preview = execute(new PreviewDataFrameTransformRequest(transform),
-                client::previewDataFrameTransform,
-                client::previewDataFrameTransformAsync);
+        TransformClient client = highLevelClient().transform();
+        PreviewTransformResponse preview = execute(new PreviewTransformRequest(transform),
+                client::previewTransform,
+                client::previewTransformAsync);
 
         List<Map<String, Object>> docs = preview.getDocs();
         assertThat(docs, hasSize(2));
@@ -355,11 +355,11 @@ public class DataFrameTransformIT extends ESRestHighLevelClientTestCase {
         assertThat(fields.get("avg_rating"), equalTo(Collections.singletonMap("type", "double")));
     }
 
-    private DataFrameTransformConfig validDataFrameTransformConfig(String id, String source, String destination) {
+    private TransformConfig validDataFrameTransformConfig(String id, String source, String destination) {
         return validDataFrameTransformConfigBuilder(id, source, destination).build();
     }
 
-    private DataFrameTransformConfig.Builder validDataFrameTransformConfigBuilder(String id, String source, String destination) {
+    private TransformConfig.Builder validDataFrameTransformConfigBuilder(String id, String source, String destination) {
         GroupConfig groupConfig = GroupConfig.builder().groupBy("reviewer",
             TermsGroupSource.builder().setField("user_id").build()).build();
         AggregatorFactories.Builder aggBuilder = new AggregatorFactories.Builder();
@@ -368,7 +368,7 @@ public class DataFrameTransformIT extends ESRestHighLevelClientTestCase {
 
         DestConfig destConfig = (destination != null) ? DestConfig.builder().setIndex(destination).build() : null;
 
-        return DataFrameTransformConfig.builder()
+        return TransformConfig.builder()
             .setId(id)
             .setSource(SourceConfig.builder().setIndex(source).setQuery(new MatchAllQueryBuilder()).build())
             .setDest(destConfig)
@@ -389,7 +389,7 @@ public class DataFrameTransformIT extends ESRestHighLevelClientTestCase {
         PivotConfig pivotConfig = PivotConfig.builder().setGroups(groupConfig).setAggregations(aggBuilder).build();
 
         String id = "test-get-stats";
-        DataFrameTransformConfig transform = DataFrameTransformConfig.builder()
+        TransformConfig transform = TransformConfig.builder()
             .setId(id)
             .setSource(SourceConfig.builder().setIndex(sourceIndex).setQuery(new MatchAllQueryBuilder()).build())
             .setDest(DestConfig.builder().setIndex("pivot-dest").build())
@@ -397,17 +397,17 @@ public class DataFrameTransformIT extends ESRestHighLevelClientTestCase {
             .setDescription("transform for testing stats")
             .build();
 
-        DataFrameClient client = highLevelClient().dataFrame();
+        TransformClient client = highLevelClient().transform();
         putTransform(transform);
 
-        GetDataFrameTransformStatsResponse statsResponse = execute(new GetDataFrameTransformStatsRequest(id),
-                client::getDataFrameTransformStats, client::getDataFrameTransformStatsAsync);
+        GetTransformStatsResponse statsResponse = execute(new GetTransformStatsRequest(id),
+                client::getTransformStats, client::getTransformStatsAsync);
 
         assertEquals(1, statsResponse.getTransformsStats().size());
-        DataFrameTransformStats stats = statsResponse.getTransformsStats().get(0);
-        assertEquals(DataFrameTransformStats.State.STOPPED, stats.getState());
+        TransformStats stats = statsResponse.getTransformsStats().get(0);
+        assertEquals(TransformStats.State.STOPPED, stats.getState());
 
-        DataFrameIndexerTransformStats zeroIndexerStats = new DataFrameIndexerTransformStats(
+        TransformIndexerStats zeroIndexerStats = new TransformIndexerStats(
             0L,
             0L,
             0L,
@@ -424,25 +424,25 @@ public class DataFrameTransformIT extends ESRestHighLevelClientTestCase {
         assertEquals(zeroIndexerStats, stats.getIndexerStats());
 
         // start the transform
-        StartDataFrameTransformResponse startTransformResponse = execute(new StartDataFrameTransformRequest(id),
-            client::startDataFrameTransform,
-            client::startDataFrameTransformAsync);
+        StartTransformResponse startTransformResponse = execute(new StartTransformRequest(id),
+            client::startTransform,
+            client::startTransformAsync);
         assertThat(startTransformResponse.isAcknowledged(), is(true));
         assertBusy(() -> {
-            GetDataFrameTransformStatsResponse response = execute(new GetDataFrameTransformStatsRequest(id),
-                    client::getDataFrameTransformStats, client::getDataFrameTransformStatsAsync);
-            DataFrameTransformStats stateAndStats = response.getTransformsStats().get(0);
+            GetTransformStatsResponse response = execute(new GetTransformStatsRequest(id),
+                    client::getTransformStats, client::getTransformStatsAsync);
+            TransformStats stateAndStats = response.getTransformsStats().get(0);
             assertNotEquals(zeroIndexerStats, stateAndStats.getIndexerStats());
-            assertThat(stateAndStats.getState(), oneOf(DataFrameTransformStats.State.STARTED, DataFrameTransformStats.State.INDEXING,
-                DataFrameTransformStats.State.STOPPING, DataFrameTransformStats.State.STOPPED));
+            assertThat(stateAndStats.getState(), oneOf(TransformStats.State.STARTED, TransformStats.State.INDEXING,
+                TransformStats.State.STOPPING, TransformStats.State.STOPPED));
             assertThat(stateAndStats.getReason(), is(nullValue()));
         });
     }
 
-    void putTransform(DataFrameTransformConfig config) throws IOException {
-        DataFrameClient client = highLevelClient().dataFrame();
-        AcknowledgedResponse ack = execute(new PutDataFrameTransformRequest(config), client::putDataFrameTransform,
-            client::putDataFrameTransformAsync);
+    void putTransform(TransformConfig config) throws IOException {
+        TransformClient client = highLevelClient().transform();
+        AcknowledgedResponse ack = execute(new PutTransformRequest(config), client::putTransform,
+            client::putTransformAsync);
         assertTrue(ack.isAcknowledged());
         transformsToClean.add(config.getId());
     }

client/rest-high-level/src/test/java/org/elasticsearch/client/documentation/TransformDocumentationIT.java

@@ -28,25 +28,25 @@ import org.elasticsearch.client.core.AcknowledgedResponse;
 import org.elasticsearch.client.core.PageParams;
 import org.elasticsearch.client.indices.CreateIndexRequest;
 import org.elasticsearch.client.indices.CreateIndexResponse;
-import org.elasticsearch.client.transform.DeleteDataFrameTransformRequest;
-import org.elasticsearch.client.transform.GetDataFrameTransformRequest;
-import org.elasticsearch.client.transform.GetDataFrameTransformResponse;
-import org.elasticsearch.client.transform.GetDataFrameTransformStatsRequest;
-import org.elasticsearch.client.transform.GetDataFrameTransformStatsResponse;
-import org.elasticsearch.client.transform.PreviewDataFrameTransformRequest;
-import org.elasticsearch.client.transform.PreviewDataFrameTransformResponse;
-import org.elasticsearch.client.transform.PutDataFrameTransformRequest;
-import org.elasticsearch.client.transform.StartDataFrameTransformRequest;
-import org.elasticsearch.client.transform.StartDataFrameTransformResponse;
-import org.elasticsearch.client.transform.StopDataFrameTransformRequest;
-import org.elasticsearch.client.transform.StopDataFrameTransformResponse;
-import org.elasticsearch.client.transform.UpdateDataFrameTransformRequest;
-import org.elasticsearch.client.transform.UpdateDataFrameTransformResponse;
-import org.elasticsearch.client.transform.transforms.DataFrameIndexerTransformStats;
-import org.elasticsearch.client.transform.transforms.DataFrameTransformConfig;
-import org.elasticsearch.client.transform.transforms.DataFrameTransformConfigUpdate;
-import org.elasticsearch.client.transform.transforms.DataFrameTransformProgress;
-import org.elasticsearch.client.transform.transforms.DataFrameTransformStats;
+import org.elasticsearch.client.transform.DeleteTransformRequest;
+import org.elasticsearch.client.transform.GetTransformRequest;
+import org.elasticsearch.client.transform.GetTransformResponse;
+import org.elasticsearch.client.transform.GetTransformStatsRequest;
+import org.elasticsearch.client.transform.GetTransformStatsResponse;
+import org.elasticsearch.client.transform.PreviewTransformRequest;
+import org.elasticsearch.client.transform.PreviewTransformResponse;
+import org.elasticsearch.client.transform.PutTransformRequest;
+import org.elasticsearch.client.transform.StartTransformRequest;
+import org.elasticsearch.client.transform.StartTransformResponse;
+import org.elasticsearch.client.transform.StopTransformRequest;
+import org.elasticsearch.client.transform.StopTransformResponse;
+import org.elasticsearch.client.transform.UpdateTransformRequest;
+import org.elasticsearch.client.transform.UpdateTransformResponse;
+import org.elasticsearch.client.transform.transforms.TransformIndexerStats;
+import org.elasticsearch.client.transform.transforms.TransformConfig;
+import org.elasticsearch.client.transform.transforms.TransformConfigUpdate;
+import org.elasticsearch.client.transform.transforms.TransformProgress;
+import org.elasticsearch.client.transform.transforms.TransformStats;
 import org.elasticsearch.client.transform.transforms.DestConfig;
 import org.elasticsearch.client.transform.transforms.NodeAttributes;
 import org.elasticsearch.client.transform.transforms.QueryConfig;
@@ -73,20 +73,20 @@ import static org.elasticsearch.common.xcontent.XContentFactory.jsonBuilder;
 import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.hasSize;
 
-public class DataFrameTransformDocumentationIT extends ESRestHighLevelClientTestCase {
+public class TransformDocumentationIT extends ESRestHighLevelClientTestCase {
 
     private List<String> transformsToClean = new ArrayList<>();
 
     @After
     public void cleanUpTransforms() throws Exception {
         for (String transformId : transformsToClean) {
-            highLevelClient().dataFrame().stopDataFrameTransform(
-                    new StopDataFrameTransformRequest(transformId, Boolean.TRUE, TimeValue.timeValueSeconds(20)), RequestOptions.DEFAULT);
+            highLevelClient().transform().stopTransform(
+                    new StopTransformRequest(transformId, Boolean.TRUE, TimeValue.timeValueSeconds(20)), RequestOptions.DEFAULT);
         }
 
         for (String transformId : transformsToClean) {
-            highLevelClient().dataFrame().deleteDataFrameTransform(
-                    new DeleteDataFrameTransformRequest(transformId), RequestOptions.DEFAULT);
+            highLevelClient().transform().deleteTransform(
+                    new DeleteTransformRequest(transformId), RequestOptions.DEFAULT);
         }
 
         transformsToClean = new ArrayList<>();
@@ -116,7 +116,7 @@ public class DataFrameTransformDocumentationIT extends ESRestHighLevelClientTest
         assertTrue(response.isAcknowledged());
     }
 
-    public void testPutDataFrameTransform() throws IOException, InterruptedException {
+    public void testPutTransform() throws IOException, InterruptedException {
         createIndex("source-index");
 
         RestHighLevelClient client = highLevelClient();
@@ -154,7 +154,7 @@ public class DataFrameTransformDocumentationIT extends ESRestHighLevelClientTest
             .build();
         // end::put-transform-pivot-config
         // tag::put-transform-config
-        DataFrameTransformConfig transformConfig = DataFrameTransformConfig
+        TransformConfig transformConfig = TransformConfig
             .builder()
             .setId("reviewer-avg-rating") // <1>
             .setSource(sourceConfig) // <2>
@@ -167,14 +167,14 @@ public class DataFrameTransformDocumentationIT extends ESRestHighLevelClientTest
 
         {
             // tag::put-transform-request
-            PutDataFrameTransformRequest request =
-                    new PutDataFrameTransformRequest(transformConfig); // <1>
+            PutTransformRequest request =
+                    new PutTransformRequest(transformConfig); // <1>
             request.setDeferValidation(false); // <2>
             // end::put-transform-request
 
             // tag::put-transform-execute
             AcknowledgedResponse response =
-                    client.dataFrame().putDataFrameTransform(
+                    client.transform().putTransform(
                             request, RequestOptions.DEFAULT);
             // end::put-transform-execute
             transformsToClean.add(request.getConfig().getId());
@@ -182,13 +182,13 @@ public class DataFrameTransformDocumentationIT extends ESRestHighLevelClientTest
             assertTrue(response.isAcknowledged());
         }
         {
-            DataFrameTransformConfig configWithDifferentId = DataFrameTransformConfig.builder()
+            TransformConfig configWithDifferentId = TransformConfig.builder()
                 .setId("reviewer-avg-rating2")
                 .setSource(transformConfig.getSource())
                 .setDest(transformConfig.getDestination())
                 .setPivotConfig(transformConfig.getPivotConfig())
                 .build();
-            PutDataFrameTransformRequest request = new PutDataFrameTransformRequest(configWithDifferentId);
+            PutTransformRequest request = new PutTransformRequest(configWithDifferentId);
 
             // tag::put-transform-execute-listener
             ActionListener<AcknowledgedResponse> listener =
@@ -210,7 +210,7 @@ public class DataFrameTransformDocumentationIT extends ESRestHighLevelClientTest
             listener = new LatchedActionListener<>(listener, latch);
 
             // tag::put-transform-execute-async
-            client.dataFrame().putDataFrameTransformAsync(
+            client.transform().putTransformAsync(
                     request, RequestOptions.DEFAULT, listener); // <1>
             // end::put-transform-execute-async
 
@@ -231,7 +231,7 @@ public class DataFrameTransformDocumentationIT extends ESRestHighLevelClientTest
         AggregationConfig aggConfig = new AggregationConfig(aggBuilder);
         PivotConfig pivotConfig = PivotConfig.builder().setGroups(groupConfig).setAggregationConfig(aggConfig).build();
 
-        DataFrameTransformConfig transformConfig = DataFrameTransformConfig.builder()
+        TransformConfig transformConfig = TransformConfig.builder()
             .setId("my-transform-to-update")
             .setSource(SourceConfig.builder().setIndex("source-data").setQueryConfig(queryConfig).build())
             .setDest(DestConfig.builder().setIndex("pivot-dest").build())
@@ -239,11 +239,11 @@ public class DataFrameTransformDocumentationIT extends ESRestHighLevelClientTest
             .setSyncConfig(new TimeSyncConfig("time-field", TimeValue.timeValueSeconds(120)))
             .build();
 
-        client.dataFrame().putDataFrameTransform(new PutDataFrameTransformRequest(transformConfig), RequestOptions.DEFAULT);
+        client.transform().putTransform(new PutTransformRequest(transformConfig), RequestOptions.DEFAULT);
         transformsToClean.add(transformConfig.getId());
 
         // tag::update-transform-config
-        DataFrameTransformConfigUpdate update = DataFrameTransformConfigUpdate
+        TransformConfigUpdate update = TransformConfigUpdate
             .builder()
             .setSource(SourceConfig.builder()
                 .setIndex("source-data")
@@ -260,32 +260,32 @@ public class DataFrameTransformDocumentationIT extends ESRestHighLevelClientTest
 
         {
         // tag::update-transform-request
-        UpdateDataFrameTransformRequest request =
-            new UpdateDataFrameTransformRequest(
+        UpdateTransformRequest request =
+            new UpdateTransformRequest(
                 update, // <1>
                 "my-transform-to-update"); // <2>
         request.setDeferValidation(false); // <3>
         // end::update-transform-request
 
         // tag::update-transform-execute
-        UpdateDataFrameTransformResponse response =
-            client.dataFrame().updateDataFrameTransform(request,
+        UpdateTransformResponse response =
+            client.transform().updateTransform(request,
                 RequestOptions.DEFAULT);
-        DataFrameTransformConfig updatedConfig =
+        TransformConfig updatedConfig =
             response.getTransformConfiguration();
         // end::update-transform-execute
 
         assertThat(updatedConfig.getDescription(), equalTo("This is my updated transform"));
         }
         {
-        UpdateDataFrameTransformRequest request = new UpdateDataFrameTransformRequest(update,
+        UpdateTransformRequest request = new UpdateTransformRequest(update,
             "my-transform-to-update");
 
         // tag::update-transform-execute-listener
-        ActionListener<UpdateDataFrameTransformResponse> listener =
-            new ActionListener<UpdateDataFrameTransformResponse>() {
+        ActionListener<UpdateTransformResponse> listener =
+            new ActionListener<UpdateTransformResponse>() {
                 @Override
-                public void onResponse(UpdateDataFrameTransformResponse response) {
+                public void onResponse(UpdateTransformResponse response) {
                     // <1>
                 }
 
@@ -301,7 +301,7 @@ public class DataFrameTransformDocumentationIT extends ESRestHighLevelClientTest
         listener = new LatchedActionListener<>(listener, latch);
 
         // tag::update-transform-execute-async
-        client.dataFrame().updateDataFrameTransformAsync(
+        client.transform().updateTransformAsync(
             request, RequestOptions.DEFAULT, listener); // <1>
         // end::update-transform-execute-async
 
@@ -322,20 +322,20 @@ public class DataFrameTransformDocumentationIT extends ESRestHighLevelClientTest
         AggregationConfig aggConfig = new AggregationConfig(aggBuilder);
         PivotConfig pivotConfig = PivotConfig.builder().setGroups(groupConfig).setAggregationConfig(aggConfig).build();
 
-        DataFrameTransformConfig transformConfig = DataFrameTransformConfig.builder()
+        TransformConfig transformConfig = TransformConfig.builder()
             .setId("mega-transform")
             .setSource(SourceConfig.builder().setIndex("source-data").setQueryConfig(queryConfig).build())
             .setDest(DestConfig.builder().setIndex("pivot-dest").build())
             .setPivotConfig(pivotConfig)
             .build();
 
-        client.dataFrame().putDataFrameTransform(new PutDataFrameTransformRequest(transformConfig), RequestOptions.DEFAULT);
+        client.transform().putTransform(new PutTransformRequest(transformConfig), RequestOptions.DEFAULT);
         transformsToClean.add(transformConfig.getId());
 
         {
             // tag::start-transform-request
-            StartDataFrameTransformRequest request =
-                    new StartDataFrameTransformRequest("mega-transform");  // <1>
+            StartTransformRequest request =
+                    new StartTransformRequest("mega-transform");  // <1>
             // end::start-transform-request
 
             // tag::start-transform-request-options
@@ -343,8 +343,8 @@ public class DataFrameTransformDocumentationIT extends ESRestHighLevelClientTest
             // end::start-transform-request-options
 
             // tag::start-transform-execute
-            StartDataFrameTransformResponse response =
-                    client.dataFrame().startDataFrameTransform(
+            StartTransformResponse response =
+                    client.transform().startTransform(
                             request, RequestOptions.DEFAULT);
             // end::start-transform-execute
 
@@ -352,8 +352,8 @@ public class DataFrameTransformDocumentationIT extends ESRestHighLevelClientTest
         }
         {
             // tag::stop-transform-request
-            StopDataFrameTransformRequest request =
-                    new StopDataFrameTransformRequest("mega-transform"); // <1>
+            StopTransformRequest request =
+                    new StopTransformRequest("mega-transform"); // <1>
             // end::stop-transform-request
 
             // tag::stop-transform-request-options
@@ -363,8 +363,8 @@ public class DataFrameTransformDocumentationIT extends ESRestHighLevelClientTest
             // end::stop-transform-request-options
 
             // tag::stop-transform-execute
-            StopDataFrameTransformResponse response =
-                    client.dataFrame().stopDataFrameTransform(
+            StopTransformResponse response =
+                    client.transform().stopTransform(
                             request, RequestOptions.DEFAULT);
             // end::stop-transform-execute
 
@@ -372,11 +372,11 @@ public class DataFrameTransformDocumentationIT extends ESRestHighLevelClientTest
         }
         {
             // tag::start-transform-execute-listener
-            ActionListener<StartDataFrameTransformResponse> listener =
-                    new ActionListener<StartDataFrameTransformResponse>() {
+            ActionListener<StartTransformResponse> listener =
+                    new ActionListener<StartTransformResponse>() {
                         @Override
                         public void onResponse(
-                                StartDataFrameTransformResponse response) {
+                                StartTransformResponse response) {
                             // <1>
                         }
 
@@ -391,9 +391,9 @@ public class DataFrameTransformDocumentationIT extends ESRestHighLevelClientTest
             final CountDownLatch latch = new CountDownLatch(1);
             listener = new LatchedActionListener<>(listener, latch);
 
-            StartDataFrameTransformRequest request = new StartDataFrameTransformRequest("mega-transform");
+            StartTransformRequest request = new StartTransformRequest("mega-transform");
             // tag::start-transform-execute-async
-            client.dataFrame().startDataFrameTransformAsync(
+            client.transform().startTransformAsync(
                     request, RequestOptions.DEFAULT, listener); // <1>
             // end::start-transform-execute-async
 
@@ -401,11 +401,11 @@ public class DataFrameTransformDocumentationIT extends ESRestHighLevelClientTest
         }
         {
             // tag::stop-transform-execute-listener
-            ActionListener<StopDataFrameTransformResponse> listener =
-                    new ActionListener<StopDataFrameTransformResponse>() {
+            ActionListener<StopTransformResponse> listener =
+                    new ActionListener<StopTransformResponse>() {
                         @Override
                         public void onResponse(
-                                StopDataFrameTransformResponse response) {
+                                StopTransformResponse response) {
                             // <1>
                         }
 
@@ -420,9 +420,9 @@ public class DataFrameTransformDocumentationIT extends ESRestHighLevelClientTest
             final CountDownLatch latch = new CountDownLatch(1);
             listener = new LatchedActionListener<>(listener, latch);
 
-            StopDataFrameTransformRequest request = new StopDataFrameTransformRequest("mega-transform");
+            StopTransformRequest request = new StopTransformRequest("mega-transform");
             // tag::stop-transform-execute-async
-            client.dataFrame().stopDataFrameTransformAsync(
+            client.transform().stopTransformAsync(
                     request, RequestOptions.DEFAULT, listener); // <1>
             // end::stop-transform-execute-async
 
@@ -442,7 +442,7 @@ public class DataFrameTransformDocumentationIT extends ESRestHighLevelClientTest
         AggregationConfig aggConfig = new AggregationConfig(aggBuilder);
         PivotConfig pivotConfig = PivotConfig.builder().setGroups(groupConfig).setAggregationConfig(aggConfig).build();
 
-        DataFrameTransformConfig transformConfig1 = DataFrameTransformConfig.builder()
+        TransformConfig transformConfig1 = TransformConfig.builder()
             .setId("mega-transform")
             .setSource(SourceConfig.builder()
                 .setIndex("source-data")
@@ -451,7 +451,7 @@ public class DataFrameTransformDocumentationIT extends ESRestHighLevelClientTest
             .setDest(DestConfig.builder().setIndex("pivot-dest").build())
             .setPivotConfig(pivotConfig)
             .build();
-        DataFrameTransformConfig transformConfig2 = DataFrameTransformConfig.builder()
+        TransformConfig transformConfig2 = TransformConfig.builder()
             .setId("mega-transform2")
             .setSource(SourceConfig.builder()
                 .setIndex("source-data")
@@ -461,20 +461,20 @@ public class DataFrameTransformDocumentationIT extends ESRestHighLevelClientTest
             .setPivotConfig(pivotConfig)
             .build();
 
-        client.dataFrame().putDataFrameTransform(new PutDataFrameTransformRequest(transformConfig1), RequestOptions.DEFAULT);
-        client.dataFrame().putDataFrameTransform(new PutDataFrameTransformRequest(transformConfig2), RequestOptions.DEFAULT);
+        client.transform().putTransform(new PutTransformRequest(transformConfig1), RequestOptions.DEFAULT);
+        client.transform().putTransform(new PutTransformRequest(transformConfig2), RequestOptions.DEFAULT);
 
         {
             // tag::delete-transform-request
-            DeleteDataFrameTransformRequest request =
-                    new DeleteDataFrameTransformRequest("mega-transform"); // <1>
+            DeleteTransformRequest request =
+                    new DeleteTransformRequest("mega-transform"); // <1>
             request.setForce(false); // <2>
             // end::delete-transform-request
 
             // tag::delete-transform-execute
             AcknowledgedResponse response =
-                    client.dataFrame()
-                    .deleteDataFrameTransform(request, RequestOptions.DEFAULT);
+                    client.transform()
+                    .deleteTransform(request, RequestOptions.DEFAULT);
             // end::delete-transform-execute
 
             assertTrue(response.isAcknowledged());
@@ -499,10 +499,10 @@ public class DataFrameTransformDocumentationIT extends ESRestHighLevelClientTest
             final CountDownLatch latch = new CountDownLatch(1);
             listener = new LatchedActionListener<>(listener, latch);
 
-            DeleteDataFrameTransformRequest request = new DeleteDataFrameTransformRequest("mega-transform2");
+            DeleteTransformRequest request = new DeleteTransformRequest("mega-transform2");
 
             // tag::delete-transform-execute-async
-            client.dataFrame().deleteDataFrameTransformAsync(
+            client.transform().deleteTransformAsync(
                     request, RequestOptions.DEFAULT, listener);  // <1>
             // end::delete-transform-execute-async
 
@@ -524,23 +524,23 @@ public class DataFrameTransformDocumentationIT extends ESRestHighLevelClientTest
         PivotConfig pivotConfig = PivotConfig.builder().setGroups(groupConfig).setAggregationConfig(aggConfig).build();
 
         // tag::preview-transform-request
-        DataFrameTransformConfig transformConfig =
-            DataFrameTransformConfig.forPreview(
+        TransformConfig transformConfig =
+            TransformConfig.forPreview(
                 SourceConfig.builder()
                     .setIndex("source-data")
                     .setQueryConfig(queryConfig)
                     .build(), // <1>
                 pivotConfig); // <2>
 
-        PreviewDataFrameTransformRequest request =
-                new PreviewDataFrameTransformRequest(transformConfig); // <3>
+        PreviewTransformRequest request =
+                new PreviewTransformRequest(transformConfig); // <3>
         // end::preview-transform-request
 
         {
             // tag::preview-transform-execute
-            PreviewDataFrameTransformResponse response =
-                client.dataFrame()
-                    .previewDataFrameTransform(request, RequestOptions.DEFAULT);
+            PreviewTransformResponse response =
+                client.transform()
+                    .previewTransform(request, RequestOptions.DEFAULT);
             // end::preview-transform-execute
 
             assertNotNull(response.getDocs());
@@ -548,10 +548,10 @@ public class DataFrameTransformDocumentationIT extends ESRestHighLevelClientTest
         }
         {
             // tag::preview-transform-execute-listener
-            ActionListener<PreviewDataFrameTransformResponse> listener =
-                new ActionListener<PreviewDataFrameTransformResponse>() {
+            ActionListener<PreviewTransformResponse> listener =
+                new ActionListener<PreviewTransformResponse>() {
                     @Override
-                    public void onResponse(PreviewDataFrameTransformResponse response) {
+                    public void onResponse(PreviewTransformResponse response) {
                         // <1>
                     }
 
@@ -567,7 +567,7 @@ public class DataFrameTransformDocumentationIT extends ESRestHighLevelClientTest
             listener = new LatchedActionListener<>(listener, latch);
 
             // tag::preview-transform-execute-async
-            client.dataFrame().previewDataFrameTransformAsync(
+            client.transform().previewTransformAsync(
                     request, RequestOptions.DEFAULT, listener);  // <1>
             // end::preview-transform-execute-async
 
@@ -588,7 +588,7 @@ public class DataFrameTransformDocumentationIT extends ESRestHighLevelClientTest
         PivotConfig pivotConfig = PivotConfig.builder().setGroups(groupConfig).setAggregationConfig(aggConfig).build();
 
         String id = "statisitcal-transform";
-        DataFrameTransformConfig transformConfig = DataFrameTransformConfig.builder()
+        TransformConfig transformConfig = TransformConfig.builder()
             .setId(id)
             .setSource(SourceConfig.builder()
                 .setIndex("source-data")
@@ -597,12 +597,12 @@ public class DataFrameTransformDocumentationIT extends ESRestHighLevelClientTest
             .setDest(DestConfig.builder().setIndex("pivot-dest").build())
             .setPivotConfig(pivotConfig)
             .build();
-        client.dataFrame().putDataFrameTransform(new PutDataFrameTransformRequest(transformConfig), RequestOptions.DEFAULT);
+        client.transform().putTransform(new PutTransformRequest(transformConfig), RequestOptions.DEFAULT);
         transformsToClean.add(id);
 
         // tag::get-transform-stats-request
-        GetDataFrameTransformStatsRequest request =
-                new GetDataFrameTransformStatsRequest(id); // <1>
+        GetTransformStatsRequest request =
+                new GetTransformStatsRequest(id); // <1>
         // end::get-transform-stats-request
 
         // tag::get-transform-stats-request-options
@@ -612,38 +612,38 @@ public class DataFrameTransformDocumentationIT extends ESRestHighLevelClientTest
 
         {
             // tag::get-transform-stats-execute
-            GetDataFrameTransformStatsResponse response =
-                client.dataFrame()
-                    .getDataFrameTransformStats(request, RequestOptions.DEFAULT);
+            GetTransformStatsResponse response =
+                client.transform()
+                    .getTransformStats(request, RequestOptions.DEFAULT);
             // end::get-transform-stats-execute
 
             assertThat(response.getTransformsStats(), hasSize(1));
 
             // tag::get-transform-stats-response
-            DataFrameTransformStats stats =
+            TransformStats stats =
                 response.getTransformsStats().get(0); // <1>
-            DataFrameTransformStats.State state =
+            TransformStats.State state =
                 stats.getState(); // <2>
-            DataFrameIndexerTransformStats indexerStats =
+            TransformIndexerStats indexerStats =
                 stats.getIndexerStats(); // <3>
-            DataFrameTransformProgress progress =
+            TransformProgress progress =
                 stats.getCheckpointingInfo()
                     .getNext().getCheckpointProgress(); // <4>
             NodeAttributes node =
                 stats.getNode(); // <5>
             // end::get-transform-stats-response
 
-            assertEquals(DataFrameTransformStats.State.STOPPED, state);
+            assertEquals(TransformStats.State.STOPPED, state);
             assertNotNull(indexerStats);
             assertNull(progress);
         }
         {
             // tag::get-transform-stats-execute-listener
-            ActionListener<GetDataFrameTransformStatsResponse> listener =
-                    new ActionListener<GetDataFrameTransformStatsResponse>() {
+            ActionListener<GetTransformStatsResponse> listener =
+                    new ActionListener<GetTransformStatsResponse>() {
                         @Override
                         public void onResponse(
-                                GetDataFrameTransformStatsResponse response) {
+                                GetTransformStatsResponse response) {
                             // <1>
                         }
 
@@ -659,7 +659,7 @@ public class DataFrameTransformDocumentationIT extends ESRestHighLevelClientTest
             listener = new LatchedActionListener<>(listener, latch);
 
             // tag::get-transform-stats-execute-async
-            client.dataFrame().getDataFrameTransformStatsAsync(
+            client.transform().getTransformStatsAsync(
                     request, RequestOptions.DEFAULT, listener);  // <1>
             // end::get-transform-stats-execute-async
 
@@ -679,7 +679,7 @@ public class DataFrameTransformDocumentationIT extends ESRestHighLevelClientTest
         PivotConfig pivotConfig = PivotConfig.builder().setGroups(groupConfig).setAggregationConfig(aggConfig).build();
 
 
-        DataFrameTransformConfig putTransformConfig = DataFrameTransformConfig.builder()
+        TransformConfig putTransformConfig = TransformConfig.builder()
             .setId("mega-transform")
             .setSource(SourceConfig.builder()
                 .setIndex("source-data")
@@ -690,13 +690,13 @@ public class DataFrameTransformDocumentationIT extends ESRestHighLevelClientTest
             .build();
 
         RestHighLevelClient client = highLevelClient();
-        client.dataFrame().putDataFrameTransform(new PutDataFrameTransformRequest(putTransformConfig), RequestOptions.DEFAULT);
+        client.transform().putTransform(new PutTransformRequest(putTransformConfig), RequestOptions.DEFAULT);
         transformsToClean.add(putTransformConfig.getId());
 
         {
             // tag::get-transform-request
-            GetDataFrameTransformRequest request =
-                    new GetDataFrameTransformRequest("mega-transform"); // <1>
+            GetTransformRequest request =
+                    new GetTransformRequest("mega-transform"); // <1>
             // end::get-transform-request
 
             // tag::get-transform-request-options
@@ -705,13 +705,13 @@ public class DataFrameTransformDocumentationIT extends ESRestHighLevelClientTest
             // end::get-transform-request-options
 
             // tag::get-transform-execute
-            GetDataFrameTransformResponse response =
-                client.dataFrame()
-                    .getDataFrameTransform(request, RequestOptions.DEFAULT);
+            GetTransformResponse response =
+                client.transform()
+                    .getTransform(request, RequestOptions.DEFAULT);
             // end::get-transform-execute
 
             // tag::get-transform-response
-            List<DataFrameTransformConfig> transformConfigs =
+            List<TransformConfig> transformConfigs =
                     response.getTransformConfigurations();
             // end::get-transform-response
 
@@ -719,10 +719,10 @@ public class DataFrameTransformDocumentationIT extends ESRestHighLevelClientTest
         }
         {
             // tag::get-transform-execute-listener
-            ActionListener<GetDataFrameTransformResponse> listener =
-                new ActionListener<GetDataFrameTransformResponse>() {
+            ActionListener<GetTransformResponse> listener =
+                new ActionListener<GetTransformResponse>() {
                     @Override
-                    public void onResponse(GetDataFrameTransformResponse response) {
+                    public void onResponse(GetTransformResponse response) {
                         // <1>
                     }
 
@@ -737,10 +737,10 @@ public class DataFrameTransformDocumentationIT extends ESRestHighLevelClientTest
             final CountDownLatch latch = new CountDownLatch(1);
             listener = new LatchedActionListener<>(listener, latch);
 
-            GetDataFrameTransformRequest request = new GetDataFrameTransformRequest("mega-transform");
+            GetTransformRequest request = new GetTransformRequest("mega-transform");
 
             // tag::get-transform-execute-async
-            client.dataFrame().getDataFrameTransformAsync(
+            client.transform().getTransformAsync(
                     request, RequestOptions.DEFAULT, listener);  // <1>
             // end::get-transform-execute-async
 

client/rest-high-level/src/test/java/org/elasticsearch/client/transform/DeleteTransformRequestTests.java

@@ -23,11 +23,11 @@ import org.elasticsearch.test.ESTestCase;
 
 import static org.hamcrest.Matchers.containsString;
 
-public class DeleteDataFrameTransformRequestTests extends ESTestCase {
+public class DeleteTransformRequestTests extends ESTestCase {
 
     public void testValidate() {
-        assertFalse(new DeleteDataFrameTransformRequest("valid-id").validate().isPresent());
-        assertThat(new DeleteDataFrameTransformRequest(null).validate().get().getMessage(),
-                containsString("data frame transform id must not be null"));
+        assertFalse(new DeleteTransformRequest("valid-id").validate().isPresent());
+        assertThat(new DeleteTransformRequest(null).validate().get().getMessage(),
+                containsString("transform id must not be null"));
     }
 }

client/rest-high-level/src/test/java/org/elasticsearch/client/transform/GetTransformRequestTests.java

@@ -23,10 +23,10 @@ import org.elasticsearch.test.ESTestCase;
 
 import static org.hamcrest.Matchers.containsString;
 
-public class GetDataFrameTransformRequestTests extends ESTestCase {
+public class GetTransformRequestTests extends ESTestCase {
     public void testValidate() {
-        assertFalse(new GetDataFrameTransformRequest("valid-id").validate().isPresent());
-        assertThat(new GetDataFrameTransformRequest(new String[0]).validate().get().getMessage(),
-                containsString("data frame transform id must not be null"));
+        assertFalse(new GetTransformRequest("valid-id").validate().isPresent());
+        assertThat(new GetTransformRequest(new String[0]).validate().get().getMessage(),
+                containsString("transform id must not be null"));
     }
 }

client/rest-high-level/src/test/java/org/elasticsearch/client/transform/GetTransformResponseTests.java

@@ -19,8 +19,8 @@
 
 package org.elasticsearch.client.transform;
 
-import org.elasticsearch.client.transform.transforms.DataFrameTransformConfig;
-import org.elasticsearch.client.transform.transforms.DataFrameTransformConfigTests;
+import org.elasticsearch.client.transform.transforms.TransformConfig;
+import org.elasticsearch.client.transform.transforms.TransformConfigTests;
 import org.elasticsearch.common.settings.Settings;
 import org.elasticsearch.common.xcontent.NamedXContentRegistry;
 import org.elasticsearch.common.xcontent.XContentBuilder;
@@ -35,32 +35,32 @@ import java.util.List;
 
 import static org.elasticsearch.test.AbstractXContentTestCase.xContentTester;
 
-public class GetDataFrameTransformResponseTests extends ESTestCase {
+public class GetTransformResponseTests extends ESTestCase {
 
     public void testXContentParser() throws IOException {
         xContentTester(this::createParser,
-                GetDataFrameTransformResponseTests::createTestInstance,
-                GetDataFrameTransformResponseTests::toXContent,
-                GetDataFrameTransformResponse::fromXContent)
+                GetTransformResponseTests::createTestInstance,
+                GetTransformResponseTests::toXContent,
+                GetTransformResponse::fromXContent)
                 .supportsUnknownFields(false)
                 .test();
     }
 
-    private static GetDataFrameTransformResponse createTestInstance() {
+    private static GetTransformResponse createTestInstance() {
         int numTransforms = randomIntBetween(0, 3);
-        List<DataFrameTransformConfig> transforms = new ArrayList<>();
+        List<TransformConfig> transforms = new ArrayList<>();
         for (int i=0; i<numTransforms; i++) {
-            transforms.add(DataFrameTransformConfigTests.randomDataFrameTransformConfig());
+            transforms.add(TransformConfigTests.randomTransformConfig());
         }
-        GetDataFrameTransformResponse.InvalidTransforms invalidTransforms = null;
+        GetTransformResponse.InvalidTransforms invalidTransforms = null;
         if (randomBoolean()) {
             List<String> invalidIds = Arrays.asList(generateRandomStringArray(5, 6, false, false));
-            invalidTransforms = new GetDataFrameTransformResponse.InvalidTransforms(invalidIds);
+            invalidTransforms = new GetTransformResponse.InvalidTransforms(invalidIds);
         }
-        return new GetDataFrameTransformResponse(transforms, transforms.size() + 10, invalidTransforms);
+        return new GetTransformResponse(transforms, transforms.size() + 10, invalidTransforms);
     }
 
-    private static void toXContent(GetDataFrameTransformResponse response, XContentBuilder builder) throws IOException {
+    private static void toXContent(GetTransformResponse response, XContentBuilder builder) throws IOException {
         builder.startObject();
         {
             builder.field("count", response.getCount());
@@ -79,7 +79,7 @@ public class GetDataFrameTransformResponseTests extends ESTestCase {
     protected NamedXContentRegistry xContentRegistry() {
         SearchModule searchModule = new SearchModule(Settings.EMPTY, false, Collections.emptyList());
         List<NamedXContentRegistry.Entry> namedXContents = searchModule.getNamedXContents();
-        namedXContents.addAll(new DataFrameNamedXContentProvider().getNamedXContentParsers());
+        namedXContents.addAll(new TransformNamedXContentProvider().getNamedXContentParsers());
 
         return new NamedXContentRegistry(namedXContents);
     }

client/rest-high-level/src/test/java/org/elasticsearch/client/transform/GetTransformStatsRequestTests.java

@@ -23,10 +23,10 @@ import org.elasticsearch.test.ESTestCase;
 
 import static org.hamcrest.Matchers.containsString;
 
-public class GetDataFrameTransformStatsRequestTests extends ESTestCase {
+public class GetTransformStatsRequestTests extends ESTestCase {
     public void testValidate() {
-        assertFalse(new GetDataFrameTransformStatsRequest("valid-id").validate().isPresent());
-        assertThat(new GetDataFrameTransformStatsRequest(null).validate().get().getMessage(),
-                containsString("data frame transform id must not be null"));
+        assertFalse(new GetTransformStatsRequest("valid-id").validate().isPresent());
+        assertThat(new GetTransformStatsRequest(null).validate().get().getMessage(),
+                containsString("transform id must not be null"));
     }
 }

client/rest-high-level/src/test/java/org/elasticsearch/client/transform/GetTransformStatsResponseTests.java

@@ -21,8 +21,8 @@ package org.elasticsearch.client.transform;
 
 import org.elasticsearch.ElasticsearchException;
 import org.elasticsearch.action.TaskOperationFailure;
-import org.elasticsearch.client.transform.transforms.DataFrameTransformStats;
-import org.elasticsearch.client.transform.transforms.DataFrameTransformStatsTests;
+import org.elasticsearch.client.transform.transforms.TransformStats;
+import org.elasticsearch.client.transform.transforms.TransformStatsTests;
 import org.elasticsearch.common.xcontent.XContentBuilder;
 import org.elasticsearch.test.ESTestCase;
 
@@ -32,25 +32,25 @@ import java.util.List;
 
 import static org.elasticsearch.test.AbstractXContentTestCase.xContentTester;
 
-public class GetDataFrameTransformStatsResponseTests extends ESTestCase {
+public class GetTransformStatsResponseTests extends ESTestCase {
 
     public void testXContentParser() throws IOException {
         xContentTester(this::createParser,
-                GetDataFrameTransformStatsResponseTests::createTestInstance,
-                GetDataFrameTransformStatsResponseTests::toXContent,
-                GetDataFrameTransformStatsResponse::fromXContent)
-                .assertEqualsConsumer(GetDataFrameTransformStatsResponseTests::assertEqualInstances)
+                GetTransformStatsResponseTests::createTestInstance,
+                GetTransformStatsResponseTests::toXContent,
+                GetTransformStatsResponse::fromXContent)
+                .assertEqualsConsumer(GetTransformStatsResponseTests::assertEqualInstances)
                 .assertToXContentEquivalence(false)
                 .supportsUnknownFields(true)
                 .randomFieldsExcludeFilter(path -> path.isEmpty() == false)
                 .test();
     }
 
-    private static GetDataFrameTransformStatsResponse createTestInstance() {
+    private static GetTransformStatsResponse createTestInstance() {
         int count = randomIntBetween(1, 3);
-        List<DataFrameTransformStats> stats = new ArrayList<>();
+        List<TransformStats> stats = new ArrayList<>();
         for (int i=0; i<count; i++) {
-            stats.add(DataFrameTransformStatsTests.randomInstance());
+            stats.add(TransformStatsTests.randomInstance());
         }
 
         List<TaskOperationFailure> taskFailures = null;
@@ -66,19 +66,19 @@ public class GetDataFrameTransformStatsResponseTests extends ESTestCase {
             nodeFailures = new ArrayList<>();
             int numNodeFailures = randomIntBetween(1, 4);
             for (int i=0; i<numNodeFailures; i++) {
-                nodeFailures.add(new ElasticsearchException("GetDataFrameTransformStatsResponseTests"));
+                nodeFailures.add(new ElasticsearchException("GetTransformStatsResponseTests"));
             }
         }
 
-        return new GetDataFrameTransformStatsResponse(stats, taskFailures, nodeFailures);
+        return new GetTransformStatsResponse(stats, taskFailures, nodeFailures);
     }
 
-    private static void toXContent(GetDataFrameTransformStatsResponse response, XContentBuilder builder) throws IOException {
+    private static void toXContent(GetTransformStatsResponse response, XContentBuilder builder) throws IOException {
         builder.startObject();
         {
             builder.startArray("transforms");
-            for (DataFrameTransformStats stats : response.getTransformsStats()) {
-                DataFrameTransformStatsTests.toXContent(stats, builder);
+            for (TransformStats stats : response.getTransformsStats()) {
+                TransformStatsTests.toXContent(stats, builder);
             }
             builder.endArray();
 
@@ -90,8 +90,8 @@ public class GetDataFrameTransformStatsResponseTests extends ESTestCase {
 
     // Serialisation of TaskOperationFailure and ElasticsearchException changes
     // the object so use a custom compare method rather than Object.equals
-    private static void assertEqualInstances(GetDataFrameTransformStatsResponse expected,
-                                             GetDataFrameTransformStatsResponse actual) {
+    private static void assertEqualInstances(GetTransformStatsResponse expected,
+                                             GetTransformStatsResponse actual) {
         assertEquals(expected.getTransformsStats(), actual.getTransformsStats());
         AcknowledgedTasksResponseTests.assertTaskOperationFailuresEqual(expected.getTaskFailures(), actual.getTaskFailures());
         AcknowledgedTasksResponseTests.assertNodeFailuresEqual(expected.getNodeFailures(), actual.getNodeFailures());

client/rest-high-level/src/test/java/org/elasticsearch/client/transform/PreviewTransformRequestTests.java

@@ -20,8 +20,8 @@
 package org.elasticsearch.client.transform;
 
 import org.elasticsearch.client.ValidationException;
-import org.elasticsearch.client.transform.transforms.DataFrameTransformConfig;
-import org.elasticsearch.client.transform.transforms.DataFrameTransformConfigTests;
+import org.elasticsearch.client.transform.transforms.TransformConfig;
+import org.elasticsearch.client.transform.transforms.TransformConfigTests;
 import org.elasticsearch.client.transform.transforms.pivot.PivotConfigTests;
 import org.elasticsearch.common.settings.Settings;
 import org.elasticsearch.common.xcontent.NamedXContentRegistry;
@@ -37,15 +37,15 @@ import java.util.Optional;
 import static org.elasticsearch.client.transform.transforms.SourceConfigTests.randomSourceConfig;
 import static org.hamcrest.Matchers.containsString;
 
-public class PreviewDataFrameTransformRequestTests extends AbstractXContentTestCase<PreviewDataFrameTransformRequest> {
+public class PreviewTransformRequestTests extends AbstractXContentTestCase<PreviewTransformRequest> {
     @Override
-    protected PreviewDataFrameTransformRequest createTestInstance() {
-        return new PreviewDataFrameTransformRequest(DataFrameTransformConfigTests.randomDataFrameTransformConfig());
+    protected PreviewTransformRequest createTestInstance() {
+        return new PreviewTransformRequest(TransformConfigTests.randomTransformConfig());
     }
 
     @Override
-    protected PreviewDataFrameTransformRequest doParseInstance(XContentParser parser) throws IOException {
-        return new PreviewDataFrameTransformRequest(DataFrameTransformConfig.fromXContent(parser));
+    protected PreviewTransformRequest doParseInstance(XContentParser parser) throws IOException {
+        return new PreviewTransformRequest(TransformConfig.fromXContent(parser));
     }
 
     @Override
@@ -57,27 +57,27 @@ public class PreviewDataFrameTransformRequestTests extends AbstractXContentTestC
     protected NamedXContentRegistry xContentRegistry() {
         SearchModule searchModule = new SearchModule(Settings.EMPTY, false, Collections.emptyList());
         List<NamedXContentRegistry.Entry> namedXContents = searchModule.getNamedXContents();
-        namedXContents.addAll(new DataFrameNamedXContentProvider().getNamedXContentParsers());
+        namedXContents.addAll(new TransformNamedXContentProvider().getNamedXContentParsers());
 
         return new NamedXContentRegistry(namedXContents);
     }
 
     public void testValidate() {
-        assertFalse(new PreviewDataFrameTransformRequest(DataFrameTransformConfigTests.randomDataFrameTransformConfig())
+        assertFalse(new PreviewTransformRequest(TransformConfigTests.randomTransformConfig())
                 .validate().isPresent());
-        assertThat(new PreviewDataFrameTransformRequest(null).validate().get().getMessage(),
-                containsString("preview requires a non-null data frame config"));
+        assertThat(new PreviewTransformRequest(null).validate().get().getMessage(),
+                containsString("preview requires a non-null transform config"));
 
         // null id and destination is valid
-        DataFrameTransformConfig config = DataFrameTransformConfig.forPreview(randomSourceConfig(), PivotConfigTests.randomPivotConfig());
+        TransformConfig config = TransformConfig.forPreview(randomSourceConfig(), PivotConfigTests.randomPivotConfig());
 
-        assertFalse(new PreviewDataFrameTransformRequest(config).validate().isPresent());
+        assertFalse(new PreviewTransformRequest(config).validate().isPresent());
 
         // null source is not valid
-        config = DataFrameTransformConfig.builder().setPivotConfig(PivotConfigTests.randomPivotConfig()).build();
+        config = TransformConfig.builder().setPivotConfig(PivotConfigTests.randomPivotConfig()).build();
 
-        Optional<ValidationException> error = new PreviewDataFrameTransformRequest(config).validate();
+        Optional<ValidationException> error = new PreviewTransformRequest(config).validate();
         assertTrue(error.isPresent());
-        assertThat(error.get().getMessage(), containsString("data frame transform source cannot be null"));
+        assertThat(error.get().getMessage(), containsString("transform source cannot be null"));
     }
 }

client/rest-high-level/src/test/java/org/elasticsearch/client/transform/PreviewTransformResponseTests.java

@@ -31,19 +31,19 @@ import java.util.Map;
 
 import static org.elasticsearch.test.AbstractXContentTestCase.xContentTester;
 
-public class PreviewDataFrameTransformResponseTests extends ESTestCase {
+public class PreviewTransformResponseTests extends ESTestCase {
 
     public void testFromXContent() throws IOException {
         xContentTester(this::createParser,
                 this::createTestInstance,
                 this::toXContent,
-                PreviewDataFrameTransformResponse::fromXContent)
+                PreviewTransformResponse::fromXContent)
                 .supportsUnknownFields(true)
                 .randomFieldsExcludeFilter(path -> path.isEmpty() == false)
                 .test();
     }
 
-    private PreviewDataFrameTransformResponse createTestInstance() {
+    private PreviewTransformResponse createTestInstance() {
         int numDocs = randomIntBetween(5, 10);
         List<Map<String, Object>> docs = new ArrayList<>(numDocs);
         for (int i=0; i<numDocs; i++) {
@@ -60,10 +60,10 @@ public class PreviewDataFrameTransformResponseTests extends ESTestCase {
             mappings.put(randomAlphaOfLength(10), Collections.singletonMap("type", randomAlphaOfLength(10)));
         }
 
-        return new PreviewDataFrameTransformResponse(docs, mappings);
+        return new PreviewTransformResponse(docs, mappings);
     }
 
-    private void toXContent(PreviewDataFrameTransformResponse response, XContentBuilder builder) throws IOException {
+    private void toXContent(PreviewTransformResponse response, XContentBuilder builder) throws IOException {
         builder.startObject();
         builder.startArray("preview");
         for (Map<String, Object> doc : response.getDocs()) {

client/rest-high-level/src/test/java/org/elasticsearch/client/transform/PutTransformRequestTests.java

@@ -20,8 +20,8 @@
 package org.elasticsearch.client.transform;
 
 import org.elasticsearch.client.ValidationException;
-import org.elasticsearch.client.transform.transforms.DataFrameTransformConfig;
-import org.elasticsearch.client.transform.transforms.DataFrameTransformConfigTests;
+import org.elasticsearch.client.transform.transforms.TransformConfig;
+import org.elasticsearch.client.transform.transforms.TransformConfigTests;
 import org.elasticsearch.client.transform.transforms.pivot.PivotConfigTests;
 import org.elasticsearch.common.settings.Settings;
 import org.elasticsearch.common.xcontent.NamedXContentRegistry;
@@ -36,32 +36,32 @@ import java.util.Optional;
 
 import static org.hamcrest.Matchers.containsString;
 
-public class PutDataFrameTransformRequestTests extends AbstractXContentTestCase<PutDataFrameTransformRequest> {
+public class PutTransformRequestTests extends AbstractXContentTestCase<PutTransformRequest> {
 
     public void testValidate() {
         assertFalse(createTestInstance().validate().isPresent());
 
-        DataFrameTransformConfig config = DataFrameTransformConfig.builder().setPivotConfig(PivotConfigTests.randomPivotConfig()).build();
+        TransformConfig config = TransformConfig.builder().setPivotConfig(PivotConfigTests.randomPivotConfig()).build();
 
-        Optional<ValidationException> error = new PutDataFrameTransformRequest(config).validate();
+        Optional<ValidationException> error = new PutTransformRequest(config).validate();
         assertTrue(error.isPresent());
-        assertThat(error.get().getMessage(), containsString("data frame transform id cannot be null"));
-        assertThat(error.get().getMessage(), containsString("data frame transform source cannot be null"));
-        assertThat(error.get().getMessage(), containsString("data frame transform destination cannot be null"));
+        assertThat(error.get().getMessage(), containsString("transform id cannot be null"));
+        assertThat(error.get().getMessage(), containsString("transform source cannot be null"));
+        assertThat(error.get().getMessage(), containsString("transform destination cannot be null"));
 
-        error = new PutDataFrameTransformRequest(null).validate();
+        error = new PutTransformRequest(null).validate();
         assertTrue(error.isPresent());
-        assertThat(error.get().getMessage(), containsString("put requires a non-null data frame config"));
+        assertThat(error.get().getMessage(), containsString("put requires a non-null transform config"));
     }
 
     @Override
-    protected PutDataFrameTransformRequest createTestInstance() {
-        return new PutDataFrameTransformRequest(DataFrameTransformConfigTests.randomDataFrameTransformConfig());
+    protected PutTransformRequest createTestInstance() {
+        return new PutTransformRequest(TransformConfigTests.randomTransformConfig());
     }
 
     @Override
-    protected PutDataFrameTransformRequest doParseInstance(XContentParser parser) throws IOException {
-        return new PutDataFrameTransformRequest(DataFrameTransformConfig.fromXContent(parser));
+    protected PutTransformRequest doParseInstance(XContentParser parser) throws IOException {
+        return new PutTransformRequest(TransformConfig.fromXContent(parser));
     }
 
     @Override
@@ -73,7 +73,7 @@ public class PutDataFrameTransformRequestTests extends AbstractXContentTestCase<
     protected NamedXContentRegistry xContentRegistry() {
         SearchModule searchModule = new SearchModule(Settings.EMPTY, false, Collections.emptyList());
         List<NamedXContentRegistry.Entry> namedXContents = searchModule.getNamedXContents();
-        namedXContents.addAll(new DataFrameNamedXContentProvider().getNamedXContentParsers());
+        namedXContents.addAll(new TransformNamedXContentProvider().getNamedXContentParsers());
 
         return new NamedXContentRegistry(namedXContents);
     }

client/rest-high-level/src/test/java/org/elasticsearch/client/transform/StartDataFrameTransformRequestTests.java

@@ -28,14 +28,14 @@ import static org.hamcrest.Matchers.containsString;
 
 public class StartDataFrameTransformRequestTests extends ESTestCase {
     public void testValidate_givenNullId() {
-        StartDataFrameTransformRequest request = new StartDataFrameTransformRequest(null, null);
+        StartTransformRequest request = new StartTransformRequest(null, null);
         Optional<ValidationException> validate = request.validate();
         assertTrue(validate.isPresent());
-        assertThat(validate.get().getMessage(), containsString("data frame transform id must not be null"));
+        assertThat(validate.get().getMessage(), containsString("transform id must not be null"));
     }
 
     public void testValidate_givenValid() {
-        StartDataFrameTransformRequest request = new StartDataFrameTransformRequest("foo", null);
+        StartTransformRequest request = new StartTransformRequest("foo", null);
         Optional<ValidationException> validate = request.validate();
         assertFalse(validate.isPresent());
     }

client/rest-high-level/src/test/java/org/elasticsearch/client/transform/StopTransformRequestTests.java

@@ -26,16 +26,16 @@ import java.util.Optional;
 
 import static org.hamcrest.Matchers.containsString;
 
-public class StopDataFrameTransformRequestTests extends ESTestCase {
+public class StopTransformRequestTests extends ESTestCase {
     public void testValidate_givenNullId() {
-        StopDataFrameTransformRequest request = new StopDataFrameTransformRequest(null);
+        StopTransformRequest request = new StopTransformRequest(null);
         Optional<ValidationException> validate = request.validate();
         assertTrue(validate.isPresent());
-        assertThat(validate.get().getMessage(), containsString("data frame transform id must not be null"));
+        assertThat(validate.get().getMessage(), containsString("transform id must not be null"));
     }
 
     public void testValidate_givenValid() {
-        StopDataFrameTransformRequest request = new StopDataFrameTransformRequest("foo");
+        StopTransformRequest request = new StopTransformRequest("foo");
         Optional<ValidationException> validate = request.validate();
         assertFalse(validate.isPresent());
     }

client/rest-high-level/src/test/java/org/elasticsearch/client/transform/UpdateDataFrameTransformResponseTests.java

@@ -19,7 +19,7 @@
 
 package org.elasticsearch.client.transform;
 
-import org.elasticsearch.client.transform.transforms.DataFrameTransformConfigTests;
+import org.elasticsearch.client.transform.transforms.TransformConfigTests;
 import org.elasticsearch.common.settings.Settings;
 import org.elasticsearch.common.xcontent.NamedXContentRegistry;
 import org.elasticsearch.common.xcontent.XContentBuilder;
@@ -38,17 +38,17 @@ public class UpdateDataFrameTransformResponseTests extends ESTestCase {
         xContentTester(this::createParser,
                 UpdateDataFrameTransformResponseTests::createTestInstance,
                 UpdateDataFrameTransformResponseTests::toXContent,
-                UpdateDataFrameTransformResponse::fromXContent)
+                UpdateTransformResponse::fromXContent)
                 .assertToXContentEquivalence(false)
                 .supportsUnknownFields(false)
                 .test();
     }
 
-    private static UpdateDataFrameTransformResponse createTestInstance() {
-        return new UpdateDataFrameTransformResponse(DataFrameTransformConfigTests.randomDataFrameTransformConfig());
+    private static UpdateTransformResponse createTestInstance() {
+        return new UpdateTransformResponse(TransformConfigTests.randomTransformConfig());
     }
 
-    private static void toXContent(UpdateDataFrameTransformResponse response, XContentBuilder builder) throws IOException {
+    private static void toXContent(UpdateTransformResponse response, XContentBuilder builder) throws IOException {
         response.getTransformConfiguration().toXContent(builder, null);
     }
 
@@ -56,7 +56,7 @@ public class UpdateDataFrameTransformResponseTests extends ESTestCase {
     protected NamedXContentRegistry xContentRegistry() {
         SearchModule searchModule = new SearchModule(Settings.EMPTY, false, Collections.emptyList());
         List<NamedXContentRegistry.Entry> namedXContents = searchModule.getNamedXContents();
-        namedXContents.addAll(new DataFrameNamedXContentProvider().getNamedXContentParsers());
+        namedXContents.addAll(new TransformNamedXContentProvider().getNamedXContentParsers());
 
         return new NamedXContentRegistry(namedXContents);
     }

client/rest-high-level/src/test/java/org/elasticsearch/client/transform/UpdateTransformRequestTests.java

@@ -20,7 +20,7 @@
 package org.elasticsearch.client.transform;
 
 import org.elasticsearch.client.ValidationException;
-import org.elasticsearch.client.transform.transforms.DataFrameTransformConfigUpdate;
+import org.elasticsearch.client.transform.transforms.TransformConfigUpdate;
 import org.elasticsearch.common.settings.Settings;
 import org.elasticsearch.common.xcontent.NamedXContentRegistry;
 import org.elasticsearch.common.xcontent.XContentParser;
@@ -32,34 +32,34 @@ import java.util.Collections;
 import java.util.List;
 import java.util.Optional;
 
-import static org.elasticsearch.client.transform.transforms.DataFrameTransformConfigUpdateTests.randomDataFrameTransformConfigUpdate;
+import static org.elasticsearch.client.transform.transforms.TransformConfigUpdateTests.randomTransformConfigUpdate;
 import static org.hamcrest.Matchers.containsString;
 
-public class UpdateDataFrameTransformRequestTests extends AbstractXContentTestCase<UpdateDataFrameTransformRequest> {
+public class UpdateTransformRequestTests extends AbstractXContentTestCase<UpdateTransformRequest> {
 
     public void testValidate() {
         assertFalse(createTestInstance().validate().isPresent());
 
-        DataFrameTransformConfigUpdate config = randomDataFrameTransformConfigUpdate();
+        TransformConfigUpdate config = randomTransformConfigUpdate();
 
-        Optional<ValidationException> error = new UpdateDataFrameTransformRequest(config, null).validate();
+        Optional<ValidationException> error = new UpdateTransformRequest(config, null).validate();
         assertTrue(error.isPresent());
-        assertThat(error.get().getMessage(), containsString("data frame transform id cannot be null"));
+        assertThat(error.get().getMessage(), containsString("transform id cannot be null"));
 
-        error = new UpdateDataFrameTransformRequest(null, "123").validate();
+        error = new UpdateTransformRequest(null, "123").validate();
         assertTrue(error.isPresent());
-        assertThat(error.get().getMessage(), containsString("put requires a non-null data frame config"));
+        assertThat(error.get().getMessage(), containsString("put requires a non-null transform config"));
     }
 
     private final String transformId = randomAlphaOfLength(10);
     @Override
-    protected UpdateDataFrameTransformRequest createTestInstance() {
-        return new UpdateDataFrameTransformRequest(randomDataFrameTransformConfigUpdate(), transformId);
+    protected UpdateTransformRequest createTestInstance() {
+        return new UpdateTransformRequest(randomTransformConfigUpdate(), transformId);
     }
 
     @Override
-    protected UpdateDataFrameTransformRequest doParseInstance(XContentParser parser) throws IOException {
-        return new UpdateDataFrameTransformRequest(DataFrameTransformConfigUpdate.fromXContent(parser), transformId);
+    protected UpdateTransformRequest doParseInstance(XContentParser parser) throws IOException {
+        return new UpdateTransformRequest(TransformConfigUpdate.fromXContent(parser), transformId);
     }
 
     @Override
@@ -71,7 +71,7 @@ public class UpdateDataFrameTransformRequestTests extends AbstractXContentTestCa
     protected NamedXContentRegistry xContentRegistry() {
         SearchModule searchModule = new SearchModule(Settings.EMPTY, false, Collections.emptyList());
         List<NamedXContentRegistry.Entry> namedXContents = searchModule.getNamedXContents();
-        namedXContents.addAll(new DataFrameNamedXContentProvider().getNamedXContentParsers());
+        namedXContents.addAll(new TransformNamedXContentProvider().getNamedXContentParsers());
 
         return new NamedXContentRegistry(namedXContents);
     }

client/rest-high-level/src/test/java/org/elasticsearch/client/transform/transforms/TransformCheckpointStatsTests.java

@@ -26,38 +26,38 @@ import java.io.IOException;
 
 import static org.elasticsearch.test.AbstractXContentTestCase.xContentTester;
 
-public class DataFrameTransformCheckpointStatsTests extends ESTestCase {
+public class TransformCheckpointStatsTests extends ESTestCase {
 
     public void testFromXContent() throws IOException {
         xContentTester(this::createParser,
-            DataFrameTransformCheckpointStatsTests::randomDataFrameTransformCheckpointStats,
-            DataFrameTransformCheckpointStatsTests::toXContent,
-            DataFrameTransformCheckpointStats::fromXContent)
+            TransformCheckpointStatsTests::randomTransformCheckpointStats,
+            TransformCheckpointStatsTests::toXContent,
+            TransformCheckpointStats::fromXContent)
                 .supportsUnknownFields(true)
                 .randomFieldsExcludeFilter(field -> field.startsWith("position"))
                 .test();
     }
 
-    public static DataFrameTransformCheckpointStats randomDataFrameTransformCheckpointStats() {
-        return new DataFrameTransformCheckpointStats(randomLongBetween(1, 1_000_000),
-            randomBoolean() ? null : DataFrameIndexerPositionTests.randomDataFrameIndexerPosition(),
-            randomBoolean() ? null : DataFrameTransformProgressTests.randomInstance(),
+    public static TransformCheckpointStats randomTransformCheckpointStats() {
+        return new TransformCheckpointStats(randomLongBetween(1, 1_000_000),
+            randomBoolean() ? null : TransformIndexerPositionTests.randomTransformIndexerPosition(),
+            randomBoolean() ? null : TransformProgressTests.randomInstance(),
             randomLongBetween(1, 1_000_000), randomLongBetween(0, 1_000_000));
     }
 
-    public static void toXContent(DataFrameTransformCheckpointStats stats, XContentBuilder builder) throws IOException {
+    public static void toXContent(TransformCheckpointStats stats, XContentBuilder builder) throws IOException {
         builder.startObject();
-        builder.field(DataFrameTransformCheckpointStats.CHECKPOINT.getPreferredName(), stats.getCheckpoint());
+        builder.field(TransformCheckpointStats.CHECKPOINT.getPreferredName(), stats.getCheckpoint());
         if (stats.getPosition() != null) {
-            builder.field(DataFrameTransformCheckpointStats.POSITION.getPreferredName());
-            DataFrameIndexerPositionTests.toXContent(stats.getPosition(), builder);
+            builder.field(TransformCheckpointStats.POSITION.getPreferredName());
+            TransformIndexerPositionTests.toXContent(stats.getPosition(), builder);
         }
         if (stats.getCheckpointProgress() != null) {
-            builder.field(DataFrameTransformCheckpointStats.CHECKPOINT_PROGRESS.getPreferredName());
-            DataFrameTransformProgressTests.toXContent(stats.getCheckpointProgress(), builder);
+            builder.field(TransformCheckpointStats.CHECKPOINT_PROGRESS.getPreferredName());
+            TransformProgressTests.toXContent(stats.getCheckpointProgress(), builder);
         }
-        builder.field(DataFrameTransformCheckpointStats.TIMESTAMP_MILLIS.getPreferredName(), stats.getTimestampMillis());
-        builder.field(DataFrameTransformCheckpointStats.TIME_UPPER_BOUND_MILLIS.getPreferredName(), stats.getTimeUpperBoundMillis());
+        builder.field(TransformCheckpointStats.TIMESTAMP_MILLIS.getPreferredName(), stats.getTimestampMillis());
+        builder.field(TransformCheckpointStats.TIME_UPPER_BOUND_MILLIS.getPreferredName(), stats.getTimeUpperBoundMillis());
         builder.endObject();
     }
 }

client/rest-high-level/src/test/java/org/elasticsearch/client/transform/transforms/TransformCheckpointingInfoTests.java

@@ -27,38 +27,38 @@ import java.time.Instant;
 
 import static org.elasticsearch.test.AbstractXContentTestCase.xContentTester;
 
-public class DataFrameTransformCheckpointingInfoTests extends ESTestCase {
+public class TransformCheckpointingInfoTests extends ESTestCase {
 
     public void testFromXContent() throws IOException {
         xContentTester(this::createParser,
-            DataFrameTransformCheckpointingInfoTests::randomDataFrameTransformCheckpointingInfo,
-            DataFrameTransformCheckpointingInfoTests::toXContent,
-            DataFrameTransformCheckpointingInfo::fromXContent)
+            TransformCheckpointingInfoTests::randomTransformCheckpointingInfo,
+            TransformCheckpointingInfoTests::toXContent,
+            TransformCheckpointingInfo::fromXContent)
                 .supportsUnknownFields(false)
                 .test();
     }
 
-    public static DataFrameTransformCheckpointingInfo randomDataFrameTransformCheckpointingInfo() {
-        return new DataFrameTransformCheckpointingInfo(
-            DataFrameTransformCheckpointStatsTests.randomDataFrameTransformCheckpointStats(),
-            DataFrameTransformCheckpointStatsTests.randomDataFrameTransformCheckpointStats(),
+    public static TransformCheckpointingInfo randomTransformCheckpointingInfo() {
+        return new TransformCheckpointingInfo(
+            TransformCheckpointStatsTests.randomTransformCheckpointStats(),
+            TransformCheckpointStatsTests.randomTransformCheckpointStats(),
             randomLongBetween(0, 10000),
             randomBoolean() ? null : Instant.ofEpochMilli(randomNonNegativeLong()));
     }
 
-    public static void toXContent(DataFrameTransformCheckpointingInfo info, XContentBuilder builder) throws IOException {
+    public static void toXContent(TransformCheckpointingInfo info, XContentBuilder builder) throws IOException {
         builder.startObject();
         if (info.getLast().getTimestampMillis() > 0) {
-            builder.field(DataFrameTransformCheckpointingInfo.LAST_CHECKPOINT.getPreferredName());
-            DataFrameTransformCheckpointStatsTests.toXContent(info.getLast(), builder);
+            builder.field(TransformCheckpointingInfo.LAST_CHECKPOINT.getPreferredName());
+            TransformCheckpointStatsTests.toXContent(info.getLast(), builder);
         }
         if (info.getNext().getTimestampMillis() > 0) {
-            builder.field(DataFrameTransformCheckpointingInfo.NEXT_CHECKPOINT.getPreferredName());
-            DataFrameTransformCheckpointStatsTests.toXContent(info.getNext(), builder);
+            builder.field(TransformCheckpointingInfo.NEXT_CHECKPOINT.getPreferredName());
+            TransformCheckpointStatsTests.toXContent(info.getNext(), builder);
         }
-        builder.field(DataFrameTransformCheckpointingInfo.OPERATIONS_BEHIND.getPreferredName(), info.getOperationsBehind());
+        builder.field(TransformCheckpointingInfo.OPERATIONS_BEHIND.getPreferredName(), info.getOperationsBehind());
         if (info.getChangesLastDetectedAt() != null) {
-            builder.field(DataFrameTransformCheckpointingInfo.CHANGES_LAST_DETECTED_AT.getPreferredName(), info.getChangesLastDetectedAt());
+            builder.field(TransformCheckpointingInfo.CHANGES_LAST_DETECTED_AT.getPreferredName(), info.getChangesLastDetectedAt());
         }
         builder.endObject();
     }

client/rest-high-level/src/test/java/org/elasticsearch/client/transform/transforms/TransformConfigTests.java

@@ -20,7 +20,7 @@
 package org.elasticsearch.client.transform.transforms;
 
 import org.elasticsearch.Version;
-import org.elasticsearch.client.transform.DataFrameNamedXContentProvider;
+import org.elasticsearch.client.transform.TransformNamedXContentProvider;
 import org.elasticsearch.client.transform.transforms.pivot.PivotConfigTests;
 import org.elasticsearch.common.settings.Settings;
 import org.elasticsearch.common.unit.TimeValue;
@@ -38,10 +38,10 @@ import java.util.function.Predicate;
 import static org.elasticsearch.client.transform.transforms.DestConfigTests.randomDestConfig;
 import static org.elasticsearch.client.transform.transforms.SourceConfigTests.randomSourceConfig;
 
-public class DataFrameTransformConfigTests extends AbstractXContentTestCase<DataFrameTransformConfig> {
+public class TransformConfigTests extends AbstractXContentTestCase<TransformConfig> {
 
-    public static DataFrameTransformConfig randomDataFrameTransformConfig() {
-        return new DataFrameTransformConfig(randomAlphaOfLengthBetween(1, 10),
+    public static TransformConfig randomTransformConfig() {
+        return new TransformConfig(randomAlphaOfLengthBetween(1, 10),
             randomSourceConfig(),
             randomDestConfig(),
             randomBoolean() ? null : TimeValue.timeValueMillis(randomIntBetween(1000, 1000000)),
@@ -57,13 +57,13 @@ public class DataFrameTransformConfigTests extends AbstractXContentTestCase<Data
     }
 
     @Override
-    protected DataFrameTransformConfig createTestInstance() {
-        return randomDataFrameTransformConfig();
+    protected TransformConfig createTestInstance() {
+        return randomTransformConfig();
     }
 
     @Override
-    protected DataFrameTransformConfig doParseInstance(XContentParser parser) throws IOException {
-        return DataFrameTransformConfig.fromXContent(parser);
+    protected TransformConfig doParseInstance(XContentParser parser) throws IOException {
+        return TransformConfig.fromXContent(parser);
     }
 
     @Override
@@ -81,7 +81,7 @@ public class DataFrameTransformConfigTests extends AbstractXContentTestCase<Data
     protected NamedXContentRegistry xContentRegistry() {
         SearchModule searchModule = new SearchModule(Settings.EMPTY, false, Collections.emptyList());
         List<NamedXContentRegistry.Entry> namedXContents = searchModule.getNamedXContents();
-        namedXContents.addAll(new DataFrameNamedXContentProvider().getNamedXContentParsers());
+        namedXContents.addAll(new TransformNamedXContentProvider().getNamedXContentParsers());
 
         return new NamedXContentRegistry(namedXContents);
     }

client/rest-high-level/src/test/java/org/elasticsearch/client/transform/transforms/TransformConfigUpdateTests.java

@@ -19,7 +19,7 @@
 
 package org.elasticsearch.client.transform.transforms;
 
-import org.elasticsearch.client.transform.DataFrameNamedXContentProvider;
+import org.elasticsearch.client.transform.TransformNamedXContentProvider;
 import org.elasticsearch.common.settings.Settings;
 import org.elasticsearch.common.unit.TimeValue;
 import org.elasticsearch.common.xcontent.NamedXContentRegistry;
@@ -34,10 +34,10 @@ import java.util.List;
 import static org.elasticsearch.client.transform.transforms.DestConfigTests.randomDestConfig;
 import static org.elasticsearch.client.transform.transforms.SourceConfigTests.randomSourceConfig;
 
-public class DataFrameTransformConfigUpdateTests extends AbstractXContentTestCase<DataFrameTransformConfigUpdate> {
+public class TransformConfigUpdateTests extends AbstractXContentTestCase<TransformConfigUpdate> {
 
-    public static DataFrameTransformConfigUpdate randomDataFrameTransformConfigUpdate() {
-        return new DataFrameTransformConfigUpdate(
+    public static TransformConfigUpdate randomTransformConfigUpdate() {
+        return new TransformConfigUpdate(
             randomBoolean() ? null : randomSourceConfig(),
             randomBoolean() ? null : randomDestConfig(),
             randomBoolean() ? null : TimeValue.timeValueMillis(randomIntBetween(1_000, 3_600_000)),
@@ -50,8 +50,8 @@ public class DataFrameTransformConfigUpdateTests extends AbstractXContentTestCas
     }
 
     @Override
-    protected DataFrameTransformConfigUpdate doParseInstance(XContentParser parser) throws IOException {
-        return DataFrameTransformConfigUpdate.fromXContent(parser);
+    protected TransformConfigUpdate doParseInstance(XContentParser parser) throws IOException {
+        return TransformConfigUpdate.fromXContent(parser);
     }
 
     @Override
@@ -60,15 +60,15 @@ public class DataFrameTransformConfigUpdateTests extends AbstractXContentTestCas
     }
 
     @Override
-    protected DataFrameTransformConfigUpdate createTestInstance() {
-        return randomDataFrameTransformConfigUpdate();
+    protected TransformConfigUpdate createTestInstance() {
+        return randomTransformConfigUpdate();
     }
 
     @Override
     protected NamedXContentRegistry xContentRegistry() {
         SearchModule searchModule = new SearchModule(Settings.EMPTY, false, Collections.emptyList());
         List<NamedXContentRegistry.Entry> namedXContents = searchModule.getNamedXContents();
-        namedXContents.addAll(new DataFrameNamedXContentProvider().getNamedXContentParsers());
+        namedXContents.addAll(new TransformNamedXContentProvider().getNamedXContentParsers());
 
         return new NamedXContentRegistry(namedXContents);
     }

client/rest-high-level/src/test/java/org/elasticsearch/client/transform/transforms/TransformIndexerPositionTests.java

@@ -28,24 +28,24 @@ import java.util.Map;
 
 import static org.elasticsearch.test.AbstractXContentTestCase.xContentTester;
 
-public class DataFrameIndexerPositionTests extends ESTestCase {
+public class TransformIndexerPositionTests extends ESTestCase {
 
     public void testFromXContent() throws IOException {
         xContentTester(this::createParser,
-                DataFrameIndexerPositionTests::randomDataFrameIndexerPosition,
-                DataFrameIndexerPositionTests::toXContent,
-                DataFrameIndexerPosition::fromXContent)
+                TransformIndexerPositionTests::randomTransformIndexerPosition,
+                TransformIndexerPositionTests::toXContent,
+                TransformIndexerPosition::fromXContent)
                 .supportsUnknownFields(true)
                 .randomFieldsExcludeFilter(field -> field.equals("indexer_position") ||
                     field.equals("bucket_position"))
                 .test();
     }
 
-    public static DataFrameIndexerPosition randomDataFrameIndexerPosition() {
-        return new DataFrameIndexerPosition(randomPositionMap(), randomPositionMap());
+    public static TransformIndexerPosition randomTransformIndexerPosition() {
+        return new TransformIndexerPosition(randomPositionMap(), randomPositionMap());
     }
 
-    public static void toXContent(DataFrameIndexerPosition position, XContentBuilder builder) throws IOException {
+    public static void toXContent(TransformIndexerPosition position, XContentBuilder builder) throws IOException {
         builder.startObject();
         if (position.getIndexerPosition() != null) {
             builder.field("indexer_position", position.getIndexerPosition());

client/rest-high-level/src/test/java/org/elasticsearch/client/transform/transforms/TransformIndexerStatsTests.java

@@ -27,20 +27,20 @@ import java.io.IOException;
 
 import static org.elasticsearch.test.AbstractXContentTestCase.xContentTester;
 
-public class DataFrameIndexerTransformStatsTests extends ESTestCase {
+public class TransformIndexerStatsTests extends ESTestCase {
 
     public void testFromXContent() throws IOException {
         xContentTester(
                 this::createParser,
-                DataFrameIndexerTransformStatsTests::randomStats,
-                DataFrameIndexerTransformStatsTests::toXContent,
-                DataFrameIndexerTransformStats::fromXContent)
+                TransformIndexerStatsTests::randomStats,
+                TransformIndexerStatsTests::toXContent,
+                TransformIndexerStats::fromXContent)
                 .supportsUnknownFields(true)
                 .test();
     }
 
-    public static DataFrameIndexerTransformStats randomStats() {
-        return new DataFrameIndexerTransformStats(randomNonNegativeLong(), randomNonNegativeLong(), randomNonNegativeLong(),
+    public static TransformIndexerStats randomStats() {
+        return new TransformIndexerStats(randomNonNegativeLong(), randomNonNegativeLong(), randomNonNegativeLong(),
                 randomNonNegativeLong(), randomNonNegativeLong(), randomNonNegativeLong(),
                 randomNonNegativeLong(), randomNonNegativeLong(), randomNonNegativeLong(), randomNonNegativeLong(),
             randomBoolean() ? null : randomDouble(),
@@ -48,7 +48,7 @@ public class DataFrameIndexerTransformStatsTests extends ESTestCase {
             randomBoolean() ? null : randomDouble());
     }
 
-    public static void toXContent(DataFrameIndexerTransformStats stats, XContentBuilder builder) throws IOException {
+    public static void toXContent(TransformIndexerStats stats, XContentBuilder builder) throws IOException {
         builder.startObject();
         builder.field(IndexerJobStats.NUM_PAGES.getPreferredName(), stats.getNumPages());
         builder.field(IndexerJobStats.NUM_INPUT_DOCUMENTS.getPreferredName(), stats.getNumDocuments());
@@ -60,11 +60,11 @@ public class DataFrameIndexerTransformStatsTests extends ESTestCase {
         builder.field(IndexerJobStats.SEARCH_TIME_IN_MS.getPreferredName(), stats.getSearchTime());
         builder.field(IndexerJobStats.SEARCH_TOTAL.getPreferredName(), stats.getSearchTotal());
         builder.field(IndexerJobStats.SEARCH_FAILURES.getPreferredName(), stats.getSearchFailures());
-        builder.field(DataFrameIndexerTransformStats.EXPONENTIAL_AVG_CHECKPOINT_DURATION_MS.getPreferredName(),
+        builder.field(TransformIndexerStats.EXPONENTIAL_AVG_CHECKPOINT_DURATION_MS.getPreferredName(),
             stats.getExpAvgCheckpointDurationMs());
-        builder.field(DataFrameIndexerTransformStats.EXPONENTIAL_AVG_DOCUMENTS_INDEXED.getPreferredName(),
+        builder.field(TransformIndexerStats.EXPONENTIAL_AVG_DOCUMENTS_INDEXED.getPreferredName(),
             stats.getExpAvgDocumentsIndexed());
-        builder.field(DataFrameIndexerTransformStats.EXPONENTIAL_AVG_DOCUMENTS_PROCESSED.getPreferredName(),
+        builder.field(TransformIndexerStats.EXPONENTIAL_AVG_DOCUMENTS_PROCESSED.getPreferredName(),
             stats.getExpAvgDocumentsProcessed());
         builder.endObject();
     }

client/rest-high-level/src/test/java/org/elasticsearch/client/transform/transforms/TransformProgressTests.java

@@ -26,19 +26,19 @@ import java.io.IOException;
 
 import static org.elasticsearch.test.AbstractXContentTestCase.xContentTester;
 
-public class DataFrameTransformProgressTests extends ESTestCase {
+public class TransformProgressTests extends ESTestCase {
 
     public void testFromXContent() throws IOException {
         xContentTester(this::createParser,
-            DataFrameTransformProgressTests::randomInstance,
-            DataFrameTransformProgressTests::toXContent,
-            DataFrameTransformProgress::fromXContent)
+            TransformProgressTests::randomInstance,
+            TransformProgressTests::toXContent,
+            TransformProgress::fromXContent)
            .supportsUnknownFields(true)
            .test();
     }
 
-    public static DataFrameTransformProgress randomInstance() {
-        return new DataFrameTransformProgress(
+    public static TransformProgress randomInstance() {
+        return new TransformProgress(
             randomBoolean() ? null : randomNonNegativeLong(),
             randomBoolean() ? null : randomNonNegativeLong(),
             randomBoolean() ? null : randomDouble(),
@@ -46,19 +46,19 @@ public class DataFrameTransformProgressTests extends ESTestCase {
             randomBoolean() ? null : randomNonNegativeLong());
     }
 
-    public static void toXContent(DataFrameTransformProgress progress, XContentBuilder builder) throws IOException {
+    public static void toXContent(TransformProgress progress, XContentBuilder builder) throws IOException {
         builder.startObject();
         if (progress.getTotalDocs() != null) {
-            builder.field(DataFrameTransformProgress.TOTAL_DOCS.getPreferredName(), progress.getTotalDocs());
+            builder.field(TransformProgress.TOTAL_DOCS.getPreferredName(), progress.getTotalDocs());
         }
         if (progress.getPercentComplete() != null) {
-            builder.field(DataFrameTransformProgress.PERCENT_COMPLETE.getPreferredName(), progress.getPercentComplete());
+            builder.field(TransformProgress.PERCENT_COMPLETE.getPreferredName(), progress.getPercentComplete());
         }
         if (progress.getRemainingDocs() != null) {
-            builder.field(DataFrameTransformProgress.DOCS_REMAINING.getPreferredName(), progress.getRemainingDocs());
+            builder.field(TransformProgress.DOCS_REMAINING.getPreferredName(), progress.getRemainingDocs());
         }
-        builder.field(DataFrameTransformProgress.DOCS_INDEXED.getPreferredName(), progress.getDocumentsIndexed());
-        builder.field(DataFrameTransformProgress.DOCS_PROCESSED.getPreferredName(), progress.getDocumentsProcessed());
+        builder.field(TransformProgress.DOCS_INDEXED.getPreferredName(), progress.getDocumentsIndexed());
+        builder.field(TransformProgress.DOCS_PROCESSED.getPreferredName(), progress.getDocumentsProcessed());
         builder.endObject();
     }
 }

client/rest-high-level/src/test/java/org/elasticsearch/client/transform/transforms/TransformStatsTests.java

@@ -27,46 +27,46 @@ import java.io.IOException;
 
 import static org.elasticsearch.test.AbstractXContentTestCase.xContentTester;
 
-public class DataFrameTransformStatsTests extends ESTestCase {
+public class TransformStatsTests extends ESTestCase {
 
     public void testFromXContent() throws IOException {
         xContentTester(this::createParser,
-            DataFrameTransformStatsTests::randomInstance,
-            DataFrameTransformStatsTests::toXContent,
-            DataFrameTransformStats::fromXContent)
+            TransformStatsTests::randomInstance,
+            TransformStatsTests::toXContent,
+            TransformStats::fromXContent)
                 .supportsUnknownFields(true)
                 .randomFieldsExcludeFilter(field -> field.equals("node.attributes") || field.contains("position"))
                 .test();
     }
 
-    public static DataFrameTransformStats randomInstance() {
-        return new DataFrameTransformStats(randomAlphaOfLength(10),
-            randomBoolean() ? null : randomFrom(DataFrameTransformStats.State.values()),
+    public static TransformStats randomInstance() {
+        return new TransformStats(randomAlphaOfLength(10),
+            randomBoolean() ? null : randomFrom(TransformStats.State.values()),
             randomBoolean() ? null : randomAlphaOfLength(100),
             randomBoolean() ? null : NodeAttributesTests.createRandom(),
-            DataFrameIndexerTransformStatsTests.randomStats(),
-            randomBoolean() ? null : DataFrameTransformCheckpointingInfoTests.randomDataFrameTransformCheckpointingInfo());
+            TransformIndexerStatsTests.randomStats(),
+            randomBoolean() ? null : TransformCheckpointingInfoTests.randomTransformCheckpointingInfo());
     }
 
-    public static void toXContent(DataFrameTransformStats stats, XContentBuilder builder) throws IOException {
+    public static void toXContent(TransformStats stats, XContentBuilder builder) throws IOException {
         builder.startObject();
-        builder.field(DataFrameTransformStats.ID.getPreferredName(), stats.getId());
+        builder.field(TransformStats.ID.getPreferredName(), stats.getId());
         if (stats.getState() != null) {
-            builder.field(DataFrameTransformStats.STATE_FIELD.getPreferredName(),
+            builder.field(TransformStats.STATE_FIELD.getPreferredName(),
                 stats.getState().value());
         }
         if (stats.getReason() != null) {
-            builder.field(DataFrameTransformStats.REASON_FIELD.getPreferredName(), stats.getReason());
+            builder.field(TransformStats.REASON_FIELD.getPreferredName(), stats.getReason());
         }
         if (stats.getNode() != null) {
-            builder.field(DataFrameTransformStats.NODE_FIELD.getPreferredName());
+            builder.field(TransformStats.NODE_FIELD.getPreferredName());
             stats.getNode().toXContent(builder, ToXContent.EMPTY_PARAMS);
         }
-        builder.field(DataFrameTransformStats.STATS_FIELD.getPreferredName());
-        DataFrameIndexerTransformStatsTests.toXContent(stats.getIndexerStats(), builder);
+        builder.field(TransformStats.STATS_FIELD.getPreferredName());
+        TransformIndexerStatsTests.toXContent(stats.getIndexerStats(), builder);
         if (stats.getCheckpointingInfo() != null) {
-            builder.field(DataFrameTransformStats.CHECKPOINTING_INFO_FIELD.getPreferredName());
-            DataFrameTransformCheckpointingInfoTests.toXContent(stats.getCheckpointingInfo(), builder);
+            builder.field(TransformStats.CHECKPOINTING_INFO_FIELD.getPreferredName());
+            TransformCheckpointingInfoTests.toXContent(stats.getCheckpointingInfo(), builder);
         }
         builder.endObject();
     }

client/rest-high-level/src/test/java/org/elasticsearch/client/transform/transforms/hlrc/TransformCheckpointStatsTests.java

@@ -28,40 +28,40 @@ import java.io.IOException;
 
 import static org.hamcrest.Matchers.equalTo;
 
-public class DataFrameTransformCheckpointStatsTests extends AbstractResponseTestCase<
+public class TransformCheckpointStatsTests extends AbstractResponseTestCase<
         TransformCheckpointStats,
-        org.elasticsearch.client.transform.transforms.DataFrameTransformCheckpointStats> {
+        org.elasticsearch.client.transform.transforms.TransformCheckpointStats> {
 
     public static TransformCheckpointStats fromHlrc(
-            org.elasticsearch.client.transform.transforms.DataFrameTransformCheckpointStats instance) {
+            org.elasticsearch.client.transform.transforms.TransformCheckpointStats instance) {
         return new TransformCheckpointStats(instance.getCheckpoint(),
-            DataFrameIndexerPositionTests.fromHlrc(instance.getPosition()),
-            DataFrameTransformProgressTests.fromHlrc(instance.getCheckpointProgress()),
+            TransformIndexerPositionTests.fromHlrc(instance.getPosition()),
+            TransformProgressTests.fromHlrc(instance.getCheckpointProgress()),
             instance.getTimestampMillis(),
             instance.getTimeUpperBoundMillis());
     }
 
-    public static TransformCheckpointStats randomDataFrameTransformCheckpointStats() {
+    public static TransformCheckpointStats randomTransformCheckpointStats() {
         return new TransformCheckpointStats(randomLongBetween(1, 1_000_000),
-            DataFrameIndexerPositionTests.randomDataFrameIndexerPosition(),
-            randomBoolean() ? null : DataFrameTransformProgressTests.randomDataFrameTransformProgress(),
+            TransformIndexerPositionTests.randomTransformIndexerPosition(),
+            randomBoolean() ? null : TransformProgressTests.randomTransformProgress(),
             randomLongBetween(1, 1_000_000), randomLongBetween(0, 1_000_000));
     }
 
     @Override
     protected TransformCheckpointStats createServerTestInstance(XContentType xContentType) {
-        return randomDataFrameTransformCheckpointStats();
+        return randomTransformCheckpointStats();
     }
 
     @Override
-    protected org.elasticsearch.client.transform.transforms.DataFrameTransformCheckpointStats doParseToClientInstance(XContentParser parser)
+    protected org.elasticsearch.client.transform.transforms.TransformCheckpointStats doParseToClientInstance(XContentParser parser)
         throws IOException {
-        return org.elasticsearch.client.transform.transforms.DataFrameTransformCheckpointStats.fromXContent(parser);
+        return org.elasticsearch.client.transform.transforms.TransformCheckpointStats.fromXContent(parser);
     }
 
     @Override
     protected void assertInstances(TransformCheckpointStats serverTestInstance,
-                                   org.elasticsearch.client.transform.transforms.DataFrameTransformCheckpointStats clientInstance) {
+                                   org.elasticsearch.client.transform.transforms.TransformCheckpointStats clientInstance) {
         assertThat(serverTestInstance.getCheckpoint(), equalTo(clientInstance.getCheckpoint()));
         assertThat(serverTestInstance.getPosition().getBucketsPosition(), equalTo(clientInstance.getPosition().getBucketsPosition()));
         assertThat(serverTestInstance.getPosition().getIndexerPosition(), equalTo(clientInstance.getPosition().getIndexerPosition()));

client/rest-high-level/src/test/java/org/elasticsearch/client/transform/transforms/hlrc/TransformCheckpointingInfoTests.java

@@ -27,41 +27,41 @@ import java.io.IOException;
 import java.time.Instant;
 import java.util.function.Predicate;
 
-public class DataFrameTransformCheckpointingInfoTests extends AbstractHlrcXContentTestCase<
+public class TransformCheckpointingInfoTests extends AbstractHlrcXContentTestCase<
         TransformCheckpointingInfo,
-        org.elasticsearch.client.transform.transforms.DataFrameTransformCheckpointingInfo> {
+        org.elasticsearch.client.transform.transforms.TransformCheckpointingInfo> {
 
     public static TransformCheckpointingInfo fromHlrc(
-            org.elasticsearch.client.transform.transforms.DataFrameTransformCheckpointingInfo instance) {
+            org.elasticsearch.client.transform.transforms.TransformCheckpointingInfo instance) {
         return new TransformCheckpointingInfo(
-            DataFrameTransformCheckpointStatsTests.fromHlrc(instance.getLast()),
-            DataFrameTransformCheckpointStatsTests.fromHlrc(instance.getNext()),
+            TransformCheckpointStatsTests.fromHlrc(instance.getLast()),
+            TransformCheckpointStatsTests.fromHlrc(instance.getNext()),
             instance.getOperationsBehind(),
             instance.getChangesLastDetectedAt());
     }
 
     @Override
-    public org.elasticsearch.client.transform.transforms.DataFrameTransformCheckpointingInfo doHlrcParseInstance(XContentParser parser) {
-        return org.elasticsearch.client.transform.transforms.DataFrameTransformCheckpointingInfo.fromXContent(parser);
+    public org.elasticsearch.client.transform.transforms.TransformCheckpointingInfo doHlrcParseInstance(XContentParser parser) {
+        return org.elasticsearch.client.transform.transforms.TransformCheckpointingInfo.fromXContent(parser);
     }
 
     @Override
     public TransformCheckpointingInfo convertHlrcToInternal(
-            org.elasticsearch.client.transform.transforms.DataFrameTransformCheckpointingInfo instance) {
+            org.elasticsearch.client.transform.transforms.TransformCheckpointingInfo instance) {
         return fromHlrc(instance);
     }
 
-    public static TransformCheckpointingInfo randomDataFrameTransformCheckpointingInfo() {
+    public static TransformCheckpointingInfo randomTransformCheckpointingInfo() {
         return new TransformCheckpointingInfo(
-            DataFrameTransformCheckpointStatsTests.randomDataFrameTransformCheckpointStats(),
-            DataFrameTransformCheckpointStatsTests.randomDataFrameTransformCheckpointStats(),
+            TransformCheckpointStatsTests.randomTransformCheckpointStats(),
+            TransformCheckpointStatsTests.randomTransformCheckpointStats(),
             randomNonNegativeLong(),
             randomBoolean() ? null : Instant.ofEpochMilli(randomNonNegativeLong()));
     }
 
     @Override
     protected TransformCheckpointingInfo createTestInstance() {
-        return randomDataFrameTransformCheckpointingInfo();
+        return randomTransformCheckpointingInfo();
     }
 
     @Override

client/rest-high-level/src/test/java/org/elasticsearch/client/transform/transforms/hlrc/TransformIndexerPositionTests.java

@@ -29,35 +29,35 @@ import java.util.Map;
 
 import static org.hamcrest.Matchers.equalTo;
 
-public class DataFrameIndexerPositionTests extends AbstractResponseTestCase<
+public class TransformIndexerPositionTests extends AbstractResponseTestCase<
         TransformIndexerPosition,
-        org.elasticsearch.client.transform.transforms.DataFrameIndexerPosition> {
+        org.elasticsearch.client.transform.transforms.TransformIndexerPosition> {
 
     public static TransformIndexerPosition fromHlrc(
-            org.elasticsearch.client.transform.transforms.DataFrameIndexerPosition instance) {
+            org.elasticsearch.client.transform.transforms.TransformIndexerPosition instance) {
         if (instance == null) {
             return null;
         }
         return new TransformIndexerPosition(instance.getIndexerPosition(), instance.getBucketsPosition());
     }
 
-    public static TransformIndexerPosition randomDataFrameIndexerPosition() {
+    public static TransformIndexerPosition randomTransformIndexerPosition() {
         return new TransformIndexerPosition(randomPositionMap(), randomPositionMap());
     }
 
     @Override
     protected TransformIndexerPosition createServerTestInstance(XContentType xContentType) {
-        return randomDataFrameIndexerPosition();
+        return randomTransformIndexerPosition();
     }
 
     @Override
-    protected org.elasticsearch.client.transform.transforms.DataFrameIndexerPosition doParseToClientInstance(XContentParser parser) {
-        return org.elasticsearch.client.transform.transforms.DataFrameIndexerPosition.fromXContent(parser);
+    protected org.elasticsearch.client.transform.transforms.TransformIndexerPosition doParseToClientInstance(XContentParser parser) {
+        return org.elasticsearch.client.transform.transforms.TransformIndexerPosition.fromXContent(parser);
     }
 
     @Override
     protected void assertInstances(TransformIndexerPosition serverTestInstance,
-                                   org.elasticsearch.client.transform.transforms.DataFrameIndexerPosition clientInstance) {
+                                   org.elasticsearch.client.transform.transforms.TransformIndexerPosition clientInstance) {
         assertThat(serverTestInstance.getIndexerPosition(), equalTo(clientInstance.getIndexerPosition()));
         assertThat(serverTestInstance.getBucketsPosition(), equalTo(clientInstance.getBucketsPosition()));
     }

client/rest-high-level/src/test/java/org/elasticsearch/client/transform/transforms/hlrc/TransformIndexerStatsTests.java

@@ -25,12 +25,12 @@ import org.elasticsearch.xpack.core.transform.transforms.TransformIndexerStats;
 
 import java.io.IOException;
 
-public class DataFrameIndexerTransformStatsTests extends AbstractHlrcXContentTestCase<
+public class TransformIndexerStatsTests extends AbstractHlrcXContentTestCase<
         TransformIndexerStats,
-        org.elasticsearch.client.transform.transforms.DataFrameIndexerTransformStats> {
+        org.elasticsearch.client.transform.transforms.TransformIndexerStats> {
 
     public static TransformIndexerStats fromHlrc(
-            org.elasticsearch.client.transform.transforms.DataFrameIndexerTransformStats instance) {
+            org.elasticsearch.client.transform.transforms.TransformIndexerStats instance) {
         return new TransformIndexerStats(
             instance.getNumPages(),
             instance.getNumDocuments(),
@@ -48,14 +48,14 @@ public class DataFrameIndexerTransformStatsTests extends AbstractHlrcXContentTes
     }
 
     @Override
-    public org.elasticsearch.client.transform.transforms.DataFrameIndexerTransformStats doHlrcParseInstance(XContentParser parser)
+    public org.elasticsearch.client.transform.transforms.TransformIndexerStats doHlrcParseInstance(XContentParser parser)
             throws IOException {
-        return org.elasticsearch.client.transform.transforms.DataFrameIndexerTransformStats.fromXContent(parser);
+        return org.elasticsearch.client.transform.transforms.TransformIndexerStats.fromXContent(parser);
     }
 
     @Override
     public TransformIndexerStats convertHlrcToInternal(
-            org.elasticsearch.client.transform.transforms.DataFrameIndexerTransformStats instance) {
+            org.elasticsearch.client.transform.transforms.TransformIndexerStats instance) {
         return fromHlrc(instance);
     }
 

client/rest-high-level/src/test/java/org/elasticsearch/client/transform/transforms/hlrc/TransformProgressTests.java

@@ -26,12 +26,12 @@ import org.elasticsearch.xpack.core.transform.transforms.TransformProgress;
 
 import static org.hamcrest.Matchers.equalTo;
 
-public class DataFrameTransformProgressTests extends AbstractResponseTestCase<
+public class TransformProgressTests extends AbstractResponseTestCase<
         TransformProgress,
-        org.elasticsearch.client.transform.transforms.DataFrameTransformProgress> {
+        org.elasticsearch.client.transform.transforms.TransformProgress> {
 
     public static TransformProgress fromHlrc(
-            org.elasticsearch.client.transform.transforms.DataFrameTransformProgress instance) {
+            org.elasticsearch.client.transform.transforms.TransformProgress instance) {
         if (instance == null) {
             return null;
         }
@@ -41,7 +41,7 @@ public class DataFrameTransformProgressTests extends AbstractResponseTestCase<
             instance.getDocumentsIndexed());
     }
 
-    public static TransformProgress randomDataFrameTransformProgress() {
+    public static TransformProgress randomTransformProgress() {
         Long totalDocs = randomBoolean() ? null : randomNonNegativeLong();
         Long docsRemaining = totalDocs != null ? randomLongBetween(0, totalDocs) : null;
         return new TransformProgress(
@@ -53,17 +53,17 @@ public class DataFrameTransformProgressTests extends AbstractResponseTestCase<
 
     @Override
     protected TransformProgress createServerTestInstance(XContentType xContentType) {
-        return randomDataFrameTransformProgress();
+        return randomTransformProgress();
     }
 
     @Override
-    protected org.elasticsearch.client.transform.transforms.DataFrameTransformProgress doParseToClientInstance(XContentParser parser) {
-        return org.elasticsearch.client.transform.transforms.DataFrameTransformProgress.fromXContent(parser);
+    protected org.elasticsearch.client.transform.transforms.TransformProgress doParseToClientInstance(XContentParser parser) {
+        return org.elasticsearch.client.transform.transforms.TransformProgress.fromXContent(parser);
     }
 
     @Override
     protected void assertInstances(TransformProgress serverTestInstance,
-                                   org.elasticsearch.client.transform.transforms.DataFrameTransformProgress clientInstance) {
+                                   org.elasticsearch.client.transform.transforms.TransformProgress clientInstance) {
         assertThat(serverTestInstance.getTotalDocs(), equalTo(clientInstance.getTotalDocs()));
         assertThat(serverTestInstance.getDocumentsProcessed(), equalTo(clientInstance.getDocumentsProcessed()));
         assertThat(serverTestInstance.getPercentComplete(), equalTo(clientInstance.getPercentComplete()));

client/rest-high-level/src/test/java/org/elasticsearch/client/transform/transforms/hlrc/TransformStatsTests.java

@@ -34,8 +34,8 @@ import java.util.HashMap;
 import java.util.Map;
 import java.util.function.Predicate;
 
-public class DataFrameTransformStatsTests extends AbstractHlrcXContentTestCase<TransformStats,
-    org.elasticsearch.client.transform.transforms.DataFrameTransformStats> {
+public class TransformStatsTests extends AbstractHlrcXContentTestCase<TransformStats,
+    org.elasticsearch.client.transform.transforms.TransformStats> {
 
     public static NodeAttributes fromHlrc(org.elasticsearch.client.transform.transforms.NodeAttributes attributes) {
         return attributes == null ? null : new NodeAttributes(attributes.getId(),
@@ -46,45 +46,45 @@ public class DataFrameTransformStatsTests extends AbstractHlrcXContentTestCase<T
     }
 
     public static TransformStats
-        fromHlrc(org.elasticsearch.client.transform.transforms.DataFrameTransformStats instance) {
+        fromHlrc(org.elasticsearch.client.transform.transforms.TransformStats instance) {
 
         return new TransformStats(instance.getId(),
             TransformStats.State.fromString(instance.getState().value()),
             instance.getReason(),
             fromHlrc(instance.getNode()),
-            DataFrameIndexerTransformStatsTests.fromHlrc(instance.getIndexerStats()),
-            DataFrameTransformCheckpointingInfoTests.fromHlrc(instance.getCheckpointingInfo()));
+            TransformIndexerStatsTests.fromHlrc(instance.getIndexerStats()),
+            TransformCheckpointingInfoTests.fromHlrc(instance.getCheckpointingInfo()));
     }
 
     @Override
-    public org.elasticsearch.client.transform.transforms.DataFrameTransformStats doHlrcParseInstance(XContentParser parser)
+    public org.elasticsearch.client.transform.transforms.TransformStats doHlrcParseInstance(XContentParser parser)
             throws IOException {
-        return org.elasticsearch.client.transform.transforms.DataFrameTransformStats.fromXContent(parser);
+        return org.elasticsearch.client.transform.transforms.TransformStats.fromXContent(parser);
     }
 
     @Override
     public TransformStats convertHlrcToInternal(
-        org.elasticsearch.client.transform.transforms.DataFrameTransformStats instance) {
+        org.elasticsearch.client.transform.transforms.TransformStats instance) {
         return new TransformStats(instance.getId(),
                 TransformStats.State.fromString(instance.getState().value()),
                 instance.getReason(),
                 fromHlrc(instance.getNode()),
-                DataFrameIndexerTransformStatsTests.fromHlrc(instance.getIndexerStats()),
-                DataFrameTransformCheckpointingInfoTests.fromHlrc(instance.getCheckpointingInfo()));
+                TransformIndexerStatsTests.fromHlrc(instance.getIndexerStats()),
+                TransformCheckpointingInfoTests.fromHlrc(instance.getCheckpointingInfo()));
     }
 
-    public static TransformStats randomDataFrameTransformStats() {
+    public static TransformStats randomTransformStats() {
         return new TransformStats(randomAlphaOfLength(10),
             randomFrom(TransformStats.State.values()),
             randomBoolean() ? null : randomAlphaOfLength(100),
             randomBoolean() ? null : randomNodeAttributes(),
             randomStats(),
-            DataFrameTransformCheckpointingInfoTests.randomDataFrameTransformCheckpointingInfo());
+            TransformCheckpointingInfoTests.randomTransformCheckpointingInfo());
     }
 
     @Override
     protected TransformStats createTestInstance() {
-        return randomDataFrameTransformStats();
+        return randomTransformStats();
     }
 
     @Override
@@ -97,7 +97,7 @@ public class DataFrameTransformStatsTests extends AbstractHlrcXContentTestCase<T
         return field -> field.contains("position") || field.equals("node.attributes");
     }
 
-    public static TransformProgress randomDataFrameTransformProgress() {
+    public static TransformProgress randomTransformProgress() {
         Long totalDocs = randomBoolean() ? null : randomNonNegativeLong();
         Long docsRemaining = totalDocs != null ? randomLongBetween(0, totalDocs) : null;
         return new TransformProgress(
@@ -107,16 +107,16 @@ public class DataFrameTransformStatsTests extends AbstractHlrcXContentTestCase<T
             randomBoolean() ? null : randomNonNegativeLong());
     }
 
-    public static TransformCheckpointingInfo randomDataFrameTransformCheckpointingInfo() {
-        return new TransformCheckpointingInfo(randomDataFrameTransformCheckpointStats(),
-            randomDataFrameTransformCheckpointStats(), randomNonNegativeLong(),
+    public static TransformCheckpointingInfo randomTransformCheckpointingInfo() {
+        return new TransformCheckpointingInfo(randomTransformCheckpointStats(),
+            randomTransformCheckpointStats(), randomNonNegativeLong(),
             randomBoolean() ? null : Instant.ofEpochMilli(randomNonNegativeLong()));
     }
 
-    public static TransformCheckpointStats randomDataFrameTransformCheckpointStats() {
+    public static TransformCheckpointStats randomTransformCheckpointStats() {
         return new TransformCheckpointStats(randomLongBetween(1, 1_000_000),
-            DataFrameIndexerPositionTests.randomDataFrameIndexerPosition(),
-            randomBoolean() ? null : DataFrameTransformProgressTests.randomDataFrameTransformProgress(),
+            TransformIndexerPositionTests.randomTransformIndexerPosition(),
+            randomBoolean() ? null : TransformProgressTests.randomTransformProgress(),
             randomLongBetween(1, 1_000_000), randomLongBetween(0, 1_000_000));
     }
 

docs/java-rest/high-level/supported-apis.asciidoc

@@ -580,7 +580,7 @@ include::ilm/remove_lifecycle_policy_from_index.asciidoc[]
 == {transform-cap} APIs
 
 :upid: {mainid}
-:doc-tests-file: {doc-tests}/DataFrameTransformDocumentationIT.java
+:doc-tests-file: {doc-tests}/TransformDocumentationIT.java
 
 The Java High Level REST Client supports the following {transform}
 APIs:

docs/java-rest/high-level/transform/delete_transform.asciidoc

@@ -1,6 +1,6 @@
 --
 :api: delete-transform
-:request: DeleteDataFrameTransformRequest
+:request: DeleteTransformRequest
 :response: AcknowledgedResponse
 --
 [role="xpack"]

docs/java-rest/high-level/transform/get_transform.asciidoc

@@ -1,7 +1,7 @@
 --
 :api: get-transform
-:request: GetDataFrameTransformRequest
-:response: GetDataFrameTransformResponse
+:request: GetTransformRequest
+:response: GetTransformResponse
 --
 [role="xpack"]
 [id="{upid}-{api}"]

docs/java-rest/high-level/transform/get_transform_stats.asciidoc

@@ -1,7 +1,7 @@
 --
 :api: get-transform-stats
-:request: GetDataFrameTransformStatsRequest
-:response: GetDataFrameTransformStatsResponse
+:request: GetTransformStatsRequest
+:response: GetTransformStatsResponse
 --
 [role="xpack"]
 [id="{upid}-{api}"]
@@ -48,7 +48,7 @@ The returned +{response}+ contains the requested {transform} statistics.
 --------------------------------------------------
 include-tagged::{doc-tests-file}[{api}-response]
 --------------------------------------------------
-<1> The response contains a list of `DataFrameTransformStats` objects
+<1> The response contains a list of `TransformStats` objects
 <2> The running state of the {transform}, for example `started`, `indexing`, etc.
 <3> The overall {transform} statistics recording the number of documents indexed etc.
 <4> The progress of the current run in the {transform}. Supplies the number of docs left until the next checkpoint

docs/java-rest/high-level/transform/preview_transform.asciidoc

@@ -1,7 +1,7 @@
 --
 :api: preview-transform
-:request: PreviewDataFrameTransformRequest
-:response: PreviewDataFrameTransformResponse
+:request: PreviewTransformRequest
+:response: PreviewTransformResponse
 --
 [role="xpack"]
 [id="{upid}-{api}"]

docs/java-rest/high-level/transform/put_transform.asciidoc

@@ -1,6 +1,6 @@
 --
 :api: put-transform
-:request: PutDataFrameTransformRequest
+:request: PutTransformRequest
 :response: AcknowledgedResponse
 --
 [role="xpack"]
@@ -29,7 +29,7 @@ such an error will not be visible until `_start` is called.
 [id="{upid}-{api}-config"]
 ==== {transform-cap} configuration
 
-The `DataFrameTransformConfig` object contains all the details about the
+The `TransformConfig` object contains all the details about the
 {transform} configuration and contains the following arguments:
 
 ["source","java",subs="attributes,callouts,macros"]

docs/java-rest/high-level/transform/start_transform.asciidoc

@@ -1,7 +1,7 @@
 --
 :api: start-transform
-:request: StartDataFrameTransformRequest
-:response: StartDataFrameTransformResponse
+:request: StartTransformRequest
+:response: StartTransformResponse
 --
 [role="xpack"]
 [id="{upid}-{api}"]

docs/java-rest/high-level/transform/stop_transform.asciidoc

@@ -1,7 +1,7 @@
 --
 :api: stop-transform
-:request: StopDataFrameTransformRequest
-:response: StopDataFrameTransformResponse
+:request: StopTransformRequest
+:response: StopTransformResponse
 --
 [role="xpack"]
 [id="{upid}-{api}"]
@@ -31,7 +31,7 @@ The following arguments are optional.
 --------------------------------------------------
 include-tagged::{doc-tests-file}[{api}-request-options]
 --------------------------------------------------
-<1> If true wait for the data frame task to stop before responding
+<1> If true wait for the transform task to stop before responding
 <2> Controls the amount of time to wait until the {transform} stops.
 <3> Whether to ignore if a wildcard expression matches no {transforms}.
 

docs/java-rest/high-level/transform/update_transform.asciidoc

@@ -1,7 +1,7 @@
 --
 :api: update-transform
-:request: UpdateDataFrameTransformRequest
-:response: UpdateDataFrameTransformResponse
+:request: UpdateTransformRequest
+:response: UpdateTransformResponse
 --
 [role="xpack"]
 [id="{upid}-{api}"]
@@ -30,7 +30,7 @@ such an error will not be visible until `_start` is called.
 [id="{upid}-{api}-config"]
 ==== {transform-cap} update configuration
 
-The `DataFrameTransformConfigUpdate` object contains all the details about updated
+The `TransformConfigUpdate` object contains all the details about updated
 {transform} configuration and contains the following arguments:
 
 ["source","java",subs="attributes,callouts,macros"]

x-pack/plugin/src/test/resources/rest-api-spec/api/transform.delete_transform.json

@@ -1,5 +1,5 @@
 {
-  "data_frame.delete_data_frame_transform":{
+  "transform.delete_transform":{
     "documentation":{
       "url":"https://www.elastic.co/guide/en/elasticsearch/reference/current/delete-transform.html"
     },

x-pack/plugin/src/test/resources/rest-api-spec/api/transform.get_transform.json

@@ -1,5 +1,5 @@
 {
-  "data_frame.get_data_frame_transform":{
+  "transform.get_transform":{
     "documentation":{
       "url":"https://www.elastic.co/guide/en/elasticsearch/reference/current/get-transform.html"
     },
@@ -40,7 +40,7 @@
       "allow_no_match":{
         "type":"boolean",
         "required":false,
-        "description":"Whether to ignore if a wildcard expression matches no data frame transforms. (This includes `_all` string or when no data frame transforms have been specified)"
+        "description":"Whether to ignore if a wildcard expression matches no transforms. (This includes `_all` string or when no transforms have been specified)"
       }
     }
   }

x-pack/plugin/src/test/resources/rest-api-spec/api/transform.get_transform_stats.json

@@ -1,5 +1,5 @@
 {
-  "data_frame.get_data_frame_transform_stats":{
+  "transform.get_transform_stats":{
     "documentation":{
       "url":"https://www.elastic.co/guide/en/elasticsearch/reference/current/get-transform-stats.html"
     },
@@ -34,7 +34,7 @@
       "allow_no_match":{
         "type":"boolean",
         "required":false,
-        "description":"Whether to ignore if a wildcard expression matches no data frame transforms. (This includes `_all` string or when no data frame transforms have been specified)"
+        "description":"Whether to ignore if a wildcard expression matches no transforms. (This includes `_all` string or when no transforms have been specified)"
       }
     }
   }

x-pack/plugin/src/test/resources/rest-api-spec/api/transform.preview_transform.json

@@ -1,5 +1,5 @@
 {
-  "data_frame.preview_data_frame_transform":{
+  "transform.preview_transform":{
     "documentation":{
       "url":"https://www.elastic.co/guide/en/elasticsearch/reference/current/preview-transform.html"
     },
@@ -15,7 +15,7 @@
       ]
     },
     "body":{
-      "description":"The definition for the data_frame transform to preview",
+      "description":"The definition for the transform to preview",
       "required":true
     }
   }

x-pack/plugin/src/test/resources/rest-api-spec/api/transform.put_transform.json

@@ -1,5 +1,5 @@
 {
-  "data_frame.put_data_frame_transform":{
+  "transform.put_transform":{
     "documentation":{
       "url":"https://www.elastic.co/guide/en/elasticsearch/reference/current/put-transform.html"
     },
@@ -24,11 +24,11 @@
       "defer_validation": {
         "type": "boolean",
         "required": false,
-        "description": "If validations should be deferred until data frame transform starts, defaults to false."
+        "description": "If validations should be deferred until transform starts, defaults to false."
       }
     },
     "body":{
-      "description":"The data frame transform definition",
+      "description":"The transform definition",
       "required":true
     }
   }

x-pack/plugin/src/test/resources/rest-api-spec/api/transform.start_transform.json

@@ -1,5 +1,5 @@
 {
-  "data_frame.start_data_frame_transform":{
+  "transform.start_transform":{
     "documentation":{
       "url":"https://www.elastic.co/guide/en/elasticsearch/reference/current/start-transform.html"
     },

x-pack/plugin/src/test/resources/rest-api-spec/api/transform.stop_transform.json

@@ -1,5 +1,5 @@
 {
-  "data_frame.stop_data_frame_transform":{
+  "transform.stop_transform":{
     "documentation":{
       "url":"https://www.elastic.co/guide/en/elasticsearch/reference/current/stop-transform.html"
     },
@@ -34,7 +34,7 @@
       "allow_no_match":{
         "type":"boolean",
         "required":false,
-        "description":"Whether to ignore if a wildcard expression matches no data frame transforms. (This includes `_all` string or when no data frame transforms have been specified)"
+        "description":"Whether to ignore if a wildcard expression matches no transforms. (This includes `_all` string or when no transforms have been specified)"
       }
     }
   }

x-pack/plugin/src/test/resources/rest-api-spec/api/transform.update_transform.json

@@ -1,5 +1,5 @@
 {
-  "data_frame.update_data_frame_transform": {
+  "transform.update_transform": {
     "documentation": {
       "url": "https://www.elastic.co/guide/en/elasticsearch/reference/current/update-transform.html"
     },
@@ -23,11 +23,11 @@
       "defer_validation": {
         "type": "boolean",
         "required": false,
-        "description": "If validations should be deferred until data frame transform starts, defaults to false."
+        "description": "If validations should be deferred until transform starts, defaults to false."
       }
     },
     "body": {
-      "description" : "The update data frame transform definition",
+      "description" : "The update transform definition",
       "required": true
     }
   }

x-pack/plugin/src/test/resources/rest-api-spec/test/transform/preview_transforms.yml

@@ -68,7 +68,7 @@ setup:
 ---
 "Test preview transform":
   - do:
-      data_frame.preview_data_frame_transform:
+      transform.preview_transform:
         body: >
           {
             "source": { "index": "airline-data" },
@@ -120,7 +120,7 @@ setup:
           }
   - match: { acknowledged: true }
   - do:
-      data_frame.preview_data_frame_transform:
+      transform.preview_transform:
         body: >
           {
             "source": { "index": "airline-data" },
@@ -154,7 +154,7 @@ setup:
 "Test preview transform with invalid config":
   - do:
       catch: /\[data_frame_terms_group\] unknown field \[not_a_terms_param\]/
-      data_frame.preview_data_frame_transform:
+      transform.preview_transform:
         body: >
           {
             "source": { "index": "airline-data" },
@@ -167,7 +167,7 @@ setup:
 "Test preview with non-existing source index":
   - do:
       catch: /Source index \[does_not_exist\] does not exist/
-      data_frame.preview_data_frame_transform:
+      transform.preview_transform:
         body: >
           {
             "source": { "index": ["airline-data", "does_not_exist"] },
@@ -182,7 +182,7 @@ setup:
 "Test preview returns bad request with invalid agg":
   - do:
       catch: bad_request
-      data_frame.preview_data_frame_transform:
+      transform.preview_transform:
         body: >
           {
             "source": { "index": "airline-data" },
@@ -198,7 +198,7 @@ setup:
 
   - do:
       catch: /field \[time\] cannot be both an object and a field/
-      data_frame.preview_data_frame_transform:
+      transform.preview_transform:
         body: >
           {
             "source": { "index": "airline-data" },
@@ -213,7 +213,7 @@ setup:
           }
   - do:
       catch: /field \[super_metric\] cannot be both an object and a field/
-      data_frame.preview_data_frame_transform:
+      transform.preview_transform:
         body: >
           {
             "source": { "index": "airline-data" },
@@ -238,7 +238,7 @@ setup:
 "Test preview with missing pipeline":
   - do:
       catch: bad_request
-      data_frame.preview_data_frame_transform:
+      transform.preview_transform:
         body: >
           {
             "source": { "index": "airline-data" },
@@ -256,7 +256,7 @@ setup:
 "Test preview with unsupported agg":
   - do:
       catch: bad_request
-      data_frame.preview_data_frame_transform:
+      transform.preview_transform:
         body: >
           {
             "source": { "index": "airline-data" },
@@ -271,7 +271,7 @@ setup:
           }
   - do:
       catch: /Unsupported aggregation type \[terms\]/
-      data_frame.preview_data_frame_transform:
+      transform.preview_transform:
         body: >
           {
             "source": { "index": "airline-data" },

x-pack/plugin/src/test/resources/rest-api-spec/test/transform/transforms_crud.yml

@@ -17,14 +17,14 @@ setup:
 ---
 "Test get all transforms when there are none":
   - do:
-      data_frame.get_data_frame_transform:
+      transform.get_transform:
         transform_id: "*"
   - match: { count: 0 }
   - match: { transforms: [] }
 
   - do:
       catch: missing
-      data_frame.get_data_frame_transform:
+      transform.get_transform:
         transform_id: "*"
         allow_no_match: false
 
@@ -32,21 +32,21 @@ setup:
 "Test get transform when it does not exist":
   - do:
       catch: /Transform with id \[missing-transform-id\] could not be found/
-      data_frame.get_data_frame_transform:
+      transform.get_transform:
         transform_id: "missing-transform-id"
 
 ---
 "Test delete transform when it does not exist":
   - do:
       catch: missing
-      data_frame.delete_data_frame_transform:
+      transform.delete_transform:
         transform_id: "missing transform"
 
 ---
 "Test put transform with frequency too low":
   - do:
       catch: /minimum permitted \[frequency\] is \[1s\]/
-      data_frame.put_data_frame_transform:
+      transform.put_transform:
         transform_id: "frequency-too-low"
         body: >
           {
@@ -63,7 +63,7 @@ setup:
 "Test put transform with frequency too high":
   - do:
       catch: /highest permitted \[frequency\] is \[1h\]/
-      data_frame.put_data_frame_transform:
+      transform.put_transform:
         transform_id: "frequency-too-low"
         body: >
           {
@@ -80,7 +80,7 @@ setup:
 "Test put transform with invalid source index":
   - do:
       catch: /Source index \[missing-index\] does not exist/
-      data_frame.put_data_frame_transform:
+      transform.put_transform:
         transform_id: "missing-source-transform"
         body: >
           {
@@ -92,7 +92,7 @@ setup:
             }
           }
   - do:
-      data_frame.put_data_frame_transform:
+      transform.put_transform:
         transform_id: "missing-source-transform"
         defer_validation: true
         body: >
@@ -108,7 +108,7 @@ setup:
 ---
 "Test basic transform crud":
   - do:
-      data_frame.put_data_frame_transform:
+      transform.put_transform:
         transform_id: "airline-transform"
         body: >
           {
@@ -123,7 +123,7 @@ setup:
   - match: { acknowledged: true }
 
   - do:
-      data_frame.put_data_frame_transform:
+      transform.put_transform:
         transform_id: "airline-transform-dos"
         body: >
           {
@@ -137,7 +137,7 @@ setup:
   - match: { acknowledged: true }
 
   - do:
-      data_frame.get_data_frame_transform:
+      transform.get_transform:
         transform_id: "airline-transform"
   - match: { count: 1 }
   - match: { transforms.0.id: "airline-transform" }
@@ -151,7 +151,7 @@ setup:
   - match: { transforms.0.description: "yaml test transform on airline-data" }
 
   - do:
-      data_frame.get_data_frame_transform:
+      transform.get_transform:
         transform_id: "*"
   - match: { count: 2 }
   - match: { transforms.0.id: "airline-transform" }
@@ -159,27 +159,27 @@ setup:
   - is_false: transforms.1.description
 
   - do:
-      data_frame.get_data_frame_transform:
+      transform.get_transform:
         transform_id: "_all"
   - match: { count: 2 }
   - match: { transforms.0.id: "airline-transform" }
   - match: { transforms.1.id: "airline-transform-dos" }
   - do:
-      data_frame.get_data_frame_transform:
+      transform.get_transform:
         transform_id: "airline-transform,airline-transform-dos"
   - match: { count: 2 }
   - match: { transforms.0.id: "airline-transform" }
   - match: { transforms.1.id: "airline-transform-dos" }
 
   - do:
-      data_frame.get_data_frame_transform:
+      transform.get_transform:
         transform_id: "airline-transform*"
   - match: { count: 2 }
   - match: { transforms.0.id: "airline-transform" }
   - match: { transforms.1.id: "airline-transform-dos" }
 
   - do:
-      data_frame.get_data_frame_transform:
+      transform.get_transform:
         transform_id: "airline-transform*"
         from: 0
         size: 1
@@ -187,7 +187,7 @@ setup:
   - match: { transforms.0.id: "airline-transform" }
 
   - do:
-      data_frame.get_data_frame_transform:
+      transform.get_transform:
         transform_id: "airline-transform*"
         from: 1
         size: 1
@@ -212,7 +212,7 @@ setup:
                 type: integer
 
   - do:
-      data_frame.put_data_frame_transform:
+      transform.put_transform:
         transform_id: "airline-transform"
         body: >
           {
@@ -228,7 +228,7 @@ setup:
           }
   - match: { acknowledged: true }
   - do:
-      data_frame.get_data_frame_transform:
+      transform.get_transform:
         transform_id: "airline-transform"
   - match: { count: 1 }
   - match: { transforms.0.id: "airline-transform" }
@@ -241,7 +241,7 @@ setup:
 ---
 "Test PUT continuous transform":
   - do:
-      data_frame.put_data_frame_transform:
+      transform.put_transform:
         transform_id: "airline-transform-continuous"
         body: >
           {
@@ -262,7 +262,7 @@ setup:
           }
   - match: { acknowledged: true }
   - do:
-      data_frame.get_data_frame_transform:
+      transform.get_transform:
         transform_id: "airline-transform-continuous"
   - match: { count: 1 }
   - match: { transforms.0.id: "airline-transform-continuous" }
@@ -275,7 +275,7 @@ setup:
 ---
 "Test PUT continuous transform without delay set":
   - do:
-      data_frame.put_data_frame_transform:
+      transform.put_transform:
         transform_id: "airline-transform-continuous"
         body: >
           {
@@ -295,7 +295,7 @@ setup:
           }
   - match: { acknowledged: true }
   - do:
-      data_frame.get_data_frame_transform:
+      transform.get_transform:
         transform_id: "airline-transform-continuous"
   - match: { count: 1 }
   - match: { transforms.0.id: "airline-transform-continuous" }
@@ -309,7 +309,7 @@ setup:
 "Test transform with invalid page parameter":
   - do:
       catch: /Param \[size\] has a max acceptable value of \[1000\]/
-      data_frame.get_data_frame_transform:
+      transform.get_transform:
         transform_id: "_all"
         from: 0
         size: 10000
@@ -317,7 +317,7 @@ setup:
 "Test transform where dest is included in source":
   - do:
       catch: /Destination index \[airline-data-by-airline\] is included in source expression \[airline-data/
-      data_frame.put_data_frame_transform:
+      transform.put_transform:
         transform_id: "airline-transform"
         body: >
           {
@@ -332,7 +332,7 @@ setup:
           }
 
   - do:
-      data_frame.put_data_frame_transform:
+      transform.put_transform:
         transform_id: "airline-transform"
         defer_validation: true
         body: >
@@ -363,7 +363,7 @@ setup:
         index: created-destination-index
         name: dest-index
   - do:
-      data_frame.put_data_frame_transform:
+      transform.put_transform:
         transform_id: "transform-from-aliases"
         body: >
           {
@@ -385,7 +385,7 @@ setup:
 
   - do:
       catch: /Destination index \[created-destination-index\] is included in source expression \[airline-data,created-destination-index\]/
-      data_frame.put_data_frame_transform:
+      transform.put_transform:
         transform_id: "transform-from-aliases-failures"
         body: >
           {
@@ -411,7 +411,7 @@ setup:
 
   - do:
       catch: /Destination index \[dest-index\] should refer to a single index/
-      data_frame.put_data_frame_transform:
+      transform.put_transform:
         transform_id: "airline-transform"
         body: >
           {
@@ -428,7 +428,7 @@ setup:
 "Test put config with invalid pivot size":
   - do:
       catch: /pivot\.max_page_search_size \[5\] must be greater than 10 and less than 10,000/
-      data_frame.put_data_frame_transform:
+      transform.put_transform:
         transform_id: "airline-transform"
         body: >
           {
@@ -442,7 +442,7 @@ setup:
           }
   - do:
       catch: /pivot\.max_page_search_size \[15000\] must be greater than 10 and less than 10,000/
-      data_frame.put_data_frame_transform:
+      transform.put_transform:
         transform_id: "airline-transform"
         body: >
           {
@@ -458,7 +458,7 @@ setup:
 "Test creation failures due to duplicate and conflicting field names":
   - do:
       catch: /duplicate field \[airline\] detected/
-      data_frame.put_data_frame_transform:
+      transform.put_transform:
         transform_id: "duplicate-field-transform"
         body: >
           {
@@ -473,7 +473,7 @@ setup:
           }
   - do:
       catch: /field \[airline\] cannot be both an object and a field/
-      data_frame.put_data_frame_transform:
+      transform.put_transform:
         transform_id: "duplicate-field-transform"
         body: >
           {
@@ -487,10 +487,10 @@ setup:
             }
           }
 ---
-"Test invalid data frame id":
+"Test invalid transform id":
   - do:
       catch: /can contain lowercase alphanumeric \(a-z and 0-9\), hyphens or underscores; must start and end with alphanumeric/
-      data_frame.put_data_frame_transform:
+      transform.put_transform:
         transform_id: "!@#$%^&*(duplicate-field-transform"
         body: >
           {
@@ -505,7 +505,7 @@ setup:
           }
   - do:
       catch: /The id cannot contain more than 64 character/
-      data_frame.put_data_frame_transform:
+      transform.put_transform:
         transform_id: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
         body: >
           {
@@ -522,7 +522,7 @@ setup:
 "Test invalid destination index name":
   - do:
       catch: /dest\.index \[DeStInAtIoN\] must be lowercase/
-      data_frame.put_data_frame_transform:
+      transform.put_transform:
         transform_id: "airline-transform"
         body: >
           {
@@ -537,7 +537,7 @@ setup:
           }
   - do:
       catch: /Invalid index name \[destination#dest\], must not contain \'#\'/
-      data_frame.put_data_frame_transform:
+      transform.put_transform:
         transform_id: "airline-transform"
         body: >
           {
@@ -556,7 +556,7 @@ setup:
 
   - do:
       catch: /Found \[create_time\], not allowed for strict parsing/
-      data_frame.put_data_frame_transform:
+      transform.put_transform:
         transform_id: "airline-transform-with-create-time"
         body: >
           {
@@ -575,7 +575,7 @@ setup:
 
   - do:
       catch: /Found \[version\], not allowed for strict parsing/
-      data_frame.put_data_frame_transform:
+      transform.put_transform:
         transform_id: "airline-transform-with-version"
         body: >
           {
@@ -591,7 +591,7 @@ setup:
 ---
 "Test force deleting a running transform":
   - do:
-      data_frame.put_data_frame_transform:
+      transform.put_transform:
         transform_id: "airline-transform-start-delete"
         body: >
           {
@@ -610,12 +610,12 @@ setup:
           }
   - match: { acknowledged: true }
   - do:
-      data_frame.start_data_frame_transform:
+      transform.start_transform:
         transform_id: "airline-transform-start-delete"
   - match: { acknowledged: true }
 
   - do:
-      data_frame.get_data_frame_transform_stats:
+      transform.get_transform_stats:
         transform_id: "airline-transform-start-delete"
   - match: { count: 1 }
   - match: { transforms.0.id: "airline-transform-start-delete" }
@@ -623,11 +623,11 @@ setup:
 
   - do:
       catch: /Cannot delete transform \[airline-transform-start-delete\] as the task is running/
-      data_frame.delete_data_frame_transform:
+      transform.delete_transform:
         transform_id: "airline-transform-start-delete"
 
   - do:
-      data_frame.delete_data_frame_transform:
+      transform.delete_transform:
         transform_id: "airline-transform-start-delete"
         force: true
   - match: { acknowledged: true }

x-pack/plugin/src/test/resources/rest-api-spec/test/transform/transforms_start_stop.yml

@@ -17,7 +17,7 @@ setup:
               event_rate:
                 type: integer
   - do:
-      data_frame.put_data_frame_transform:
+      transform.put_transform:
         transform_id: "airline-transform-start-stop"
         body: >
           {
@@ -32,18 +32,18 @@ setup:
 ---
 teardown:
   - do:
-      data_frame.stop_data_frame_transform:
+      transform.stop_transform:
         transform_id: "airline-transform-start-stop"
         timeout: "10m"
         wait_for_completion: true
   - do:
-      data_frame.delete_data_frame_transform:
+      transform.delete_transform:
         transform_id: "airline-transform-start-stop"
 
 ---
 "Test start transform":
   - do:
-      data_frame.start_data_frame_transform:
+      transform.start_transform:
         transform_id: "airline-transform-start-stop"
   - match: { acknowledged: true }
 
@@ -51,25 +51,25 @@ teardown:
 "Test start missing transform":
   - do:
       catch: missing
-      data_frame.start_data_frame_transform:
+      transform.start_transform:
         transform_id: "missing-transform"
 
 ---
 "Test start already started transform":
   - do:
-      data_frame.start_data_frame_transform:
+      transform.start_transform:
         transform_id: "airline-transform-start-stop"
   - match: { acknowledged: true }
 
   - do:
       catch: /Cannot start transform \[airline-transform-start-stop\] as it is already started/
-      data_frame.start_data_frame_transform:
+      transform.start_transform:
         transform_id: "airline-transform-start-stop"
 
 ---
 "Verify start transform creates destination index with appropriate mapping":
   - do:
-      data_frame.start_data_frame_transform:
+      transform.start_transform:
         transform_id: "airline-transform-start-stop"
   - match: { acknowledged: true }
   - do:
@@ -84,7 +84,7 @@ teardown:
       indices.create:
         index: airline-data-by-airline-start-stop
   - do:
-      data_frame.start_data_frame_transform:
+      transform.start_transform:
         transform_id: "airline-transform-start-stop"
   - match: { acknowledged: true }
   - do:
@@ -94,37 +94,37 @@ teardown:
 ---
 "Test start/stop/start transform":
   - do:
-      data_frame.start_data_frame_transform:
+      transform.start_transform:
         transform_id: "airline-transform-start-stop"
   - match: { acknowledged: true }
 
   - do:
-      data_frame.get_data_frame_transform_stats:
+      transform.get_transform_stats:
         transform_id: "airline-transform-start-stop"
   - match: { count: 1 }
   - match: { transforms.0.id: "airline-transform-start-stop" }
   - match: { transforms.0.state: "/started|indexing/" }
 
   - do:
-      data_frame.stop_data_frame_transform:
+      transform.stop_transform:
         transform_id: "airline-transform-start-stop"
         wait_for_completion: true
   - match: { acknowledged: true }
 
   - do:
-      data_frame.get_data_frame_transform_stats:
+      transform.get_transform_stats:
         transform_id: "airline-transform-start-stop"
   - match: { count: 1 }
   - match: { transforms.0.id: "airline-transform-start-stop" }
   - match: { transforms.0.state: "stopped" }
 
   - do:
-      data_frame.start_data_frame_transform:
+      transform.start_transform:
         transform_id: "airline-transform-start-stop"
   - match: { acknowledged: true }
 
   - do:
-      data_frame.get_data_frame_transform_stats:
+      transform.get_transform_stats:
         transform_id: "airline-transform-start-stop"
   - match: { count: 1 }
   - match: { transforms.0.id: "airline-transform-start-stop" }
@@ -132,7 +132,7 @@ teardown:
 ---
 "Test start/stop/start continuous transform":
   - do:
-      data_frame.put_data_frame_transform:
+      transform.put_transform:
         transform_id: "airline-transform-start-stop-continuous"
         body: >
           {
@@ -151,82 +151,82 @@ teardown:
           }
 
   - do:
-      data_frame.start_data_frame_transform:
+      transform.start_transform:
         transform_id: "airline-transform-start-stop-continuous"
   - match: { acknowledged: true }
 
   - do:
-      data_frame.get_data_frame_transform_stats:
+      transform.get_transform_stats:
         transform_id: "airline-transform-start-stop-continuous"
   - match: { count: 1 }
   - match: { transforms.0.id: "airline-transform-start-stop-continuous" }
   - match: { transforms.0.state: "/started|indexing/" }
 
   - do:
-      data_frame.stop_data_frame_transform:
+      transform.stop_transform:
         transform_id: "airline-transform-start-stop-continuous"
         wait_for_completion: true
   - match: { acknowledged: true }
 
   - do:
-      data_frame.get_data_frame_transform_stats:
+      transform.get_transform_stats:
         transform_id: "airline-transform-start-stop-continuous"
   - match: { count: 1 }
   - match: { transforms.0.id: "airline-transform-start-stop-continuous" }
   - match: { transforms.0.state: "stopped" }
 
   - do:
-      data_frame.start_data_frame_transform:
+      transform.start_transform:
         transform_id: "airline-transform-start-stop-continuous"
   - match: { acknowledged: true }
 
   - do:
-      data_frame.get_data_frame_transform_stats:
+      transform.get_transform_stats:
         transform_id: "airline-transform-start-stop-continuous"
   - match: { count: 1 }
   - match: { transforms.0.id: "airline-transform-start-stop-continuous" }
   - match: { transforms.0.state: "/started|indexing/" }
 
   - do:
-      data_frame.stop_data_frame_transform:
+      transform.stop_transform:
         transform_id: "airline-transform-start-stop-continuous"
         wait_for_completion: true
   - match: { acknowledged: true }
 
   - do:
-      data_frame.delete_data_frame_transform:
+      transform.delete_transform:
         transform_id: "airline-transform-start-stop-continuous"
 ---
 "Test stop missing transform":
   - do:
       catch: missing
-      data_frame.stop_data_frame_transform:
+      transform.stop_transform:
         transform_id: "missing-transform"
 
 ---
 "Test stop missing transform by expression":
   - do:
-      data_frame.stop_data_frame_transform:
+      transform.stop_transform:
         allow_no_match: true
         transform_id: "missing-transform*"
 
   - do:
       catch: missing
-      data_frame.stop_data_frame_transform:
+      transform.stop_transform:
         allow_no_match: false
         transform_id: "missing-transform*"
 
 ---
 "Test stop already stopped transform":
   - do:
-      data_frame.stop_data_frame_transform:
+      transform.stop_transform:
         transform_id: "airline-transform-start-stop"
   - match: { acknowledged: true }
 
 ---
 "Test start/stop only starts/stops specified transform":
   - do:
-      data_frame.put_data_frame_transform:
+      transform.put_transform:
         transform_id: "airline-transform-start-later"
         body: >
           {
@@ -238,57 +238,57 @@ teardown:
             }
           }
   - do:
-      data_frame.start_data_frame_transform:
+      transform.start_transform:
         transform_id: "airline-transform-start-stop"
   - match: { acknowledged: true }
 
   - do:
-      data_frame.get_data_frame_transform_stats:
+      transform.get_transform_stats:
         transform_id: "airline-transform-start-stop"
   - match: { count: 1 }
   - match: { transforms.0.id: "airline-transform-start-stop" }
   - match: { transforms.0.state: "/started|indexing/" }
 
   - do:
-      data_frame.get_data_frame_transform_stats:
+      transform.get_transform_stats:
         transform_id: "airline-transform-start-later"
   - match: { count: 1 }
   - match: { transforms.0.id: "airline-transform-start-later" }
   - match: { transforms.0.state: "stopped" }
 
   - do:
-      data_frame.start_data_frame_transform:
+      transform.start_transform:
         transform_id: "airline-transform-start-later"
   - match: { acknowledged: true }
 
   - do:
-      data_frame.stop_data_frame_transform:
+      transform.stop_transform:
         transform_id: "airline-transform-start-stop"
         wait_for_completion: true
   - match: { acknowledged: true }
 
 
   - do:
-      data_frame.get_data_frame_transform_stats:
+      transform.get_transform_stats:
         transform_id: "airline-transform-start-later"
   - match: { count: 1 }
   - match: { transforms.0.id: "airline-transform-start-later" }
   - match: { transforms.0.state: "/started|indexing/" }
 
   - do:
-      data_frame.stop_data_frame_transform:
+      transform.stop_transform:
         transform_id: "airline-transform-start-later"
         wait_for_completion: true
   - match: { acknowledged: true }
 
   - do:
-      data_frame.delete_data_frame_transform:
+      transform.delete_transform:
         transform_id: "airline-transform-start-later"
 
 ---
 "Test stop all":
   - do:
-      data_frame.put_data_frame_transform:
+      transform.put_transform:
         transform_id: "airline-transform-stop-all"
         body: >
           {
@@ -300,35 +300,35 @@ teardown:
             }
           }
   - do:
-      data_frame.start_data_frame_transform:
+      transform.start_transform:
         transform_id: "airline-transform-stop-all"
   - match: { acknowledged: true }
 
   - do:
-      data_frame.start_data_frame_transform:
+      transform.start_transform:
         transform_id: "airline-transform-start-stop"
   - match: { acknowledged: true }
 
   - do:
-      data_frame.stop_data_frame_transform:
+      transform.stop_transform:
         transform_id: "_all"
         wait_for_completion: true
   - match: { acknowledged: true }
 
   - do:
-      data_frame.get_data_frame_transform_stats:
+      transform.get_transform_stats:
         transform_id: "*"
   - match: { count: 2 }
   - match: { transforms.0.state: "stopped" }
   - match: { transforms.1.state: "stopped" }
 
   - do:
-      data_frame.delete_data_frame_transform:
+      transform.delete_transform:
         transform_id: "airline-transform-stop-all"
 ---
 "Test start/stop with field alias":
   - do:
-      data_frame.put_data_frame_transform:
+      transform.put_transform:
         transform_id: "airline_via_field_alias"
         body: >
           {
@@ -340,7 +340,7 @@ teardown:
             }
           }
   - do:
-      data_frame.start_data_frame_transform:
+      transform.start_transform:
         transform_id: "airline_via_field_alias"
   - match: { acknowledged: true }
 

x-pack/plugin/src/test/resources/rest-api-spec/test/transform/transforms_stats.yml

@@ -14,7 +14,7 @@ setup:
               event_rate:
                 type: integer
   - do:
-      data_frame.put_data_frame_transform:
+      transform.put_transform:
         transform_id: "airline-transform-stats"
         body: >
           {
@@ -26,24 +26,24 @@ setup:
             }
           }
   - do:
-      data_frame.start_data_frame_transform:
+      transform.start_transform:
         transform_id: "airline-transform-stats"
 
 ---
 teardown:
   - do:
-      data_frame.stop_data_frame_transform:
+      transform.stop_transform:
         transform_id: "airline-transform-stats"
         wait_for_completion: true
 
   - do:
-      data_frame.delete_data_frame_transform:
+      transform.delete_transform:
         transform_id: "airline-transform-stats"
 
 ---
 "Test get transform stats":
   - do:
-      data_frame.get_data_frame_transform_stats:
+      transform.get_transform_stats:
         transform_id: "airline-transform-stats"
   - match: { count: 1 }
   - match: { transforms.0.id: "airline-transform-stats" }
@@ -63,7 +63,7 @@ teardown:
 ---
 "Test get transform stats on missing transform":
   - do:
-      data_frame.get_data_frame_transform_stats:
+      transform.get_transform_stats:
         transform_id: "missing-transform"
   - match: { count: 0 }
   - match: { transforms: [] }
@@ -71,7 +71,7 @@ teardown:
 ---
 "Test get multiple transform stats":
   - do:
-      data_frame.put_data_frame_transform:
+      transform.put_transform:
         transform_id: "airline-transform-stats-dos"
         body: >
           {
@@ -83,7 +83,7 @@ teardown:
             }
           }
   - do:
-      data_frame.put_data_frame_transform:
+      transform.put_transform:
         transform_id: "airline-transform-stats-the-third"
         body: >
           {
@@ -95,7 +95,7 @@ teardown:
             }
           }
   - do:
-      data_frame.get_data_frame_transform_stats:
+      transform.get_transform_stats:
         transform_id: "*"
   - match: { count: 3 }
   - match: { transforms.0.id: "airline-transform-stats" }
@@ -103,7 +103,7 @@ teardown:
   - match: { transforms.2.id: "airline-transform-stats-the-third" }
 
   - do:
-      data_frame.get_data_frame_transform_stats:
+      transform.get_transform_stats:
         transform_id: "_all"
   - match: { count: 3 }
   - match: { transforms.0.id: "airline-transform-stats" }
@@ -111,14 +111,14 @@ teardown:
   - match: { transforms.2.id: "airline-transform-stats-the-third" }
 
   - do:
-      data_frame.get_data_frame_transform_stats:
+      transform.get_transform_stats:
         transform_id: "airline-transform-stats-dos,airline-transform-stats-the*"
   - match: { count: 2 }
   - match: { transforms.0.id: "airline-transform-stats-dos" }
   - match: { transforms.1.id: "airline-transform-stats-the-third" }
 
   - do:
-      data_frame.get_data_frame_transform_stats:
+      transform.get_transform_stats:
         transform_id: "_all"
         from: 0
         size: 1
@@ -126,7 +126,7 @@ teardown:
   - match: { transforms.0.id: "airline-transform-stats" }
 
   - do:
-      data_frame.get_data_frame_transform_stats:
+      transform.get_transform_stats:
         transform_id: "_all"
         from: 1
         size: 2
@@ -135,18 +135,18 @@ teardown:
   - match: { transforms.1.id: "airline-transform-stats-the-third" }
 
   - do:
-      data_frame.delete_data_frame_transform:
+      transform.delete_transform:
         transform_id: "airline-transform-stats-dos"
 
   - do:
-      data_frame.delete_data_frame_transform:
+      transform.delete_transform:
         transform_id: "airline-transform-stats-the-third"
 
 
 ---
 "Test get multiple transform stats where one does not have a task":
   - do:
-      data_frame.put_data_frame_transform:
+      transform.put_transform:
         transform_id: "airline-transform-stats-dos"
         body: >
           {
@@ -158,14 +158,14 @@ teardown:
             }
           }
   - do:
-      data_frame.get_data_frame_transform_stats:
+      transform.get_transform_stats:
         transform_id: "*"
   - match: { count: 2 }
   - match: { transforms.0.id: "airline-transform-stats" }
   - match: { transforms.1.id: "airline-transform-stats-dos" }
 
   - do:
-      data_frame.get_data_frame_transform_stats:
+      transform.get_transform_stats:
         transform_id: "_all"
   - match: { count: 2 }
   - match: { transforms.0.id: "airline-transform-stats" }
@@ -175,7 +175,7 @@ teardown:
 "Test get single transform stats when it does not have a task":
 
   - do:
-      data_frame.put_data_frame_transform:
+      transform.put_transform:
         transform_id: "airline-transform-stats-dos"
         body: >
           {
@@ -187,7 +187,7 @@ teardown:
             }
           }
   - do:
-      data_frame.get_data_frame_transform_stats:
+      transform.get_transform_stats:
         transform_id: "airline-transform-stats-dos"
   - match: { count: 1 }
   - match: { transforms.0.id: "airline-transform-stats-dos" }
@@ -206,7 +206,7 @@ teardown:
 ---
 "Test get continuous transform stats":
   - do:
-      data_frame.put_data_frame_transform:
+      transform.put_transform:
         transform_id: "airline-transform-stats-continuous"
         body: >
           {
@@ -219,10 +219,10 @@ teardown:
             "sync": { "time": { "field": "time", "delay": "1m" } }
           }
   - do:
-      data_frame.start_data_frame_transform:
+      transform.start_transform:
         transform_id: "airline-transform-stats-continuous"
   - do:
-      data_frame.get_data_frame_transform_stats:
+      transform.get_transform_stats:
         transform_id: "airline-transform-stats-continuous"
   - match: { count: 1 }
   - match: { transforms.0.id: "airline-transform-stats-continuous" }
@@ -251,10 +251,10 @@ teardown:
   - match: { transforms.0.stats.exponential_avg_documents_processed: 0.0 }
 
   - do:
-      data_frame.stop_data_frame_transform:
+      transform.stop_transform:
         transform_id: "airline-transform-stats-continuous"
         wait_for_completion: true
 
   - do:
-      data_frame.delete_data_frame_transform:
+      transform.delete_transform:
         transform_id: "airline-transform-stats-continuous"

x-pack/plugin/src/test/resources/rest-api-spec/test/transform/transforms_update.yml

@@ -15,7 +15,7 @@ setup:
                 type: integer
 
   - do:
-      data_frame.put_data_frame_transform:
+      transform.put_transform:
         transform_id: "updating-airline-transform"
         body: >
           {
@@ -38,7 +38,7 @@ setup:
 "Test update transform with missing transform":
   - do:
       catch: /Transform with id \[missing-transform\] could not be found/
-      data_frame.update_data_frame_transform:
+      transform.update_transform:
         transform_id: "missing-transform"
         body: >
           {
@@ -48,7 +48,7 @@ setup:
 "Test update transform with frequency too low":
   - do:
       catch: /minimum permitted \[frequency\] is \[1s\]/
-      data_frame.update_data_frame_transform:
+      transform.update_transform:
         transform_id: "updating-airline-transform"
         body: >
           {
@@ -58,7 +58,7 @@ setup:
 "Test update transform with frequency too high":
   - do:
       catch: /highest permitted \[frequency\] is \[1h\]/
-      data_frame.update_data_frame_transform:
+      transform.update_transform:
         transform_id: "updating-airline-transform"
         body: >
           {
@@ -68,14 +68,14 @@ setup:
 "Test put transform with invalid source index":
   - do:
       catch: /Source index \[missing-index\] does not exist/
-      data_frame.update_data_frame_transform:
+      transform.update_transform:
         transform_id: "updating-airline-transform"
         body: >
           {
             "source": { "index": "missing-index" }
           }
   - do:
-      data_frame.update_data_frame_transform:
+      transform.update_transform:
         transform_id: "updating-airline-transform"
         defer_validation: true
         body: >
@@ -87,7 +87,7 @@ setup:
 ---
 "Test update transform when it is batch":
   - do:
-      data_frame.put_data_frame_transform:
+      transform.put_transform:
         transform_id: "batch-airline-transform"
         body: >
           {
@@ -99,7 +99,7 @@ setup:
             }
           }
   - do:
-      data_frame.update_data_frame_transform:
+      transform.update_transform:
         transform_id: "batch-airline-transform"
         body: >
           {
@@ -109,7 +109,7 @@ setup:
 
   - do:
       catch: /Cannot change the current sync configuration of transform \[batch-airline-transform\] from \[null\] to \[time\]/
-      data_frame.update_data_frame_transform:
+      transform.update_transform:
         transform_id: "batch-airline-transform"
         body: >
           {
@@ -137,7 +137,7 @@ setup:
               event_rate:
                 type: integer
   - do:
-      data_frame.get_data_frame_transform:
+      transform.get_transform:
         transform_id: "updating-airline-transform"
   - match: { count: 1 }
   - match: { transforms.0.id: "updating-airline-transform" }
@@ -154,7 +154,7 @@ setup:
   - match: { transforms.0.frequency: "60s" }
 
   - do:
-      data_frame.update_data_frame_transform:
+      transform.update_transform:
         transform_id: "updating-airline-transform"
         body: >
           {
@@ -180,7 +180,7 @@ setup:
   - match: { frequency: "5s" }
 
   - do:
-      data_frame.get_data_frame_transform:
+      transform.get_transform:
         transform_id: "updating-airline-transform"
   - match: { count: 1 }
   - match: { transforms.0.id: "updating-airline-transform" }
@@ -200,7 +200,7 @@ setup:
 "Test transform where dest is included in source":
   - do:
       catch: /Destination index \[airline-data-by-airline\] is included in source expression \[airline-data/
-      data_frame.update_data_frame_transform:
+      transform.update_transform:
         transform_id: "updating-airline-transform"
         body: >
           {
@@ -211,7 +211,7 @@ setup:
           }
 
   - do:
-      data_frame.update_data_frame_transform:
+      transform.update_transform:
         transform_id: "updating-airline-transform"
         defer_validation: true
         body: >
@@ -238,7 +238,7 @@ setup:
         index: created-destination-index
         name: dest-index
   - do:
-      data_frame.update_data_frame_transform:
+      transform.update_transform:
         transform_id: "updating-airline-transform"
         body: >
           {
@@ -256,7 +256,7 @@ setup:
 
   - do:
       catch: /Destination index \[created-destination-index\] is included in source expression \[created-destination-index\]/
-      data_frame.update_data_frame_transform:
+      transform.update_transform:
         transform_id: "updating-airline-transform"
         body: >
           {
@@ -281,7 +281,7 @@ setup:
         name: dest2-index
   - do:
       catch: /Destination index \[dest2-index\] should refer to a single index/
-      data_frame.update_data_frame_transform:
+      transform.update_transform:
         transform_id: "updating-airline-transform"
         body: >
           {
@@ -291,7 +291,7 @@ setup:
 "Test invalid destination index name":
   - do:
       catch: /dest\.index \[DeStInAtIoN\] must be lowercase/
-      data_frame.update_data_frame_transform:
+      transform.update_transform:
         transform_id: "updating-airline-transform"
         body: >
           {
@@ -299,7 +299,7 @@ setup:
           }
   - do:
       catch: /Invalid index name \[destination#dest\], must not contain \'#\'/
-      data_frame.update_data_frame_transform:
+      transform.update_transform:
         transform_id: "updating-airline-transform"
         body: >
           {

x-pack/plugin/transform/qa/multi-node-tests/src/test/java/org/elasticsearch/xpack/transform/integration/TransformIT.java

@@ -16,9 +16,9 @@ import org.elasticsearch.action.search.SearchResponse;
 import org.elasticsearch.action.support.WriteRequest;
 import org.elasticsearch.client.RequestOptions;
 import org.elasticsearch.client.RestHighLevelClient;
-import org.elasticsearch.client.transform.transforms.DataFrameTransformConfig;
-import org.elasticsearch.client.transform.transforms.DataFrameTransformConfigUpdate;
-import org.elasticsearch.client.transform.transforms.DataFrameTransformStats;
+import org.elasticsearch.client.transform.transforms.TransformConfig;
+import org.elasticsearch.client.transform.transforms.TransformConfigUpdate;
+import org.elasticsearch.client.transform.transforms.TransformStats;
 import org.elasticsearch.client.transform.transforms.DestConfig;
 import org.elasticsearch.client.transform.transforms.TimeSyncConfig;
 import org.elasticsearch.client.transform.transforms.pivot.SingleGroupSource;
@@ -65,7 +65,7 @@ public class TransformIT extends TransformIntegTestCase {
             .addAggregator(AggregationBuilders.avg("review_score").field("stars"))
             .addAggregator(AggregationBuilders.max("timestamp").field("timestamp"));
 
-        DataFrameTransformConfig config = createTransformConfig("transform-crud",
+        TransformConfig config = createTransformConfig("transform-crud",
             groups,
             aggs,
             "reviews-by-user-business-day",
@@ -78,7 +78,7 @@ public class TransformIT extends TransformIntegTestCase {
 
         stopTransform(config.getId());
 
-        DataFrameTransformConfig storedConfig = getTransform(config.getId()).getTransformConfigurations().get(0);
+        TransformConfig storedConfig = getTransform(config.getId()).getTransformConfigurations().get(0);
         assertThat(storedConfig.getVersion(), equalTo(Version.CURRENT));
         Instant now = Instant.now();
         assertTrue("[create_time] is not before current time", storedConfig.getCreateTime().isBefore(now));
@@ -98,7 +98,7 @@ public class TransformIT extends TransformIntegTestCase {
             .addAggregator(AggregationBuilders.avg("review_score").field("stars"))
             .addAggregator(AggregationBuilders.max("timestamp").field("timestamp"));
 
-        DataFrameTransformConfig config = createTransformConfigBuilder("transform-crud",
+        TransformConfig config = createTransformConfigBuilder("transform-crud",
             groups,
             aggs,
             "reviews-by-user-business-day",
@@ -112,7 +112,7 @@ public class TransformIT extends TransformIntegTestCase {
 
         waitUntilCheckpoint(config.getId(), 1L);
         assertThat(getTransformStats(config.getId()).getTransformsStats().get(0).getState(),
-                equalTo(DataFrameTransformStats.State.STARTED));
+                equalTo(TransformStats.State.STARTED));
 
         long docsIndexed = getTransformStats(config.getId())
             .getTransformsStats()
@@ -120,7 +120,7 @@ public class TransformIT extends TransformIntegTestCase {
             .getIndexerStats()
             .getNumDocuments();
 
-        DataFrameTransformConfig storedConfig = getTransform(config.getId()).getTransformConfigurations().get(0);
+        TransformConfig storedConfig = getTransform(config.getId()).getTransformConfigurations().get(0);
         assertThat(storedConfig.getVersion(), equalTo(Version.CURRENT));
         Instant now = Instant.now();
         assertTrue("[create_time] is not before current time", storedConfig.getCreateTime().isBefore(now));
@@ -155,7 +155,7 @@ public class TransformIT extends TransformIntegTestCase {
 
         String id = "transform-to-update";
         String dest = "reviews-by-user-business-day-to-update";
-        DataFrameTransformConfig config = createTransformConfigBuilder(id,
+        TransformConfig config = createTransformConfigBuilder(id,
             groups,
             aggs,
             dest,
@@ -169,7 +169,7 @@ public class TransformIT extends TransformIntegTestCase {
 
         waitUntilCheckpoint(config.getId(), 1L);
         assertThat(getTransformStats(config.getId()).getTransformsStats().get(0).getState(),
-            oneOf(DataFrameTransformStats.State.STARTED, DataFrameTransformStats.State.INDEXING));
+            oneOf(TransformStats.State.STARTED, TransformStats.State.INDEXING));
 
         long docsIndexed = getTransformStats(config.getId())
             .getTransformsStats()
@@ -177,13 +177,13 @@ public class TransformIT extends TransformIntegTestCase {
             .getIndexerStats()
             .getNumDocuments();
 
-        DataFrameTransformConfig storedConfig = getTransform(config.getId()).getTransformConfigurations().get(0);
+        TransformConfig storedConfig = getTransform(config.getId()).getTransformConfigurations().get(0);
         assertThat(storedConfig.getVersion(), equalTo(Version.CURRENT));
         Instant now = Instant.now();
         assertTrue("[create_time] is not before current time", storedConfig.getCreateTime().isBefore(now));
 
         String pipelineId = "add_forty_two";
-        DataFrameTransformConfigUpdate update = DataFrameTransformConfigUpdate.builder()
+        TransformConfigUpdate update = TransformConfigUpdate.builder()
             .setDescription("updated config")
             .setDest(DestConfig.builder().setIndex(dest).setPipeline(pipelineId).build())
             .build();

x-pack/plugin/transform/qa/multi-node-tests/src/test/java/org/elasticsearch/xpack/transform/integration/TransformIntegTestCase.java

@@ -16,22 +16,22 @@ import org.elasticsearch.client.RestHighLevelClient;
 import org.elasticsearch.client.core.AcknowledgedResponse;
 import org.elasticsearch.client.indices.CreateIndexRequest;
 import org.elasticsearch.client.indices.CreateIndexResponse;
-import org.elasticsearch.client.transform.DeleteDataFrameTransformRequest;
-import org.elasticsearch.client.transform.GetDataFrameTransformRequest;
-import org.elasticsearch.client.transform.GetDataFrameTransformResponse;
-import org.elasticsearch.client.transform.GetDataFrameTransformStatsRequest;
-import org.elasticsearch.client.transform.GetDataFrameTransformStatsResponse;
-import org.elasticsearch.client.transform.PutDataFrameTransformRequest;
-import org.elasticsearch.client.transform.StartDataFrameTransformRequest;
-import org.elasticsearch.client.transform.StartDataFrameTransformResponse;
-import org.elasticsearch.client.transform.StopDataFrameTransformRequest;
-import org.elasticsearch.client.transform.StopDataFrameTransformResponse;
-import org.elasticsearch.client.transform.UpdateDataFrameTransformRequest;
-import org.elasticsearch.client.transform.transforms.DataFrameTransformConfig;
-import org.elasticsearch.client.transform.transforms.DataFrameTransformConfigUpdate;
+import org.elasticsearch.client.transform.DeleteTransformRequest;
+import org.elasticsearch.client.transform.GetTransformRequest;
+import org.elasticsearch.client.transform.GetTransformResponse;
+import org.elasticsearch.client.transform.GetTransformStatsRequest;
+import org.elasticsearch.client.transform.GetTransformStatsResponse;
+import org.elasticsearch.client.transform.PutTransformRequest;
+import org.elasticsearch.client.transform.StartTransformRequest;
+import org.elasticsearch.client.transform.StartTransformResponse;
+import org.elasticsearch.client.transform.StopTransformRequest;
+import org.elasticsearch.client.transform.StopTransformResponse;
+import org.elasticsearch.client.transform.UpdateTransformRequest;
 import org.elasticsearch.client.transform.transforms.DestConfig;
 import org.elasticsearch.client.transform.transforms.QueryConfig;
 import org.elasticsearch.client.transform.transforms.SourceConfig;
+import org.elasticsearch.client.transform.transforms.TransformConfig;
+import org.elasticsearch.client.transform.transforms.TransformConfigUpdate;
 import org.elasticsearch.client.transform.transforms.pivot.AggregationConfig;
 import org.elasticsearch.client.transform.transforms.pivot.DateHistogramGroupSource;
 import org.elasticsearch.client.transform.transforms.pivot.GroupConfig;
@@ -70,7 +70,7 @@ import static org.hamcrest.core.Is.is;
 
 abstract class TransformIntegTestCase extends ESRestTestCase {
 
-    private Map<String, DataFrameTransformConfig> transformConfigs = new HashMap<>();
+    private Map<String, TransformConfig> transformConfigs = new HashMap<>();
 
     protected void cleanUp() throws IOException {
         cleanUpTransforms();
@@ -78,54 +78,54 @@ abstract class TransformIntegTestCase extends ESRestTestCase {
     }
 
     protected void cleanUpTransforms() throws IOException {
-        for (DataFrameTransformConfig config : transformConfigs.values()) {
+        for (TransformConfig config : transformConfigs.values()) {
             stopTransform(config.getId());
             deleteTransform(config.getId());
         }
         transformConfigs.clear();
     }
 
-    protected StopDataFrameTransformResponse stopTransform(String id) throws IOException {
+    protected StopTransformResponse stopTransform(String id) throws IOException {
         RestHighLevelClient restClient = new TestRestHighLevelClient();
-        return restClient.dataFrame().stopDataFrameTransform(new StopDataFrameTransformRequest(id, true, null), RequestOptions.DEFAULT);
+        return restClient.transform().stopTransform(new StopTransformRequest(id, true, null), RequestOptions.DEFAULT);
     }
 
-    protected StartDataFrameTransformResponse startTransform(String id, RequestOptions options) throws IOException {
+    protected StartTransformResponse startTransform(String id, RequestOptions options) throws IOException {
         RestHighLevelClient restClient = new TestRestHighLevelClient();
-        return restClient.dataFrame().startDataFrameTransform(new StartDataFrameTransformRequest(id), options);
+        return restClient.transform().startTransform(new StartTransformRequest(id), options);
     }
 
     protected AcknowledgedResponse deleteTransform(String id) throws IOException {
         RestHighLevelClient restClient = new TestRestHighLevelClient();
         AcknowledgedResponse response =
-            restClient.dataFrame().deleteDataFrameTransform(new DeleteDataFrameTransformRequest(id), RequestOptions.DEFAULT);
+            restClient.transform().deleteTransform(new DeleteTransformRequest(id), RequestOptions.DEFAULT);
         if (response.isAcknowledged()) {
             transformConfigs.remove(id);
         }
         return response;
     }
 
-    protected AcknowledgedResponse putTransform(DataFrameTransformConfig config, RequestOptions options) throws IOException {
+    protected AcknowledgedResponse putTransform(TransformConfig config, RequestOptions options) throws IOException {
         if (transformConfigs.keySet().contains(config.getId())) {
             throw new IllegalArgumentException("transform [" + config.getId() + "] is already registered");
         }
         RestHighLevelClient restClient = new TestRestHighLevelClient();
         AcknowledgedResponse response =
-            restClient.dataFrame().putDataFrameTransform(new PutDataFrameTransformRequest(config), options);
+            restClient.transform().putTransform(new PutTransformRequest(config), options);
         if (response.isAcknowledged()) {
             transformConfigs.put(config.getId(), config);
         }
         return response;
     }
 
-    protected GetDataFrameTransformStatsResponse getTransformStats(String id) throws IOException {
+    protected GetTransformStatsResponse getTransformStats(String id) throws IOException {
         RestHighLevelClient restClient = new TestRestHighLevelClient();
-        return restClient.dataFrame().getDataFrameTransformStats(new GetDataFrameTransformStatsRequest(id), RequestOptions.DEFAULT);
+        return restClient.transform().getTransformStats(new GetTransformStatsRequest(id), RequestOptions.DEFAULT);
     }
 
-    protected GetDataFrameTransformResponse getTransform(String id) throws IOException {
+    protected GetTransformResponse getTransform(String id) throws IOException {
         RestHighLevelClient restClient = new TestRestHighLevelClient();
-        return restClient.dataFrame().getDataFrameTransform(new GetDataFrameTransformRequest(id), RequestOptions.DEFAULT);
+        return restClient.transform().getTransform(new GetTransformRequest(id), RequestOptions.DEFAULT);
     }
 
     protected void waitUntilCheckpoint(String id, long checkpoint) throws Exception {
@@ -195,7 +195,7 @@ abstract class TransformIntegTestCase extends ESRestTestCase {
         return builder.build();
     }
 
-    protected DataFrameTransformConfig createTransformConfig(String id,
+    protected TransformConfig createTransformConfig(String id,
                                                     Map<String, SingleGroupSource> groups,
                                                     AggregatorFactories.Builder aggregations,
                                                     String destinationIndex,
@@ -203,13 +203,13 @@ abstract class TransformIntegTestCase extends ESRestTestCase {
         return createTransformConfig(id, groups, aggregations, destinationIndex, QueryBuilders.matchAllQuery(), sourceIndices);
     }
 
-    protected DataFrameTransformConfig.Builder createTransformConfigBuilder(String id,
+    protected TransformConfig.Builder createTransformConfigBuilder(String id,
                                                                    Map<String, SingleGroupSource> groups,
                                                                    AggregatorFactories.Builder aggregations,
                                                                    String destinationIndex,
                                                                    QueryBuilder queryBuilder,
                                                                    String... sourceIndices) throws Exception {
-        return DataFrameTransformConfig.builder()
+        return TransformConfig.builder()
             .setId(id)
             .setSource(SourceConfig.builder().setIndex(sourceIndices).setQueryConfig(createQueryConfig(queryBuilder)).build())
             .setDest(DestConfig.builder().setIndex(destinationIndex).build())
@@ -218,7 +218,7 @@ abstract class TransformIntegTestCase extends ESRestTestCase {
             .setDescription("Test transform config id: " + id);
     }
 
-    protected DataFrameTransformConfig createTransformConfig(String id,
+    protected TransformConfig createTransformConfig(String id,
                                                     Map<String, SingleGroupSource> groups,
                                                     AggregatorFactories.Builder aggregations,
                                                     String destinationIndex,
@@ -233,9 +233,9 @@ abstract class TransformIntegTestCase extends ESRestTestCase {
         assertThat(response.buildFailureMessage(), response.hasFailures(), is(false));
     }
 
-    protected void updateConfig(String id, DataFrameTransformConfigUpdate update) throws Exception {
+    protected void updateConfig(String id, TransformConfigUpdate update) throws Exception {
         RestHighLevelClient restClient = new TestRestHighLevelClient();
-        restClient.dataFrame().updateDataFrameTransform(new UpdateDataFrameTransformRequest(update, id), RequestOptions.DEFAULT);
+        restClient.transform().updateTransform(new UpdateTransformRequest(update, id), RequestOptions.DEFAULT);
     }
 
     protected void createReviewsIndex(String indexName, int numDocs) throws Exception {

x-pack/plugin/transform/qa/single-node-tests/src/test/java/org/elasticsearch/xpack/transform/integration/TransformInternalIndexIT.java

@@ -19,11 +19,11 @@ import org.elasticsearch.xpack.core.transform.TransformField;
 import org.elasticsearch.xpack.core.transform.transforms.TransformConfig;
 import org.elasticsearch.xpack.transform.persistence.TransformInternalIndex;
 import org.elasticsearch.client.indices.CreateIndexRequest;
-import org.elasticsearch.client.transform.GetDataFrameTransformRequest;
-import org.elasticsearch.client.transform.GetDataFrameTransformResponse;
-import org.elasticsearch.client.transform.UpdateDataFrameTransformRequest;
-import org.elasticsearch.client.transform.UpdateDataFrameTransformResponse;
-import org.elasticsearch.client.transform.transforms.DataFrameTransformConfigUpdate;
+import org.elasticsearch.client.transform.GetTransformRequest;
+import org.elasticsearch.client.transform.GetTransformResponse;
+import org.elasticsearch.client.transform.UpdateTransformRequest;
+import org.elasticsearch.client.transform.UpdateTransformResponse;
+import org.elasticsearch.client.transform.transforms.TransformConfigUpdate;
 import org.elasticsearch.common.settings.Settings;
 import org.elasticsearch.common.util.concurrent.ThreadContext;
 import org.elasticsearch.common.xcontent.XContentType;
@@ -88,12 +88,12 @@ public class TransformInternalIndexIT extends ESRestTestCase {
             RequestOptions.DEFAULT);
         assertThat(getResponse.isExists(), is(true));
 
-        GetDataFrameTransformResponse response = client.dataFrame()
-            .getDataFrameTransform(new GetDataFrameTransformRequest(transformId), RequestOptions.DEFAULT);
+        GetTransformResponse response = client.transform()
+            .getTransform(new GetTransformRequest(transformId), RequestOptions.DEFAULT);
         assertThat(response.getTransformConfigurations().get(0).getId(), equalTo(transformId));
 
-        UpdateDataFrameTransformResponse updated = client.dataFrame().updateDataFrameTransform(
-            new UpdateDataFrameTransformRequest(DataFrameTransformConfigUpdate.builder().setDescription("updated").build(), transformId),
+        UpdateTransformResponse updated = client.transform().updateTransform(
+            new UpdateTransformRequest(TransformConfigUpdate.builder().setDescription("updated").build(), transformId),
             RequestOptions.DEFAULT);
 
         assertThat(updated.getTransformConfiguration().getId(), equalTo(transformId));

x-pack/qa/rolling-upgrade/src/test/java/org/elasticsearch/upgrades/DataFrameSurvivesUpgradeIT.java

@@ -11,9 +11,9 @@ import org.elasticsearch.Version;
 import org.elasticsearch.client.Request;
 import org.elasticsearch.client.Response;
 import org.elasticsearch.client.core.IndexerState;
-import org.elasticsearch.client.transform.GetDataFrameTransformStatsResponse;
-import org.elasticsearch.client.transform.transforms.DataFrameTransformConfig;
-import org.elasticsearch.client.transform.transforms.DataFrameTransformStats;
+import org.elasticsearch.client.transform.GetTransformStatsResponse;
+import org.elasticsearch.client.transform.transforms.TransformConfig;
+import org.elasticsearch.client.transform.transforms.TransformStats;
 import org.elasticsearch.client.transform.transforms.DestConfig;
 import org.elasticsearch.client.transform.transforms.SourceConfig;
 import org.elasticsearch.client.transform.transforms.TimeSyncConfig;
@@ -129,7 +129,7 @@ public class DataFrameSurvivesUpgradeIT extends AbstractUpgradeTestCase {
             totalDocsWrittenSum += docs * ENTITIES.size();
         }
         long totalDocsWritten = totalDocsWrittenSum;
-        DataFrameTransformConfig config = DataFrameTransformConfig.builder()
+        TransformConfig config = TransformConfig.builder()
             .setSyncConfig(new TimeSyncConfig("timestamp", TimeValue.timeValueSeconds(1)))
             .setPivotConfig(PivotConfig.builder()
                 .setAggregations(new AggregatorFactories.Builder().addAggregator(AggregationBuilders.avg("stars").field("stars")))
@@ -146,12 +146,12 @@ public class DataFrameSurvivesUpgradeIT extends AbstractUpgradeTestCase {
         waitUntilAfterCheckpoint(CONTINUOUS_DATA_FRAME_ID, 0L);
 
         assertBusy(() -> {
-            DataFrameTransformStats stateAndStats = getTransformStats(CONTINUOUS_DATA_FRAME_ID);
+            TransformStats stateAndStats = getTransformStats(CONTINUOUS_DATA_FRAME_ID);
             assertThat(stateAndStats.getIndexerStats().getOutputDocuments(), equalTo((long)ENTITIES.size()));
             assertThat(stateAndStats.getIndexerStats().getNumDocuments(), equalTo(totalDocsWritten));
             // Even if we get back to started, we may periodically get set back to `indexing` when triggered.
             // Though short lived due to no changes on the source indices, it could result in flaky test behavior
-            assertThat(stateAndStats.getState(), oneOf(DataFrameTransformStats.State.STARTED, DataFrameTransformStats.State.INDEXING));
+            assertThat(stateAndStats.getState(), oneOf(TransformStats.State.STARTED, TransformStats.State.INDEXING));
         }, 120, TimeUnit.SECONDS);
 
 
@@ -165,13 +165,13 @@ public class DataFrameSurvivesUpgradeIT extends AbstractUpgradeTestCase {
         // A continuous data frame should automatically become started when it gets assigned to a node
         // if it was assigned to the node that was removed from the cluster
         assertBusy(() -> {
-            DataFrameTransformStats stateAndStats = getTransformStats(CONTINUOUS_DATA_FRAME_ID);
-            assertThat(stateAndStats.getState(), oneOf(DataFrameTransformStats.State.STARTED, DataFrameTransformStats.State.INDEXING));
+            TransformStats stateAndStats = getTransformStats(CONTINUOUS_DATA_FRAME_ID);
+            assertThat(stateAndStats.getState(), oneOf(TransformStats.State.STARTED, TransformStats.State.INDEXING));
         },
         120,
         TimeUnit.SECONDS);
 
-        DataFrameTransformStats previousStateAndStats = getTransformStats(CONTINUOUS_DATA_FRAME_ID);
+        TransformStats previousStateAndStats = getTransformStats(CONTINUOUS_DATA_FRAME_ID);
 
         // Add a new user and write data to it
         // This is so we can have more reliable data counts, as writing to existing entities requires
@@ -190,10 +190,10 @@ public class DataFrameSurvivesUpgradeIT extends AbstractUpgradeTestCase {
             greaterThanOrEqualTo(docs + previousStateAndStats.getIndexerStats().getNumDocuments())),
             120,
             TimeUnit.SECONDS);
-        DataFrameTransformStats stateAndStats = getTransformStats(CONTINUOUS_DATA_FRAME_ID);
+        TransformStats stateAndStats = getTransformStats(CONTINUOUS_DATA_FRAME_ID);
 
         assertThat(stateAndStats.getState(),
-            oneOf(DataFrameTransformStats.State.STARTED, DataFrameTransformStats.State.INDEXING));
+            oneOf(TransformStats.State.STARTED, TransformStats.State.INDEXING));
         awaitWrittenIndexerState(CONTINUOUS_DATA_FRAME_ID, (responseBody) -> {
             Map<String, Object> indexerStats = (Map<String,Object>)((List<?>)XContentMapValues.extractValue("hits.hits._source.stats",
                 responseBody))
@@ -245,7 +245,7 @@ public class DataFrameSurvivesUpgradeIT extends AbstractUpgradeTestCase {
         });
     }
 
-    private void putTransform(String id, DataFrameTransformConfig config) throws IOException {
+    private void putTransform(String id, TransformConfig config) throws IOException {
         final Request createDataframeTransformRequest = new Request("PUT", DATAFRAME_ENDPOINT + id);
         createDataframeTransformRequest.setJsonEntity(Strings.toString(config));
         Response response = client().performRequest(createDataframeTransformRequest);
@@ -270,7 +270,7 @@ public class DataFrameSurvivesUpgradeIT extends AbstractUpgradeTestCase {
         assertEquals(200, response.getStatusLine().getStatusCode());
     }
 
-    private DataFrameTransformStats getTransformStats(String id) throws IOException {
+    private TransformStats getTransformStats(String id) throws IOException {
         final Request getStats = new Request("GET", DATAFRAME_ENDPOINT + id + "/_stats");
         Response response = client().performRequest(getStats);
         assertEquals(200, response.getStatusLine().getStatusCode());
@@ -278,7 +278,7 @@ public class DataFrameSurvivesUpgradeIT extends AbstractUpgradeTestCase {
         try (XContentParser parser = xContentType.xContent().createParser(
             NamedXContentRegistry.EMPTY, DeprecationHandler.THROW_UNSUPPORTED_OPERATION,
             response.getEntity().getContent())) {
-            GetDataFrameTransformStatsResponse resp = GetDataFrameTransformStatsResponse.fromXContent(parser);
+            GetTransformStatsResponse resp = GetTransformStatsResponse.fromXContent(parser);
             assertThat(resp.getTransformsStats(), hasSize(1));
             return resp.getTransformsStats().get(0);
         }

x-pack/qa/rolling-upgrade/src/test/resources/rest-api-spec/test/mixed_cluster/80_data_frame_jobs_crud.yml

@@ -2,16 +2,16 @@
 "Test put batch data frame transforms on mixed cluster":
   - do:
       cluster.health:
-        index: "dataframe-transform-airline-data"
+        index: "transform-airline-data"
         wait_for_status: green
         timeout: 70s
 
   - do:
-      data_frame.put_data_frame_transform:
+      transform.put_transform:
         transform_id: "mixed-simple-transform"
         body: >
           {
-            "source": { "index": "dataframe-transform-airline-data" },
+            "source": { "index": "transform-airline-data" },
             "dest": { "index": "mixed-simple-transform-idx" },
             "pivot": {
               "group_by": { "airline": {"terms": {"field": "airline"}}},
@@ -21,11 +21,11 @@
   - match: { acknowledged: true }
 
   - do:
-      data_frame.start_data_frame_transform:
+      transform.start_transform:
         transform_id: "mixed-simple-transform"
   - match: { acknowledged: true }
   - do:
-      data_frame.get_data_frame_transform_stats:
+      transform.get_transform_stats:
         transform_id: "mixed-simple-transform"
   - match: { count: 1 }
   - match: { transforms.0.id: "mixed-simple-transform" }
@@ -34,13 +34,13 @@
   #- match: { transforms.0.state: "/started|indexing|stopping|stopped/" }
 
   - do:
-      data_frame.stop_data_frame_transform:
+      transform.stop_transform:
         transform_id: "mixed-simple-transform"
         wait_for_completion: true
   - match: { acknowledged: true }
 
   - do:
-      data_frame.get_data_frame_transform_stats:
+      transform.get_transform_stats:
         transform_id: "mixed-simple-transform"
   - match: { count: 1 }
   - match: { transforms.0.id: "mixed-simple-transform" }
@@ -49,12 +49,12 @@
   #- match: { transforms.0.state: "stopped" }
 
   - do:
-      data_frame.put_data_frame_transform:
+      transform.put_transform:
         transform_id: "mixed-complex-transform"
         body: >
           {
             "source": {
-              "index": "dataframe-transform-airline-data",
+              "index": "transform-airline-data",
               "query": {
                 "bool": {
                   "filter": {"term": {"airline": "ElasticAir"}}
@@ -76,17 +76,17 @@
   - match: { acknowledged: true }
 
   - do:
-      data_frame.get_data_frame_transform:
+      transform.get_transform:
         transform_id: "mixed-complex-transform"
   - match: { count: 1 }
   - match: { transforms.0.id: "mixed-complex-transform" }
 
   - do:
-      data_frame.start_data_frame_transform:
+      transform.start_transform:
         transform_id: "mixed-complex-transform"
   - match: { acknowledged: true }
   - do:
-      data_frame.get_data_frame_transform_stats:
+      transform.get_transform_stats:
         transform_id: "mixed-complex-transform"
   - match: { count: 1 }
   - match: { transforms.0.id: "mixed-complex-transform" }
@@ -95,13 +95,13 @@
   #- match: { transforms.0.state: "/started|indexing|stopping|stopped/" }
 
   - do:
-      data_frame.stop_data_frame_transform:
+      transform.stop_transform:
         transform_id: "mixed-complex-transform"
         wait_for_completion: true
   - match: { acknowledged: true }
 
   - do:
-      data_frame.get_data_frame_transform_stats:
+      transform.get_transform_stats:
         transform_id: "mixed-complex-transform"
   - match: { count: 1 }
   - match: { transforms.0.id: "mixed-complex-transform" }
@@ -113,16 +113,16 @@
 "Test put continuous data frame transform on mixed cluster":
   - do:
       cluster.health:
-        index: "dataframe-transform-airline-data-cont"
+        index: "transform-airline-data-cont"
         wait_for_status: green
         timeout: 70s
 
   - do:
-      data_frame.put_data_frame_transform:
+      transform.put_transform:
         transform_id: "mixed-simple-continuous-transform"
         body: >
           {
-            "source": { "index": "dataframe-transform-airline-data-cont" },
+            "source": { "index": "transform-airline-data-cont" },
             "dest": { "index": "mixed-simple-continuous-transform-idx" },
             "pivot": {
               "group_by": { "airline": {"terms": {"field": "airline"}}},
@@ -138,7 +138,7 @@
   - match: { acknowledged: true }
 
   - do:
-      data_frame.get_data_frame_transform:
+      transform.get_transform:
         transform_id: "mixed-simple-continuous-transform"
   - match: { count: 1 }
   - match: { transforms.0.id: "mixed-simple-continuous-transform" }
@@ -148,24 +148,24 @@
   - is_true: transforms.0.create_time
 
   - do:
-      data_frame.start_data_frame_transform:
+      transform.start_transform:
         transform_id: "mixed-simple-continuous-transform"
   - match: { acknowledged: true }
   - do:
-      data_frame.get_data_frame_transform_stats:
+      transform.get_transform_stats:
         transform_id: "mixed-simple-continuous-transform"
   - match: { count: 1 }
   - match: { transforms.0.id: "mixed-simple-continuous-transform" }
   - match: { transforms.0.state: "/started|indexing/" }
 
   - do:
-      data_frame.stop_data_frame_transform:
+      transform.stop_transform:
         transform_id: "mixed-simple-continuous-transform"
         wait_for_completion: true
   - match: { acknowledged: true }
 
   - do:
-      data_frame.get_data_frame_transform_stats:
+      transform.get_transform_stats:
         transform_id: "mixed-simple-continuous-transform"
   - match: { count: 1 }
   - match: { transforms.0.id: "mixed-simple-continuous-transform" }
@@ -175,26 +175,26 @@
 "Test GET, start, and stop old cluster batch transforms":
   - do:
       cluster.health:
-        index: "dataframe-transform-airline-data"
+        index: "transform-airline-data"
         wait_for_status: green
         timeout: 70s
 
   - do:
-      data_frame.get_data_frame_transform:
+      transform.get_transform:
         transform_id: "old-simple-transform"
   - match: { count: 1 }
   - match: { transforms.0.id: "old-simple-transform" }
-  - match: { transforms.0.source.index.0: "dataframe-transform-airline-data" }
+  - match: { transforms.0.source.index.0: "transform-airline-data" }
   - match: { transforms.0.dest.index: "old-simple-transform-idx" }
   - match: { transforms.0.pivot.group_by.airline.terms.field: "airline" }
   - match: { transforms.0.pivot.aggregations.avg_response.avg.field: "responsetime" }
 
   - do:
-      data_frame.start_data_frame_transform:
+      transform.start_transform:
         transform_id: "old-simple-transform"
   - match: { acknowledged: true }
   - do:
-      data_frame.get_data_frame_transform_stats:
+      transform.get_transform_stats:
         transform_id: "old-simple-transform"
   - match: { count: 1 }
   - match: { transforms.0.id: "old-simple-transform" }
@@ -203,12 +203,12 @@
   #- match: { transforms.0.state: "/started|indexing|stopping|stopped/" }
 
   - do:
-      data_frame.stop_data_frame_transform:
+      transform.stop_transform:
         transform_id: "old-simple-transform"
         wait_for_completion: true
   - match: { acknowledged: true }
   - do:
-      data_frame.get_data_frame_transform_stats:
+      transform.get_transform_stats:
         transform_id: "old-simple-transform"
   - match: { count: 1 }
   - match: { transforms.0.id: "old-simple-transform" }
@@ -217,11 +217,11 @@
   #- match: { transforms.0.state: "stopped" }
 
   - do:
-      data_frame.get_data_frame_transform:
+      transform.get_transform:
         transform_id: "old-complex-transform"
   - match: { count: 1 }
   - match: { transforms.0.id: "old-complex-transform" }
-  - match: { transforms.0.source.index.0: "dataframe-transform-airline-data" }
+  - match: { transforms.0.source.index.0: "transform-airline-data" }
   - match: { transforms.0.dest.index: "old-complex-transform-idx" }
   - match: { transforms.0.pivot.group_by.airline.terms.field: "airline" }
   - match: { transforms.0.pivot.group_by.day.date_histogram.field: "timestamp" }
@@ -229,11 +229,11 @@
   - match: { transforms.0.pivot.aggregations.avg_response.avg.field: "responsetime" }
 
   - do:
-      data_frame.start_data_frame_transform:
+      transform.start_transform:
         transform_id: "old-complex-transform"
   - match: { acknowledged: true }
   - do:
-      data_frame.get_data_frame_transform_stats:
+      transform.get_transform_stats:
         transform_id: "old-complex-transform"
   - match: { count: 1 }
   - match: { transforms.0.id: "old-complex-transform" }
@@ -242,12 +242,12 @@
   #- match: { transforms.0.state: "/started|indexing|stopping|stopped/" }
 
   - do:
-      data_frame.stop_data_frame_transform:
+      transform.stop_transform:
         transform_id: "old-complex-transform"
         wait_for_completion: true
   - match: { acknowledged: true }
   - do:
-      data_frame.get_data_frame_transform_stats:
+      transform.get_transform_stats:
         transform_id: "old-complex-transform"
   - match: { count: 1 }
   - match: { transforms.0.id: "old-complex-transform" }
@@ -259,12 +259,12 @@
 "Test GET, stop, start, old continuous transforms":
   - do:
       cluster.health:
-        index: "dataframe-transform-airline-data-cont"
+        index: "transform-airline-data-cont"
         wait_for_status: green
         timeout: 70s
 
   - do:
-      data_frame.get_data_frame_transform:
+      transform.get_transform:
         transform_id: "old-simple-continuous-transform"
   - match: { count: 1 }
   - match: { transforms.0.id: "old-simple-continuous-transform" }
@@ -274,24 +274,24 @@
   - is_true: transforms.0.create_time
 
   - do:
-      data_frame.start_data_frame_transform:
+      transform.start_transform:
         transform_id: "old-simple-continuous-transform"
   - match: { acknowledged: true }
   - do:
-      data_frame.get_data_frame_transform_stats:
+      transform.get_transform_stats:
         transform_id: "old-simple-continuous-transform"
   - match: { count: 1 }
   - match: { transforms.0.id: "old-simple-continuous-transform" }
   - match: { transforms.0.state: "/started|indexing/" }
 
   - do:
-      data_frame.stop_data_frame_transform:
+      transform.stop_transform:
         transform_id: "old-simple-continuous-transform"
         wait_for_completion: true
   - match: { acknowledged: true }
 
   - do:
-      data_frame.get_data_frame_transform_stats:
+      transform.get_transform_stats:
         transform_id: "old-simple-continuous-transform"
   - match: { count: 1 }
   - match: { transforms.0.id: "old-simple-continuous-transform" }

x-pack/qa/rolling-upgrade/src/test/resources/rest-api-spec/test/old_cluster/80_data_frame_jobs_crud.yml

@@ -2,7 +2,7 @@
 "Test put batch data frame transforms on old cluster":
   - do:
       indices.create:
-        index: dataframe-transform-airline-data
+        index: transform-airline-data
         body:
           mappings:
             properties:
@@ -16,16 +16,16 @@
                 type: integer
   - do:
       cluster.health:
-        index: "dataframe-transform-airline-data"
+        index: "transform-airline-data"
         wait_for_status: green
         timeout: 70s
 
   - do:
-      data_frame.put_data_frame_transform:
+      transform.put_transform:
         transform_id: "old-simple-transform"
         body: >
           {
-            "source": { "index": "dataframe-transform-airline-data" },
+            "source": { "index": "transform-airline-data" },
             "dest": { "index": "old-simple-transform-idx" },
             "pivot": {
               "group_by": { "airline": {"terms": {"field": "airline"}}},
@@ -35,40 +35,40 @@
   - match: { acknowledged: true }
 
   - do:
-      data_frame.get_data_frame_transform:
+      transform.get_transform:
         transform_id: "old-simple-transform"
   - match: { count: 1 }
   - match: { transforms.0.id: "old-simple-transform" }
 
   - do:
-      data_frame.start_data_frame_transform:
+      transform.start_transform:
         transform_id: "old-simple-transform"
   - match: { acknowledged: true }
   - do:
-      data_frame.get_data_frame_transform_stats:
+      transform.get_transform_stats:
         transform_id: "old-simple-transform"
   - match: { count: 1 }
   - match: { transforms.0.id: "old-simple-transform" }
 
   - do:
-      data_frame.stop_data_frame_transform:
+      transform.stop_transform:
         transform_id: "old-simple-transform"
         wait_for_completion: true
   - match: { acknowledged: true }
 
   - do:
-      data_frame.get_data_frame_transform_stats:
+      transform.get_transform_stats:
         transform_id: "old-simple-transform"
   - match: { count: 1 }
   - match: { transforms.0.id: "old-simple-transform" }
 
   - do:
-      data_frame.put_data_frame_transform:
+      transform.put_transform:
         transform_id: "old-complex-transform"
         body: >
           {
             "source": {
-              "index": "dataframe-transform-airline-data",
+              "index": "transform-airline-data",
               "query": {
                 "bool": {
                   "filter": {"term": {"airline": "ElasticAir"}}
@@ -90,29 +90,29 @@
   - match: { acknowledged: true }
 
   - do:
-      data_frame.get_data_frame_transform:
+      transform.get_transform:
         transform_id: "old-complex-transform"
   - match: { count: 1 }
   - match: { transforms.0.id: "old-complex-transform" }
 
   - do:
-      data_frame.start_data_frame_transform:
+      transform.start_transform:
         transform_id: "old-complex-transform"
   - match: { acknowledged: true }
   - do:
-      data_frame.get_data_frame_transform_stats:
+      transform.get_transform_stats:
         transform_id: "old-complex-transform"
   - match: { count: 1 }
   - match: { transforms.0.id: "old-complex-transform" }
 
   - do:
-      data_frame.stop_data_frame_transform:
+      transform.stop_transform:
         transform_id: "old-complex-transform"
         wait_for_completion: true
   - match: { acknowledged: true }
 
   - do:
-      data_frame.get_data_frame_transform_stats:
+      transform.get_transform_stats:
         transform_id: "old-complex-transform"
   - match: { count: 1 }
   - match: { transforms.0.id: "old-complex-transform" }
@@ -121,7 +121,7 @@
 "Test put continuous data frame transform on old cluster":
   - do:
       indices.create:
-        index: dataframe-transform-airline-data-cont
+        index: transform-airline-data-cont
         body:
           mappings:
             properties:
@@ -135,16 +135,16 @@
                 type: integer
   - do:
       cluster.health:
-        index: "dataframe-transform-airline-data-cont"
+        index: "transform-airline-data-cont"
         wait_for_status: green
         timeout: 70s
 
   - do:
-      data_frame.put_data_frame_transform:
+      transform.put_transform:
         transform_id: "old-simple-continuous-transform"
         body: >
           {
-            "source": { "index": "dataframe-transform-airline-data-cont" },
+            "source": { "index": "transform-airline-data-cont" },
             "dest": { "index": "old-simple-continuous-transform-idx" },
             "pivot": {
               "group_by": { "airline": {"terms": {"field": "airline"}}},
@@ -160,7 +160,7 @@
   - match: { acknowledged: true }
 
   - do:
-      data_frame.get_data_frame_transform:
+      transform.get_transform:
         transform_id: "old-simple-continuous-transform"
   - match: { count: 1 }
   - match: { transforms.0.id: "old-simple-continuous-transform" }
@@ -170,23 +170,23 @@
   - is_true: transforms.0.create_time
 
   - do:
-      data_frame.start_data_frame_transform:
+      transform.start_transform:
         transform_id: "old-simple-continuous-transform"
   - match: { acknowledged: true }
   - do:
-      data_frame.get_data_frame_transform_stats:
+      transform.get_transform_stats:
         transform_id: "old-simple-continuous-transform"
   - match: { count: 1 }
   - match: { transforms.0.id: "old-simple-continuous-transform" }
 
   - do:
-      data_frame.stop_data_frame_transform:
+      transform.stop_transform:
         transform_id: "old-simple-continuous-transform"
         wait_for_completion: true
   - match: { acknowledged: true }
 
   - do:
-      data_frame.get_data_frame_transform_stats:
+      transform.get_transform_stats:
         transform_id: "old-simple-continuous-transform"
   - match: { count: 1 }
   - match: { transforms.0.id: "old-simple-continuous-transform" }

x-pack/qa/rolling-upgrade/src/test/resources/rest-api-spec/test/upgraded_cluster/80_data_frame_jobs_crud.yml

@@ -9,43 +9,43 @@ setup:
 "Get start, stop, and delete old and mixed cluster batch data frame transforms":
   # Simple and complex OLD transforms
   - do:
-      data_frame.get_data_frame_transform:
+      transform.get_transform:
         transform_id: "old-simple-transform"
   - match: { count: 1 }
   - match: { transforms.0.id: "old-simple-transform" }
-  - match: { transforms.0.source.index.0: "dataframe-transform-airline-data" }
+  - match: { transforms.0.source.index.0: "transform-airline-data" }
   - match: { transforms.0.dest.index: "old-simple-transform-idx" }
   - match: { transforms.0.pivot.group_by.airline.terms.field: "airline" }
   - match: { transforms.0.pivot.aggregations.avg_response.avg.field: "responsetime" }
 
   - do:
-      data_frame.start_data_frame_transform:
+      transform.start_transform:
         transform_id: "old-simple-transform"
   - match: { acknowledged: true }
   - do:
-      data_frame.get_data_frame_transform_stats:
+      transform.get_transform_stats:
         transform_id: "old-simple-transform"
   - match: { count: 1 }
   - match: { transforms.0.id: "old-simple-transform" }
   - match: { transforms.0.state: "/started|indexing|stopping|stopped/" }
 
   - do:
-      data_frame.stop_data_frame_transform:
+      transform.stop_transform:
         transform_id: "old-simple-transform"
         wait_for_completion: true
   - match: { acknowledged: true }
   - do:
-      data_frame.get_data_frame_transform_stats:
+      transform.get_transform_stats:
         transform_id: "old-simple-transform"
   - match: { count: 1 }
   - match: { transforms.0.id: "old-simple-transform" }
   - match: { transforms.0.state: "stopped" }
   - do:
-      data_frame.get_data_frame_transform:
+      transform.get_transform:
         transform_id: "old-complex-transform"
   - match: { count: 1 }
   - match: { transforms.0.id: "old-complex-transform" }
-  - match: { transforms.0.source.index.0: "dataframe-transform-airline-data" }
+  - match: { transforms.0.source.index.0: "transform-airline-data" }
   - match: { transforms.0.dest.index: "old-complex-transform-idx" }
   - match: { transforms.0.pivot.group_by.airline.terms.field: "airline" }
   - match: { transforms.0.pivot.group_by.day.date_histogram.field: "timestamp" }
@@ -53,23 +53,23 @@ setup:
   - match: { transforms.0.pivot.aggregations.avg_response.avg.field: "responsetime" }
 
   - do:
-      data_frame.start_data_frame_transform:
+      transform.start_transform:
         transform_id: "old-complex-transform"
   - match: { acknowledged: true }
   - do:
-      data_frame.get_data_frame_transform_stats:
+      transform.get_transform_stats:
         transform_id: "old-complex-transform"
   - match: { count: 1 }
   - match: { transforms.0.id: "old-complex-transform" }
   - match: { transforms.0.state: "/started|indexing|stopping|stopped/" }
 
   - do:
-      data_frame.stop_data_frame_transform:
+      transform.stop_transform:
         transform_id: "old-complex-transform"
         wait_for_completion: true
   - match: { acknowledged: true }
   - do:
-      data_frame.get_data_frame_transform_stats:
+      transform.get_transform_stats:
         transform_id: "old-complex-transform"
   - match: { count: 1 }
   - match: { transforms.0.id: "old-complex-transform" }
@@ -77,44 +77,44 @@ setup:
 
   # Simple and complex Mixed cluster transforms
   - do:
-      data_frame.get_data_frame_transform:
+      transform.get_transform:
         transform_id: "mixed-simple-transform"
   - match: { count: 1 }
   - match: { transforms.0.id: "mixed-simple-transform" }
-  - match: { transforms.0.source.index.0: "dataframe-transform-airline-data" }
+  - match: { transforms.0.source.index.0: "transform-airline-data" }
   - match: { transforms.0.dest.index: "mixed-simple-transform-idx" }
   - match: { transforms.0.pivot.group_by.airline.terms.field: "airline" }
   - match: { transforms.0.pivot.aggregations.avg_response.avg.field: "responsetime" }
 
   - do:
-      data_frame.start_data_frame_transform:
+      transform.start_transform:
         transform_id: "mixed-simple-transform"
   - match: { acknowledged: true }
   - do:
-      data_frame.get_data_frame_transform_stats:
+      transform.get_transform_stats:
         transform_id: "mixed-simple-transform"
   - match: { count: 1 }
   - match: { transforms.0.id: "mixed-simple-transform" }
   - match: { transforms.0.state: "/started|indexing|stopping|stopped/" }
 
   - do:
-      data_frame.stop_data_frame_transform:
+      transform.stop_transform:
         transform_id: "mixed-simple-transform"
         wait_for_completion: true
   - match: { acknowledged: true }
   - do:
-      data_frame.get_data_frame_transform_stats:
+      transform.get_transform_stats:
         transform_id: "mixed-simple-transform"
   - match: { count: 1 }
   - match: { transforms.0.id: "mixed-simple-transform" }
   - match: { transforms.0.state: "stopped" }
 
   - do:
-      data_frame.get_data_frame_transform:
+      transform.get_transform:
         transform_id: "mixed-complex-transform"
   - match: { count: 1 }
   - match: { transforms.0.id: "mixed-complex-transform" }
-  - match: { transforms.0.source.index.0: "dataframe-transform-airline-data" }
+  - match: { transforms.0.source.index.0: "transform-airline-data" }
   - match: { transforms.0.dest.index: "mixed-complex-transform-idx" }
   - match: { transforms.0.pivot.group_by.airline.terms.field: "airline" }
   - match: { transforms.0.pivot.group_by.day.date_histogram.field: "timestamp" }
@@ -122,23 +122,23 @@ setup:
   - match: { transforms.0.pivot.aggregations.avg_response.avg.field: "responsetime" }
 
   - do:
-      data_frame.start_data_frame_transform:
+      transform.start_transform:
         transform_id: "mixed-complex-transform"
   - match: { acknowledged: true }
   - do:
-      data_frame.get_data_frame_transform_stats:
+      transform.get_transform_stats:
         transform_id: "mixed-complex-transform"
   - match: { count: 1 }
   - match: { transforms.0.id: "mixed-complex-transform" }
   - match: { transforms.0.state: "/started|indexing|stopping|stopped/" }
 
   - do:
-      data_frame.stop_data_frame_transform:
+      transform.stop_transform:
         transform_id: "mixed-complex-transform"
         wait_for_completion: true
   - match: { acknowledged: true }
   - do:
-      data_frame.get_data_frame_transform_stats:
+      transform.get_transform_stats:
         transform_id: "mixed-complex-transform"
   - match: { count: 1 }
   - match: { transforms.0.id: "mixed-complex-transform" }
@@ -146,22 +146,22 @@ setup:
 
 # Delete all old and mixed transforms
   - do:
-      data_frame.delete_data_frame_transform:
+      transform.delete_transform:
         transform_id: "old-simple-transform"
 
   - do:
-      data_frame.delete_data_frame_transform:
+      transform.delete_transform:
         transform_id: "mixed-simple-transform"
 
   - do:
-      data_frame.get_data_frame_transform_stats:
+      transform.get_transform_stats:
         transform_id: "old-simple-transform,mixed-simple-transform"
   - match: { count: 0 }
 
 ---
 "Test GET, stop, delete, old and mixed continuous transforms":
   - do:
-      data_frame.get_data_frame_transform:
+      transform.get_transform:
         transform_id: "old-simple-continuous-transform"
   - match: { count: 1 }
   - match: { transforms.0.id: "old-simple-continuous-transform" }
@@ -171,42 +171,42 @@ setup:
   - is_true: transforms.0.create_time
 
   - do:
-      data_frame.start_data_frame_transform:
+      transform.start_transform:
         transform_id: "old-simple-continuous-transform"
   - match: { acknowledged: true }
   - do:
-      data_frame.get_data_frame_transform_stats:
+      transform.get_transform_stats:
         transform_id: "old-simple-continuous-transform"
   - match: { count: 1 }
   - match: { transforms.0.id: "old-simple-continuous-transform" }
   - match: { transforms.0.state: "/started|indexing/" }
 
   - do:
-      data_frame.get_data_frame_transform_stats:
+      transform.get_transform_stats:
         transform_id: "old-simple-continuous-transform"
   - match: { count: 1 }
   - match: { transforms.0.id: "old-simple-continuous-transform" }
   - match: { transforms.0.state: "/started|indexing/" }
 
   - do:
-      data_frame.stop_data_frame_transform:
+      transform.stop_transform:
         transform_id: "old-simple-continuous-transform"
         wait_for_completion: true
   - match: { acknowledged: true }
 
   - do:
-      data_frame.get_data_frame_transform_stats:
+      transform.get_transform_stats:
         transform_id: "old-simple-continuous-transform"
   - match: { count: 1 }
   - match: { transforms.0.id: "old-simple-continuous-transform" }
   - match: { transforms.0.state: "stopped" }
 
   - do:
-      data_frame.delete_data_frame_transform:
+      transform.delete_transform:
         transform_id: "old-simple-continuous-transform"
 
   - do:
-      data_frame.get_data_frame_transform:
+      transform.get_transform:
         transform_id: "mixed-simple-continuous-transform"
   - match: { count: 1 }
   - match: { transforms.0.id: "mixed-simple-continuous-transform" }
@@ -216,48 +216,48 @@ setup:
   - is_true: transforms.0.create_time
 
   - do:
-      data_frame.start_data_frame_transform:
+      transform.start_transform:
         transform_id: "mixed-simple-continuous-transform"
   - match: { acknowledged: true }
   - do:
-      data_frame.get_data_frame_transform_stats:
+      transform.get_transform_stats:
         transform_id: "mixed-simple-continuous-transform"
   - match: { count: 1 }
   - match: { transforms.0.id: "mixed-simple-continuous-transform" }
   - match: { transforms.0.state: "/started|indexing/" }
 
   - do:
-      data_frame.get_data_frame_transform_stats:
+      transform.get_transform_stats:
         transform_id: "mixed-simple-continuous-transform"
   - match: { count: 1 }
   - match: { transforms.0.id: "mixed-simple-continuous-transform" }
   - match: { transforms.0.state: "/started|indexing/" }
 
   - do:
-      data_frame.stop_data_frame_transform:
+      transform.stop_transform:
         transform_id: "mixed-simple-continuous-transform"
         wait_for_completion: true
   - match: { acknowledged: true }
 
   - do:
-      data_frame.get_data_frame_transform_stats:
+      transform.get_transform_stats:
         transform_id: "mixed-simple-continuous-transform"
   - match: { count: 1 }
   - match: { transforms.0.id: "mixed-simple-continuous-transform" }
   - match: { transforms.0.state: "stopped" }
 
   - do:
-      data_frame.delete_data_frame_transform:
+      transform.delete_transform:
         transform_id: "mixed-simple-continuous-transform"
 ---
 "Test index mappings for latest internal index":
   - do:
-      data_frame.put_data_frame_transform:
+      transform.put_transform:
         transform_id: "upgraded-simple-transform"
         defer_validation: true
         body: >
           {
-            "source": { "index": "dataframe-transform-airline-data" },
+            "source": { "index": "transform-airline-data" },
             "dest": { "index": "upgraded-simple-transform-idx" },
             "pivot": {
               "group_by": { "airline": {"terms": {"field": "airline"}}},