diff --git a/client/rest-high-level/src/main/java/org/elasticsearch/client/IndexLifecycleClient.java b/client/rest-high-level/src/main/java/org/elasticsearch/client/IndexLifecycleClient.java
index 224c6b2caf434..60a95e510a998 100644
--- a/client/rest-high-level/src/main/java/org/elasticsearch/client/IndexLifecycleClient.java
+++ b/client/rest-high-level/src/main/java/org/elasticsearch/client/IndexLifecycleClient.java
@@ -34,6 +34,12 @@
 import org.elasticsearch.client.indexlifecycle.RetryLifecyclePolicyRequest;
 import org.elasticsearch.client.indexlifecycle.StartILMRequest;
 import org.elasticsearch.client.indexlifecycle.StopILMRequest;
+import org.elasticsearch.client.snapshotlifecycle.DeleteSnapshotLifecyclePolicyRequest;
+import org.elasticsearch.client.snapshotlifecycle.ExecuteSnapshotLifecyclePolicyRequest;
+import org.elasticsearch.client.snapshotlifecycle.ExecuteSnapshotLifecyclePolicyResponse;
+import org.elasticsearch.client.snapshotlifecycle.GetSnapshotLifecyclePolicyRequest;
+import org.elasticsearch.client.snapshotlifecycle.GetSnapshotLifecyclePolicyResponse;
+import org.elasticsearch.client.snapshotlifecycle.PutSnapshotLifecyclePolicyRequest;
 
 import java.io.IOException;
 
@@ -300,4 +306,144 @@ public void retryLifecyclePolicyAsync(RetryLifecyclePolicyRequest request, Reque
         restHighLevelClient.performRequestAsyncAndParseEntity(request, IndexLifecycleRequestConverters::retryLifecycle, options,
             AcknowledgedResponse::fromXContent, listener, emptySet());
     }
+
+    /**
+     * Retrieve one or more snapshot lifecycle policy definitions.
+     * See <pre>
+     *  https://www.elastic.co/guide/en/elasticsearch/client/java-rest/current/
+     *  java-rest-high-ilm-slm-get-snapshot-lifecycle-policy.html
+     * </pre>
+     * for more.
+     * @param request the request
+     * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
+     * @return the response
+     * @throws IOException in case there is a problem sending the request or parsing back the response
+     */
+    public GetSnapshotLifecyclePolicyResponse getSnapshotLifecyclePolicy(GetSnapshotLifecyclePolicyRequest request,
+                                                                         RequestOptions options) throws IOException {
+        return restHighLevelClient.performRequestAndParseEntity(request, IndexLifecycleRequestConverters::getSnapshotLifecyclePolicy,
+            options, GetSnapshotLifecyclePolicyResponse::fromXContent, emptySet());
+    }
+
+    /**
+     * Asynchronously retrieve one or more snapshot lifecycle policy definition.
+     * See <pre>
+     *  https://www.elastic.co/guide/en/elasticsearch/client/java-rest/current/
+     *  java-rest-high-ilm-slm-get-snapshot-lifecycle-policy.html
+     * </pre>
+     * for more.
+     * @param request the request
+     * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
+     * @param listener the listener to be notified upon request completion
+     */
+    public void getSnapshotLifecyclePolicyAsync(GetSnapshotLifecyclePolicyRequest request, RequestOptions options,
+                                                ActionListener<GetSnapshotLifecyclePolicyResponse> listener) {
+        restHighLevelClient.performRequestAsyncAndParseEntity(request, IndexLifecycleRequestConverters::getSnapshotLifecyclePolicy,
+            options, GetSnapshotLifecyclePolicyResponse::fromXContent, listener, emptySet());
+    }
+
+    /**
+     * Create or modify a snapshot lifecycle definition.
+     * See <pre>
+     *  https://www.elastic.co/guide/en/elasticsearch/client/java-rest/current/
+     *  java-rest-high-ilm-slm-put-snapshot-lifecycle-policy.html
+     * </pre>
+     * for more.
+     * @param request the request
+     * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
+     * @return the response
+     * @throws IOException in case there is a problem sending the request or parsing back the response
+     */
+    public AcknowledgedResponse putSnapshotLifecyclePolicy(PutSnapshotLifecyclePolicyRequest request,
+                                                           RequestOptions options) throws IOException {
+        return restHighLevelClient.performRequestAndParseEntity(request, IndexLifecycleRequestConverters::putSnapshotLifecyclePolicy,
+            options, AcknowledgedResponse::fromXContent, emptySet());
+    }
+
+    /**
+     * Asynchronously create or modify a snapshot lifecycle definition.
+     * See <pre>
+     *  https://www.elastic.co/guide/en/elasticsearch/client/java-rest/current/
+     *  java-rest-high-ilm-slm-put-snapshot-lifecycle-policy.html
+     * </pre>
+     * for more.
+     * @param request the request
+     * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
+     * @param listener the listener to be notified upon request completion
+     */
+    public void putSnapshotLifecyclePolicyAsync(PutSnapshotLifecyclePolicyRequest request, RequestOptions options,
+                                                ActionListener<AcknowledgedResponse> listener) {
+        restHighLevelClient.performRequestAsyncAndParseEntity(request, IndexLifecycleRequestConverters::putSnapshotLifecyclePolicy,
+            options, AcknowledgedResponse::fromXContent, listener, emptySet());
+    }
+
+    /**
+     * Delete a snapshot lifecycle definition
+     * See <pre>
+     *  https://www.elastic.co/guide/en/elasticsearch/client/java-rest/current/
+     *  java-rest-high-ilm-slm-delete-snapshot-lifecycle-policy.html
+     * </pre>
+     * for more.
+     * @param request the request
+     * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
+     * @return the response
+     * @throws IOException in case there is a problem sending the request or parsing back the response
+     */
+    public AcknowledgedResponse deleteSnapshotLifecyclePolicy(DeleteSnapshotLifecyclePolicyRequest request,
+                                                              RequestOptions options) throws IOException {
+        return restHighLevelClient.performRequestAndParseEntity(request, IndexLifecycleRequestConverters::deleteSnapshotLifecyclePolicy,
+            options, AcknowledgedResponse::fromXContent, emptySet());
+    }
+
+    /**
+     * Asynchronously delete a snapshot lifecycle definition
+     * See <pre>
+     *  https://www.elastic.co/guide/en/elasticsearch/client/java-rest/current/
+     *  java-rest-high-ilm-slm-delete-snapshot-lifecycle-policy.html
+     * </pre>
+     * for more.
+     * @param request the request
+     * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
+     * @param listener the listener to be notified upon request completion
+     */
+    public void deleteSnapshotLifecyclePolicyAsync(DeleteSnapshotLifecyclePolicyRequest request, RequestOptions options,
+                                                   ActionListener<AcknowledgedResponse> listener) {
+        restHighLevelClient.performRequestAsyncAndParseEntity(request, IndexLifecycleRequestConverters::deleteSnapshotLifecyclePolicy,
+            options, AcknowledgedResponse::fromXContent, listener, emptySet());
+    }
+
+    /**
+     * Execute a snapshot lifecycle definition
+     * See <pre>
+     *  https://www.elastic.co/guide/en/elasticsearch/client/java-rest/current/
+     *  java-rest-high-ilm-slm-execute-snapshot-lifecycle-policy.html
+     * </pre>
+     * for more.
+     * @param request the request
+     * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
+     * @return the response
+     * @throws IOException in case there is a problem sending the request or parsing back the response
+     */
+    public ExecuteSnapshotLifecyclePolicyResponse executeSnapshotLifecyclePolicy(ExecuteSnapshotLifecyclePolicyRequest request,
+                                                                                 RequestOptions options) throws IOException {
+        return restHighLevelClient.performRequestAndParseEntity(request, IndexLifecycleRequestConverters::executeSnapshotLifecyclePolicy,
+            options, ExecuteSnapshotLifecyclePolicyResponse::fromXContent, emptySet());
+    }
+
+    /**
+     * Asynchronously execute a snapshot lifecycle definition
+     * See <pre>
+     *  https://www.elastic.co/guide/en/elasticsearch/client/java-rest/current/
+     *  java-rest-high-ilm-slm-execute-snapshot-lifecycle-policy.html
+     * </pre>
+     * for more.
+     * @param request the request
+     * @param options the request options (e.g. headers), use {@link RequestOptions#DEFAULT} if nothing needs to be customized
+     * @param listener the listener to be notified upon request completion
+     */
+    public void executeSnapshotLifecyclePolicyAsync(ExecuteSnapshotLifecyclePolicyRequest request, RequestOptions options,
+                                                    ActionListener<ExecuteSnapshotLifecyclePolicyResponse> listener) {
+        restHighLevelClient.performRequestAsyncAndParseEntity(request, IndexLifecycleRequestConverters::executeSnapshotLifecyclePolicy,
+            options, ExecuteSnapshotLifecyclePolicyResponse::fromXContent, listener, emptySet());
+    }
 }
diff --git a/client/rest-high-level/src/main/java/org/elasticsearch/client/IndexLifecycleRequestConverters.java b/client/rest-high-level/src/main/java/org/elasticsearch/client/IndexLifecycleRequestConverters.java
index ff6d8a90cdb2d..2d8560742d532 100644
--- a/client/rest-high-level/src/main/java/org/elasticsearch/client/IndexLifecycleRequestConverters.java
+++ b/client/rest-high-level/src/main/java/org/elasticsearch/client/IndexLifecycleRequestConverters.java
@@ -32,6 +32,10 @@
 import org.elasticsearch.client.indexlifecycle.RetryLifecyclePolicyRequest;
 import org.elasticsearch.client.indexlifecycle.StartILMRequest;
 import org.elasticsearch.client.indexlifecycle.StopILMRequest;
+import org.elasticsearch.client.snapshotlifecycle.DeleteSnapshotLifecyclePolicyRequest;
+import org.elasticsearch.client.snapshotlifecycle.ExecuteSnapshotLifecyclePolicyRequest;
+import org.elasticsearch.client.snapshotlifecycle.GetSnapshotLifecyclePolicyRequest;
+import org.elasticsearch.client.snapshotlifecycle.PutSnapshotLifecyclePolicyRequest;
 import org.elasticsearch.common.Strings;
 
 import java.io.IOException;
@@ -150,4 +154,52 @@ static Request retryLifecycle(RetryLifecyclePolicyRequest retryLifecyclePolicyRe
         params.withTimeout(retryLifecyclePolicyRequest.timeout());
         return request;
     }
+
+    static Request getSnapshotLifecyclePolicy(GetSnapshotLifecyclePolicyRequest getSnapshotLifecyclePolicyRequest) {
+        String endpoint = new RequestConverters.EndpointBuilder().addPathPartAsIs("_slm/policy")
+            .addCommaSeparatedPathParts(getSnapshotLifecyclePolicyRequest.getPolicyIds()).build();
+        Request request = new Request(HttpGet.METHOD_NAME, endpoint);
+        RequestConverters.Params params = new RequestConverters.Params(request);
+        params.withMasterTimeout(getSnapshotLifecyclePolicyRequest.masterNodeTimeout());
+        params.withTimeout(getSnapshotLifecyclePolicyRequest.timeout());
+        return request;
+    }
+
+    static Request putSnapshotLifecyclePolicy(PutSnapshotLifecyclePolicyRequest putSnapshotLifecyclePolicyRequest) throws IOException {
+        String endpoint = new RequestConverters.EndpointBuilder()
+            .addPathPartAsIs("_slm/policy")
+            .addPathPartAsIs(putSnapshotLifecyclePolicyRequest.getPolicy().getId())
+            .build();
+        Request request = new Request(HttpPut.METHOD_NAME, endpoint);
+        RequestConverters.Params params = new RequestConverters.Params(request);
+        params.withMasterTimeout(putSnapshotLifecyclePolicyRequest.masterNodeTimeout());
+        params.withTimeout(putSnapshotLifecyclePolicyRequest.timeout());
+        request.setEntity(RequestConverters.createEntity(putSnapshotLifecyclePolicyRequest, RequestConverters.REQUEST_BODY_CONTENT_TYPE));
+        return request;
+    }
+
+    static Request deleteSnapshotLifecyclePolicy(DeleteSnapshotLifecyclePolicyRequest deleteSnapshotLifecyclePolicyRequest) {
+        Request request = new Request(HttpDelete.METHOD_NAME,
+            new RequestConverters.EndpointBuilder()
+                .addPathPartAsIs("_slm/policy")
+                .addPathPartAsIs(deleteSnapshotLifecyclePolicyRequest.getPolicyId())
+                .build());
+        RequestConverters.Params params = new RequestConverters.Params(request);
+        params.withMasterTimeout(deleteSnapshotLifecyclePolicyRequest.masterNodeTimeout());
+        params.withTimeout(deleteSnapshotLifecyclePolicyRequest.timeout());
+        return request;
+    }
+
+    static Request executeSnapshotLifecyclePolicy(ExecuteSnapshotLifecyclePolicyRequest executeSnapshotLifecyclePolicyRequest) {
+        Request request = new Request(HttpPut.METHOD_NAME,
+            new RequestConverters.EndpointBuilder()
+                .addPathPartAsIs("_slm/policy")
+                .addPathPartAsIs(executeSnapshotLifecyclePolicyRequest.getPolicyId())
+                .addPathPartAsIs("_execute")
+                .build());
+        RequestConverters.Params params = new RequestConverters.Params(request);
+        params.withMasterTimeout(executeSnapshotLifecyclePolicyRequest.masterNodeTimeout());
+        params.withTimeout(executeSnapshotLifecyclePolicyRequest.timeout());
+        return request;
+    }
 }
diff --git a/client/rest-high-level/src/main/java/org/elasticsearch/client/snapshotlifecycle/DeleteSnapshotLifecyclePolicyRequest.java b/client/rest-high-level/src/main/java/org/elasticsearch/client/snapshotlifecycle/DeleteSnapshotLifecyclePolicyRequest.java
new file mode 100644
index 0000000000000..712151def4a50
--- /dev/null
+++ b/client/rest-high-level/src/main/java/org/elasticsearch/client/snapshotlifecycle/DeleteSnapshotLifecyclePolicyRequest.java
@@ -0,0 +1,49 @@
+/*
+ * Licensed to Elasticsearch under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.elasticsearch.client.snapshotlifecycle;
+
+import org.elasticsearch.client.TimedRequest;
+
+import java.util.Objects;
+
+public class DeleteSnapshotLifecyclePolicyRequest extends TimedRequest {
+    private final String policyId;
+
+    public DeleteSnapshotLifecyclePolicyRequest(String policyId) {
+        this.policyId = policyId;
+    }
+
+    public String getPolicyId() {
+        return this.policyId;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        DeleteSnapshotLifecyclePolicyRequest other = (DeleteSnapshotLifecyclePolicyRequest) o;
+        return this.policyId.equals(other.policyId);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(this.policyId);
+    }
+}
diff --git a/client/rest-high-level/src/main/java/org/elasticsearch/client/snapshotlifecycle/ExecuteSnapshotLifecyclePolicyRequest.java b/client/rest-high-level/src/main/java/org/elasticsearch/client/snapshotlifecycle/ExecuteSnapshotLifecyclePolicyRequest.java
new file mode 100644
index 0000000000000..3c32de6837405
--- /dev/null
+++ b/client/rest-high-level/src/main/java/org/elasticsearch/client/snapshotlifecycle/ExecuteSnapshotLifecyclePolicyRequest.java
@@ -0,0 +1,49 @@
+/*
+ * Licensed to Elasticsearch under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.elasticsearch.client.snapshotlifecycle;
+
+import org.elasticsearch.client.TimedRequest;
+
+import java.util.Objects;
+
+public class ExecuteSnapshotLifecyclePolicyRequest extends TimedRequest {
+    private final String policyId;
+
+    public ExecuteSnapshotLifecyclePolicyRequest(String policyId) {
+        this.policyId = policyId;
+    }
+
+    public String getPolicyId() {
+        return this.policyId;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        ExecuteSnapshotLifecyclePolicyRequest other = (ExecuteSnapshotLifecyclePolicyRequest) o;
+        return this.policyId.equals(other.policyId);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(this.policyId);
+    }
+}
diff --git a/client/rest-high-level/src/main/java/org/elasticsearch/client/snapshotlifecycle/ExecuteSnapshotLifecyclePolicyResponse.java b/client/rest-high-level/src/main/java/org/elasticsearch/client/snapshotlifecycle/ExecuteSnapshotLifecyclePolicyResponse.java
new file mode 100644
index 0000000000000..b5698d715625b
--- /dev/null
+++ b/client/rest-high-level/src/main/java/org/elasticsearch/client/snapshotlifecycle/ExecuteSnapshotLifecyclePolicyResponse.java
@@ -0,0 +1,81 @@
+/*
+ * Licensed to Elasticsearch under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.elasticsearch.client.snapshotlifecycle;
+
+import org.elasticsearch.common.ParseField;
+import org.elasticsearch.common.xcontent.ConstructingObjectParser;
+import org.elasticsearch.common.xcontent.ToXContentObject;
+import org.elasticsearch.common.xcontent.XContentBuilder;
+import org.elasticsearch.common.xcontent.XContentParser;
+
+import java.io.IOException;
+
+public class ExecuteSnapshotLifecyclePolicyResponse implements ToXContentObject {
+
+    private static final ParseField SNAPSHOT_NAME = new ParseField("snapshot_name");
+    private static final ConstructingObjectParser<ExecuteSnapshotLifecyclePolicyResponse, Void> PARSER =
+        new ConstructingObjectParser<>("excecute_snapshot_policy", true,
+            a -> new ExecuteSnapshotLifecyclePolicyResponse((String) a[0]));
+
+    static {
+        PARSER.declareString(ConstructingObjectParser.constructorArg(), SNAPSHOT_NAME);
+    }
+
+    private final String snapshotName;
+
+    public ExecuteSnapshotLifecyclePolicyResponse(String snapshotName) {
+        this.snapshotName = snapshotName;
+    }
+
+    public static ExecuteSnapshotLifecyclePolicyResponse fromXContent(XContentParser parser) {
+        return PARSER.apply(parser, null);
+    }
+
+    public String getSnapshotName() {
+        return this.snapshotName;
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject();
+        builder.field(SNAPSHOT_NAME.getPreferredName(), snapshotName);
+        builder.endObject();
+        return builder;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+
+        ExecuteSnapshotLifecyclePolicyResponse other = (ExecuteSnapshotLifecyclePolicyResponse) o;
+        return this.snapshotName.equals(other.snapshotName);
+    }
+
+    @Override
+    public int hashCode() {
+        return this.snapshotName.hashCode();
+    }
+}
diff --git a/client/rest-high-level/src/main/java/org/elasticsearch/client/snapshotlifecycle/GetSnapshotLifecyclePolicyRequest.java b/client/rest-high-level/src/main/java/org/elasticsearch/client/snapshotlifecycle/GetSnapshotLifecyclePolicyRequest.java
new file mode 100644
index 0000000000000..c754cc8878d29
--- /dev/null
+++ b/client/rest-high-level/src/main/java/org/elasticsearch/client/snapshotlifecycle/GetSnapshotLifecyclePolicyRequest.java
@@ -0,0 +1,49 @@
+/*
+ * Licensed to Elasticsearch under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.elasticsearch.client.snapshotlifecycle;
+
+import org.elasticsearch.client.TimedRequest;
+
+import java.util.Arrays;
+
+public class GetSnapshotLifecyclePolicyRequest extends TimedRequest {
+    private final String[] policyIds;
+
+    public GetSnapshotLifecyclePolicyRequest(String... ids) {
+        this.policyIds = ids;
+    }
+
+    public String[] getPolicyIds() {
+        return this.policyIds;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        GetSnapshotLifecyclePolicyRequest other = (GetSnapshotLifecyclePolicyRequest) o;
+        return Arrays.equals(this.policyIds, other.policyIds);
+    }
+
+    @Override
+    public int hashCode() {
+        return Arrays.hashCode(this.policyIds);
+    }
+}
diff --git a/client/rest-high-level/src/main/java/org/elasticsearch/client/snapshotlifecycle/GetSnapshotLifecyclePolicyResponse.java b/client/rest-high-level/src/main/java/org/elasticsearch/client/snapshotlifecycle/GetSnapshotLifecyclePolicyResponse.java
new file mode 100644
index 0000000000000..68700bbb34bc4
--- /dev/null
+++ b/client/rest-high-level/src/main/java/org/elasticsearch/client/snapshotlifecycle/GetSnapshotLifecyclePolicyResponse.java
@@ -0,0 +1,88 @@
+/*
+ * Licensed to Elasticsearch under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.elasticsearch.client.snapshotlifecycle;
+
+import org.elasticsearch.common.xcontent.ToXContentObject;
+import org.elasticsearch.common.xcontent.XContentBuilder;
+import org.elasticsearch.common.xcontent.XContentParser;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+
+import static org.elasticsearch.common.xcontent.XContentParserUtils.ensureExpectedToken;
+
+public class GetSnapshotLifecyclePolicyResponse implements ToXContentObject {
+
+    private final Map<String, SnapshotLifecyclePolicyMetadata> policies;
+
+    public GetSnapshotLifecyclePolicyResponse(Map<String, SnapshotLifecyclePolicyMetadata> policies) {
+        this.policies = policies;
+    }
+
+    public Map<String, SnapshotLifecyclePolicyMetadata> getPolicies() {
+        return this.policies;
+    }
+
+    public static GetSnapshotLifecyclePolicyResponse fromXContent(XContentParser parser) throws IOException {
+        if (parser.currentToken() == null) {
+            parser.nextToken();
+        }
+        ensureExpectedToken(XContentParser.Token.START_OBJECT, parser.currentToken(), parser::getTokenLocation);
+        parser.nextToken();
+
+        Map<String, SnapshotLifecyclePolicyMetadata> policies = new HashMap<>();
+        while (parser.isClosed() == false) {
+            if (parser.currentToken() == XContentParser.Token.START_OBJECT) {
+                final String policyId = parser.currentName();
+                SnapshotLifecyclePolicyMetadata policyDefinition = SnapshotLifecyclePolicyMetadata.parse(parser, policyId);
+                policies.put(policyId, policyDefinition);
+            } else {
+                parser.nextToken();
+            }
+        }
+        return new GetSnapshotLifecyclePolicyResponse(policies);
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        return builder;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+
+        GetSnapshotLifecyclePolicyResponse other = (GetSnapshotLifecyclePolicyResponse) o;
+        return Objects.equals(this.policies, other.policies);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(this.policies);
+    }
+}
diff --git a/client/rest-high-level/src/main/java/org/elasticsearch/client/snapshotlifecycle/PutSnapshotLifecyclePolicyRequest.java b/client/rest-high-level/src/main/java/org/elasticsearch/client/snapshotlifecycle/PutSnapshotLifecyclePolicyRequest.java
new file mode 100644
index 0000000000000..7fb5794aee869
--- /dev/null
+++ b/client/rest-high-level/src/main/java/org/elasticsearch/client/snapshotlifecycle/PutSnapshotLifecyclePolicyRequest.java
@@ -0,0 +1,59 @@
+/*
+ * Licensed to Elasticsearch under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.elasticsearch.client.snapshotlifecycle;
+
+import org.elasticsearch.client.TimedRequest;
+import org.elasticsearch.common.xcontent.ToXContentObject;
+import org.elasticsearch.common.xcontent.XContentBuilder;
+
+import java.io.IOException;
+import java.util.Objects;
+
+public class PutSnapshotLifecyclePolicyRequest extends TimedRequest implements ToXContentObject {
+
+    private final SnapshotLifecyclePolicy policy;
+
+    public PutSnapshotLifecyclePolicyRequest(SnapshotLifecyclePolicy policy) {
+        this.policy = Objects.requireNonNull(policy, "policy definition cannot be null");
+    }
+
+    public SnapshotLifecyclePolicy getPolicy() {
+        return policy;
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        policy.toXContent(builder, params);
+        return builder;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        PutSnapshotLifecyclePolicyRequest other = (PutSnapshotLifecyclePolicyRequest) o;
+        return Objects.equals(this.policy, other.policy);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(this.policy);
+    }
+}
diff --git a/client/rest-high-level/src/main/java/org/elasticsearch/client/snapshotlifecycle/SnapshotInvocationRecord.java b/client/rest-high-level/src/main/java/org/elasticsearch/client/snapshotlifecycle/SnapshotInvocationRecord.java
new file mode 100644
index 0000000000000..ce5a7803c14e6
--- /dev/null
+++ b/client/rest-high-level/src/main/java/org/elasticsearch/client/snapshotlifecycle/SnapshotInvocationRecord.java
@@ -0,0 +1,100 @@
+/*
+ * Licensed to Elasticsearch under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.elasticsearch.client.snapshotlifecycle;
+
+import org.elasticsearch.common.ParseField;
+import org.elasticsearch.common.xcontent.ConstructingObjectParser;
+import org.elasticsearch.common.xcontent.ToXContentObject;
+import org.elasticsearch.common.xcontent.XContentBuilder;
+import org.elasticsearch.common.xcontent.XContentParser;
+
+import java.io.IOException;
+import java.util.Objects;
+
+public class SnapshotInvocationRecord implements ToXContentObject {
+    static final ParseField SNAPSHOT_NAME = new ParseField("snapshot_name");
+    static final ParseField TIMESTAMP = new ParseField("time");
+    static final ParseField DETAILS = new ParseField("details");
+
+    private String snapshotName;
+    private long timestamp;
+    private String details;
+
+    public static final ConstructingObjectParser<SnapshotInvocationRecord, String> PARSER =
+        new ConstructingObjectParser<>("snapshot_policy_invocation_record", true,
+            a -> new SnapshotInvocationRecord((String) a[0], (long) a[1], (String) a[2]));
+
+    static {
+        PARSER.declareString(ConstructingObjectParser.constructorArg(), SNAPSHOT_NAME);
+        PARSER.declareLong(ConstructingObjectParser.constructorArg(), TIMESTAMP);
+        PARSER.declareString(ConstructingObjectParser.optionalConstructorArg(), DETAILS);
+    }
+
+    public static SnapshotInvocationRecord parse(XContentParser parser, String name) {
+        return PARSER.apply(parser, name);
+    }
+
+    public SnapshotInvocationRecord(String snapshotName, long timestamp, String details) {
+        this.snapshotName = Objects.requireNonNull(snapshotName, "snapshot name must be provided");
+        this.timestamp = timestamp;
+        this.details = details;
+    }
+
+    public String getSnapshotName() {
+        return snapshotName;
+    }
+
+    public long getTimestamp() {
+        return timestamp;
+    }
+
+    public String getDetails() {
+        return details;
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject();
+        {
+            builder.field(SNAPSHOT_NAME.getPreferredName(), snapshotName);
+            builder.timeField(TIMESTAMP.getPreferredName(), "time_string", timestamp);
+            if (Objects.nonNull(details)) {
+                builder.field(DETAILS.getPreferredName(), details);
+            }
+        }
+        builder.endObject();
+        return builder;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        SnapshotInvocationRecord that = (SnapshotInvocationRecord) o;
+        return getTimestamp() == that.getTimestamp() &&
+            Objects.equals(getSnapshotName(), that.getSnapshotName()) &&
+            Objects.equals(getDetails(), that.getDetails());
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(getSnapshotName(), getTimestamp(), getDetails());
+    }
+}
diff --git a/client/rest-high-level/src/main/java/org/elasticsearch/client/snapshotlifecycle/SnapshotLifecyclePolicy.java b/client/rest-high-level/src/main/java/org/elasticsearch/client/snapshotlifecycle/SnapshotLifecyclePolicy.java
new file mode 100644
index 0000000000000..8d8e78184ff59
--- /dev/null
+++ b/client/rest-high-level/src/main/java/org/elasticsearch/client/snapshotlifecycle/SnapshotLifecyclePolicy.java
@@ -0,0 +1,137 @@
+/*
+ * Licensed to Elasticsearch under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.elasticsearch.client.snapshotlifecycle;
+
+import org.elasticsearch.cluster.metadata.IndexNameExpressionResolver;
+import org.elasticsearch.common.ParseField;
+import org.elasticsearch.common.Strings;
+import org.elasticsearch.common.xcontent.ConstructingObjectParser;
+import org.elasticsearch.common.xcontent.ToXContentObject;
+import org.elasticsearch.common.xcontent.XContentBuilder;
+import org.elasticsearch.common.xcontent.XContentParser;
+
+import java.io.IOException;
+import java.util.Map;
+import java.util.Objects;
+
+public class SnapshotLifecyclePolicy implements ToXContentObject {
+
+    private final String id;
+    private final String name;
+    private final String schedule;
+    private final String repository;
+    private final Map<String, Object> configuration;
+
+    private static final ParseField NAME = new ParseField("name");
+    private static final ParseField SCHEDULE = new ParseField("schedule");
+    private static final ParseField REPOSITORY = new ParseField("repository");
+    private static final ParseField CONFIG = new ParseField("config");
+    private static final IndexNameExpressionResolver.DateMathExpressionResolver DATE_MATH_RESOLVER =
+        new IndexNameExpressionResolver.DateMathExpressionResolver();
+
+    @SuppressWarnings("unchecked")
+    private static final ConstructingObjectParser<SnapshotLifecyclePolicy, String> PARSER =
+        new ConstructingObjectParser<>("snapshot_lifecycle", true,
+            (a, id) -> {
+                String name = (String) a[0];
+                String schedule = (String) a[1];
+                String repo = (String) a[2];
+                Map<String, Object> config = (Map<String, Object>) a[3];
+                return new SnapshotLifecyclePolicy(id, name, schedule, repo, config);
+            });
+
+    static {
+        PARSER.declareString(ConstructingObjectParser.constructorArg(), NAME);
+        PARSER.declareString(ConstructingObjectParser.constructorArg(), SCHEDULE);
+        PARSER.declareString(ConstructingObjectParser.constructorArg(), REPOSITORY);
+        PARSER.declareObject(ConstructingObjectParser.constructorArg(), (p, c) -> p.map(), CONFIG);
+    }
+
+    public SnapshotLifecyclePolicy(final String id, final String name, final String schedule,
+                                   final String repository, Map<String, Object> configuration) {
+        this.id = Objects.requireNonNull(id);
+        this.name = name;
+        this.schedule = schedule;
+        this.repository = repository;
+        this.configuration = configuration;
+    }
+
+    public String getId() {
+        return this.id;
+    }
+
+    public String getName() {
+        return this.name;
+    }
+
+    public String getSchedule() {
+        return this.schedule;
+    }
+
+    public String getRepository() {
+        return this.repository;
+    }
+
+    public Map<String, Object> getConfig() {
+        return this.configuration;
+    }
+
+    public static SnapshotLifecyclePolicy parse(XContentParser parser, String id) {
+        return PARSER.apply(parser, id);
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject();
+        builder.field(NAME.getPreferredName(), this.name);
+        builder.field(SCHEDULE.getPreferredName(), this.schedule);
+        builder.field(REPOSITORY.getPreferredName(), this.repository);
+        builder.field(CONFIG.getPreferredName(), this.configuration);
+        builder.endObject();
+        return builder;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(id, name, schedule, repository, configuration);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == null) {
+            return false;
+        }
+
+        if (obj.getClass() != getClass()) {
+            return false;
+        }
+        SnapshotLifecyclePolicy other = (SnapshotLifecyclePolicy) obj;
+        return Objects.equals(id, other.id) &&
+            Objects.equals(name, other.name) &&
+            Objects.equals(schedule, other.schedule) &&
+            Objects.equals(repository, other.repository) &&
+            Objects.equals(configuration, other.configuration);
+    }
+
+    @Override
+    public String toString() {
+        return Strings.toString(this);
+    }
+}
diff --git a/client/rest-high-level/src/main/java/org/elasticsearch/client/snapshotlifecycle/SnapshotLifecyclePolicyMetadata.java b/client/rest-high-level/src/main/java/org/elasticsearch/client/snapshotlifecycle/SnapshotLifecyclePolicyMetadata.java
new file mode 100644
index 0000000000000..dc68b2fc6e14e
--- /dev/null
+++ b/client/rest-high-level/src/main/java/org/elasticsearch/client/snapshotlifecycle/SnapshotLifecyclePolicyMetadata.java
@@ -0,0 +1,157 @@
+/*
+ * Licensed to Elasticsearch under one or more contributor
+ * license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright
+ * ownership. Elasticsearch licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may
+ * not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.elasticsearch.client.snapshotlifecycle;
+
+import org.elasticsearch.common.Nullable;
+import org.elasticsearch.common.ParseField;
+import org.elasticsearch.common.xcontent.ConstructingObjectParser;
+import org.elasticsearch.common.xcontent.ToXContentObject;
+import org.elasticsearch.common.xcontent.XContentBuilder;
+import org.elasticsearch.common.xcontent.XContentParser;
+
+import java.io.IOException;
+import java.util.Objects;
+
+public class SnapshotLifecyclePolicyMetadata implements ToXContentObject {
+
+    static final ParseField POLICY = new ParseField("policy");
+    static final ParseField VERSION = new ParseField("version");
+    static final ParseField MODIFIED_DATE_MILLIS = new ParseField("modified_date_millis");
+    static final ParseField MODIFIED_DATE = new ParseField("modified_date");
+    static final ParseField LAST_SUCCESS = new ParseField("last_success");
+    static final ParseField LAST_FAILURE = new ParseField("last_failure");
+    static final ParseField NEXT_EXECUTION_MILLIS = new ParseField("next_execution_millis");
+    static final ParseField NEXT_EXECUTION = new ParseField("next_execution");
+
+    private final SnapshotLifecyclePolicy policy;
+    private final long version;
+    private final long modifiedDate;
+    private final long nextExecution;
+    @Nullable
+    private final SnapshotInvocationRecord lastSuccess;
+    @Nullable
+    private final SnapshotInvocationRecord lastFailure;
+
+    @SuppressWarnings("unchecked")
+    public static final ConstructingObjectParser<SnapshotLifecyclePolicyMetadata, String> PARSER =
+        new ConstructingObjectParser<>("snapshot_policy_metadata",
+            a -> {
+                SnapshotLifecyclePolicy policy = (SnapshotLifecyclePolicy) a[0];
+                long version = (long) a[1];
+                long modifiedDate = (long) a[2];
+                SnapshotInvocationRecord lastSuccess = (SnapshotInvocationRecord) a[3];
+                SnapshotInvocationRecord lastFailure = (SnapshotInvocationRecord) a[4];
+                long nextExecution = (long) a[5];
+
+                return new SnapshotLifecyclePolicyMetadata(policy, version, modifiedDate, lastSuccess, lastFailure, nextExecution);
+            });
+
+    static {
+        PARSER.declareObject(ConstructingObjectParser.constructorArg(), SnapshotLifecyclePolicy::parse, POLICY);
+        PARSER.declareLong(ConstructingObjectParser.constructorArg(), VERSION);
+        PARSER.declareLong(ConstructingObjectParser.constructorArg(), MODIFIED_DATE_MILLIS);
+        PARSER.declareObject(ConstructingObjectParser.optionalConstructorArg(), SnapshotInvocationRecord::parse, LAST_SUCCESS);
+        PARSER.declareObject(ConstructingObjectParser.optionalConstructorArg(), SnapshotInvocationRecord::parse, LAST_FAILURE);
+        PARSER.declareLong(ConstructingObjectParser.constructorArg(), NEXT_EXECUTION_MILLIS);
+    }
+
+    public static SnapshotLifecyclePolicyMetadata parse(XContentParser parser, String id) {
+        return PARSER.apply(parser, id);
+    }
+
+    public SnapshotLifecyclePolicyMetadata(SnapshotLifecyclePolicy policy, long version, long modifiedDate,
+                                           SnapshotInvocationRecord lastSuccess, SnapshotInvocationRecord lastFailure,
+                                           long nextExecution) {
+        this.policy = policy;
+        this.version = version;
+        this.modifiedDate = modifiedDate;
+        this.lastSuccess = lastSuccess;
+        this.lastFailure = lastFailure;
+        this.nextExecution = nextExecution;
+    }
+
+    public SnapshotLifecyclePolicy getPolicy() {
+        return policy;
+    }
+
+    public String getName() {
+        return policy.getName();
+    }
+
+    public long getVersion() {
+        return version;
+    }
+
+    public long getModifiedDate() {
+        return modifiedDate;
+    }
+
+    public SnapshotInvocationRecord getLastSuccess() {
+        return lastSuccess;
+    }
+
+    public SnapshotInvocationRecord getLastFailure() {
+        return lastFailure;
+    }
+
+    public long getNextExecution() {
+        return this.nextExecution;
+    }
+
+    @Override
+    public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
+        builder.startObject();
+        builder.field(POLICY.getPreferredName(), policy);
+        builder.field(VERSION.getPreferredName(), version);
+        builder.timeField(MODIFIED_DATE_MILLIS.getPreferredName(), MODIFIED_DATE.getPreferredName(), modifiedDate);
+        if (Objects.nonNull(lastSuccess)) {
+            builder.field(LAST_SUCCESS.getPreferredName(), lastSuccess);
+        }
+        if (Objects.nonNull(lastFailure)) {
+            builder.field(LAST_FAILURE.getPreferredName(), lastFailure);
+        }
+        builder.timeField(NEXT_EXECUTION_MILLIS.getPreferredName(), NEXT_EXECUTION.getPreferredName(), nextExecution);
+        builder.endObject();
+        return builder;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(policy, version, modifiedDate, lastSuccess, lastFailure, nextExecution);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == null) {
+            return false;
+        }
+        if (getClass() != obj.getClass()) {
+            return false;
+        }
+        SnapshotLifecyclePolicyMetadata other = (SnapshotLifecyclePolicyMetadata) obj;
+        return Objects.equals(policy, other.policy) &&
+            Objects.equals(version, other.version) &&
+            Objects.equals(modifiedDate, other.modifiedDate) &&
+            Objects.equals(lastSuccess, other.lastSuccess) &&
+            Objects.equals(lastFailure, other.lastFailure) &&
+            Objects.equals(nextExecution, other.nextExecution);
+    }
+
+}
diff --git a/client/rest-high-level/src/test/java/org/elasticsearch/client/documentation/ILMDocumentationIT.java b/client/rest-high-level/src/test/java/org/elasticsearch/client/documentation/ILMDocumentationIT.java
index db9df0ac24c78..8ff725ea9b086 100644
--- a/client/rest-high-level/src/test/java/org/elasticsearch/client/documentation/ILMDocumentationIT.java
+++ b/client/rest-high-level/src/test/java/org/elasticsearch/client/documentation/ILMDocumentationIT.java
@@ -22,6 +22,9 @@
 import org.apache.http.util.EntityUtils;
 import org.elasticsearch.action.ActionListener;
 import org.elasticsearch.action.LatchedActionListener;
+import org.elasticsearch.action.admin.cluster.repositories.put.PutRepositoryRequest;
+import org.elasticsearch.action.admin.cluster.snapshots.get.GetSnapshotsRequest;
+import org.elasticsearch.action.admin.cluster.snapshots.get.GetSnapshotsResponse;
 import org.elasticsearch.action.admin.indices.alias.Alias;
 import org.elasticsearch.client.ESRestHighLevelClientTestCase;
 import org.elasticsearch.client.RequestOptions;
@@ -51,6 +54,15 @@
 import org.elasticsearch.client.indexlifecycle.StartILMRequest;
 import org.elasticsearch.client.indexlifecycle.StopILMRequest;
 import org.elasticsearch.client.indices.CreateIndexRequest;
+import org.elasticsearch.client.snapshotlifecycle.DeleteSnapshotLifecyclePolicyRequest;
+import org.elasticsearch.client.snapshotlifecycle.ExecuteSnapshotLifecyclePolicyRequest;
+import org.elasticsearch.client.snapshotlifecycle.ExecuteSnapshotLifecyclePolicyResponse;
+import org.elasticsearch.client.snapshotlifecycle.GetSnapshotLifecyclePolicyRequest;
+import org.elasticsearch.client.snapshotlifecycle.GetSnapshotLifecyclePolicyResponse;
+import org.elasticsearch.client.snapshotlifecycle.PutSnapshotLifecyclePolicyRequest;
+import org.elasticsearch.client.snapshotlifecycle.SnapshotInvocationRecord;
+import org.elasticsearch.client.snapshotlifecycle.SnapshotLifecyclePolicy;
+import org.elasticsearch.client.snapshotlifecycle.SnapshotLifecyclePolicyMetadata;
 import org.elasticsearch.cluster.metadata.IndexMetaData;
 import org.elasticsearch.common.Strings;
 import org.elasticsearch.common.collect.ImmutableOpenMap;
@@ -60,6 +72,9 @@
 import org.elasticsearch.common.unit.TimeValue;
 import org.elasticsearch.common.xcontent.XContentHelper;
 import org.elasticsearch.common.xcontent.json.JsonXContent;
+import org.elasticsearch.repositories.fs.FsRepository;
+import org.elasticsearch.snapshots.SnapshotInfo;
+import org.elasticsearch.snapshots.SnapshotState;
 import org.hamcrest.Matchers;
 
 import java.io.IOException;
@@ -68,6 +83,7 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
 
@@ -740,6 +756,239 @@ public void onFailure(Exception e) {
         assertTrue(latch.await(30L, TimeUnit.SECONDS));
     }
 
+    public void testAddSnapshotLifecyclePolicy() throws Exception {
+        RestHighLevelClient client = highLevelClient();
+
+        PutRepositoryRequest repoRequest = new PutRepositoryRequest();
+
+        Settings.Builder settingsBuilder = Settings.builder().put("location", ".");
+        repoRequest.settings(settingsBuilder);
+        repoRequest.name("my_repository");
+        repoRequest.type(FsRepository.TYPE);
+        org.elasticsearch.action.support.master.AcknowledgedResponse response =
+            client.snapshot().createRepository(repoRequest, RequestOptions.DEFAULT);
+        assertTrue(response.isAcknowledged());
+
+        //////// PUT
+        // tag::slm-put-snapshot-lifecycle-policy
+        Map<String, Object> config = new HashMap<>();
+        config.put("indices", Collections.singletonList("idx"));
+        SnapshotLifecyclePolicy policy = new SnapshotLifecyclePolicy(
+            "policy_id", "name", "1 2 3 * * ?", "my_repository", config);
+        PutSnapshotLifecyclePolicyRequest request =
+            new PutSnapshotLifecyclePolicyRequest(policy);
+        // end::slm-put-snapshot-lifecycle-policy
+
+        // tag::slm-put-snapshot-lifecycle-policy-execute
+        AcknowledgedResponse resp = client.indexLifecycle()
+            .putSnapshotLifecyclePolicy(request, RequestOptions.DEFAULT);
+        // end::slm-put-snapshot-lifecycle-policy-execute
+
+        // tag::slm-put-snapshot-lifecycle-policy-response
+        boolean putAcknowledged = resp.isAcknowledged(); // <1>
+        // end::slm-put-snapshot-lifecycle-policy-response
+        assertTrue(putAcknowledged);
+
+        // tag::slm-put-snapshot-lifecycle-policy-execute-listener
+        ActionListener<AcknowledgedResponse> putListener =
+                new ActionListener<>() {
+            @Override
+            public void onResponse(AcknowledgedResponse resp) {
+                boolean acknowledged = resp.isAcknowledged(); // <1>
+            }
+
+            @Override
+            public void onFailure(Exception e) {
+                // <2>
+            }
+        };
+        // end::slm-put-snapshot-lifecycle-policy-execute-listener
+
+        // tag::slm-put-snapshot-lifecycle-policy-execute-async
+        client.indexLifecycle().putSnapshotLifecyclePolicyAsync(request,
+            RequestOptions.DEFAULT, putListener);
+        // end::slm-put-snapshot-lifecycle-policy-execute-async
+
+        //////// GET
+        // tag::slm-get-snapshot-lifecycle-policy
+        GetSnapshotLifecyclePolicyRequest getAllRequest =
+            new GetSnapshotLifecyclePolicyRequest(); // <1>
+        GetSnapshotLifecyclePolicyRequest getRequest =
+            new GetSnapshotLifecyclePolicyRequest("policy_id"); // <2>
+        // end::slm-get-snapshot-lifecycle-policy
+
+        // tag::slm-get-snapshot-lifecycle-policy-execute
+        GetSnapshotLifecyclePolicyResponse getResponse =
+            client.indexLifecycle()
+                .getSnapshotLifecyclePolicy(getRequest,
+                    RequestOptions.DEFAULT);
+        // end::slm-get-snapshot-lifecycle-policy-execute
+
+        // tag::slm-get-snapshot-lifecycle-policy-execute-listener
+        ActionListener<GetSnapshotLifecyclePolicyResponse> getListener =
+                new ActionListener<>() {
+            @Override
+            public void onResponse(GetSnapshotLifecyclePolicyResponse resp) {
+                Map<String, SnapshotLifecyclePolicyMetadata> policies =
+                    resp.getPolicies(); // <1>
+            }
+
+            @Override
+            public void onFailure(Exception e) {
+                // <2>
+            }
+        };
+        // end::slm-get-snapshot-lifecycle-policy-execute-listener
+
+        // tag::slm-get-snapshot-lifecycle-policy-execute-async
+        client.indexLifecycle().getSnapshotLifecyclePolicyAsync(getRequest,
+            RequestOptions.DEFAULT, getListener);
+        // end::slm-get-snapshot-lifecycle-policy-execute-async
+
+        assertThat(getResponse.getPolicies().size(), equalTo(1));
+        // tag::slm-get-snapshot-lifecycle-policy-response
+        SnapshotLifecyclePolicyMetadata policyMeta =
+            getResponse.getPolicies().get("policy_id"); // <1>
+        long policyVersion = policyMeta.getVersion();
+        long policyModificationDate = policyMeta.getModifiedDate();
+        long nextPolicyExecutionDate = policyMeta.getNextExecution();
+        SnapshotInvocationRecord lastSuccess = policyMeta.getLastSuccess();
+        SnapshotInvocationRecord lastFailure = policyMeta.getLastFailure();
+        SnapshotLifecyclePolicy retrievedPolicy = policyMeta.getPolicy(); // <2>
+        String id = retrievedPolicy.getId();
+        String snapshotNameFormat = retrievedPolicy.getName();
+        String repositoryName = retrievedPolicy.getRepository();
+        String schedule = retrievedPolicy.getSchedule();
+        Map<String, Object> snapshotConfiguration = retrievedPolicy.getConfig();
+        // end::slm-get-snapshot-lifecycle-policy-response
+
+        assertNotNull(policyMeta);
+        assertThat(retrievedPolicy, equalTo(policy));
+        assertThat(policyVersion, equalTo(1L));
+
+        createIndex("idx", Settings.builder().put("index.number_of_shards", 1).build());
+
+        //////// EXECUTE
+        // tag::slm-execute-snapshot-lifecycle-policy
+        ExecuteSnapshotLifecyclePolicyRequest executeRequest =
+            new ExecuteSnapshotLifecyclePolicyRequest("policy_id"); // <1>
+        // end::slm-execute-snapshot-lifecycle-policy
+
+        // tag::slm-execute-snapshot-lifecycle-policy-execute
+        ExecuteSnapshotLifecyclePolicyResponse executeResponse =
+            client.indexLifecycle()
+                .executeSnapshotLifecyclePolicy(executeRequest,
+                    RequestOptions.DEFAULT);
+        // end::slm-execute-snapshot-lifecycle-policy-execute
+
+        // tag::slm-execute-snapshot-lifecycle-policy-response
+        final String snapshotName = executeResponse.getSnapshotName(); // <1>
+        // end::slm-execute-snapshot-lifecycle-policy-response
+
+        assertSnapshotExists(client, "my_repository", snapshotName);
+
+        // tag::slm-execute-snapshot-lifecycle-policy-execute-listener
+        ActionListener<ExecuteSnapshotLifecyclePolicyResponse> executeListener =
+                new ActionListener<>() {
+            @Override
+            public void onResponse(ExecuteSnapshotLifecyclePolicyResponse r) {
+                String snapshotName = r.getSnapshotName(); // <1>
+            }
+
+            @Override
+            public void onFailure(Exception e) {
+                // <2>
+            }
+        };
+        // end::slm-execute-snapshot-lifecycle-policy-execute-listener
+
+        // We need a listener that will actually wait for the snapshot to be created
+        CountDownLatch latch = new CountDownLatch(1);
+        executeListener =
+            new ActionListener<>() {
+                @Override
+                public void onResponse(ExecuteSnapshotLifecyclePolicyResponse r) {
+                    try {
+                        assertSnapshotExists(client, "my_repository", r.getSnapshotName());
+                    } catch (Exception e) {
+                        // Ignore
+                    } finally {
+                        latch.countDown();
+                    }
+                }
+
+                @Override
+                public void onFailure(Exception e) {
+                    latch.countDown();
+                    fail("failed to execute slm execute: " + e);
+                }
+        };
+
+        // tag::slm-execute-snapshot-lifecycle-policy-execute-async
+        client.indexLifecycle()
+            .executeSnapshotLifecyclePolicyAsync(executeRequest,
+                RequestOptions.DEFAULT, executeListener);
+        // end::slm-execute-snapshot-lifecycle-policy-execute-async
+        latch.await(5, TimeUnit.SECONDS);
+
+        //////// DELETE
+        // tag::slm-delete-snapshot-lifecycle-policy
+        DeleteSnapshotLifecyclePolicyRequest deleteRequest =
+            new DeleteSnapshotLifecyclePolicyRequest("policy_id"); // <1>
+        // end::slm-delete-snapshot-lifecycle-policy
+
+        // tag::slm-delete-snapshot-lifecycle-policy-execute
+        AcknowledgedResponse deleteResp = client.indexLifecycle()
+            .deleteSnapshotLifecyclePolicy(deleteRequest, RequestOptions.DEFAULT);
+        // end::slm-delete-snapshot-lifecycle-policy-execute
+        assertTrue(deleteResp.isAcknowledged());
+
+        ActionListener<AcknowledgedResponse> deleteListener = new ActionListener<>() {
+            @Override
+            public void onResponse(AcknowledgedResponse resp) {
+                // no-op
+            }
+
+            @Override
+            public void onFailure(Exception e) {
+                // no-op
+            }
+        };
+
+        // tag::slm-delete-snapshot-lifecycle-policy-execute-async
+        client.indexLifecycle()
+            .deleteSnapshotLifecyclePolicyAsync(deleteRequest,
+                RequestOptions.DEFAULT, deleteListener);
+        // end::slm-delete-snapshot-lifecycle-policy-execute-async
+
+        assertTrue(deleteResp.isAcknowledged());
+    }
+
+    private void assertSnapshotExists(final RestHighLevelClient client, final String repo, final String snapshotName) throws Exception {
+        assertBusy(() -> {
+            GetSnapshotsRequest getSnapshotsRequest = new GetSnapshotsRequest(repo, new String[]{snapshotName});
+            final GetSnapshotsResponse snaps;
+            try {
+                snaps = client.snapshot().get(getSnapshotsRequest, RequestOptions.DEFAULT);
+            } catch (Exception e) {
+                if (e.getMessage().contains("snapshot_missing_exception")) {
+                    fail("snapshot does not exist: " + snapshotName);
+                }
+                throw e;
+            }
+            Optional<SnapshotInfo> info = snaps.getSnapshots().stream().findFirst();
+
+            if (info.isPresent()) {
+                info.ifPresent(si -> {
+                    assertThat(si.snapshotId().getName(), equalTo(snapshotName));
+                    assertThat(si.state(), equalTo(SnapshotState.SUCCESS));
+                });
+            } else {
+                fail("unable to find snapshot; " + snapshotName);
+            }
+        });
+    }
+
     static Map<String, Object> toMap(Response response) throws IOException {
         return XContentHelper.convertToMap(JsonXContent.jsonXContent, EntityUtils.toString(response.getEntity()), false);
     }
diff --git a/docs/java-rest/high-level/ilm/delete_snapshot_lifecycle_policy.asciidoc b/docs/java-rest/high-level/ilm/delete_snapshot_lifecycle_policy.asciidoc
new file mode 100644
index 0000000000000..66819d06187b7
--- /dev/null
+++ b/docs/java-rest/high-level/ilm/delete_snapshot_lifecycle_policy.asciidoc
@@ -0,0 +1,36 @@
+--
+:api: slm-delete-snapshot-lifecycle-policy
+:request: DeleteSnapshotLifecyclePolicyRequest
+:response: AcknowledgedResponse
+--
+
+[id="{upid}-{api}"]
+=== Delete Snapshot Lifecycle Policy API
+
+
+[id="{upid}-{api}-request"]
+==== Request
+
+The Delete Snapshot Lifecycle Policy API allows you to delete a Snapshot Lifecycle Management Policy
+from the cluster.
+
+["source","java",subs="attributes,callouts,macros"]
+--------------------------------------------------
+include-tagged::{doc-tests-file}[{api}-request]
+--------------------------------------------------
+<1> The policy with the id `policy_id` will be deleted.
+
+[id="{upid}-{api}-response"]
+==== Response
+
+The returned +{response}+ indicates if the delete snapshot lifecycle policy request was received.
+
+["source","java",subs="attributes,callouts,macros"]
+--------------------------------------------------
+include-tagged::{doc-tests-file}[{api}-response]
+--------------------------------------------------
+<1> Whether or not the delete snapshot lifecycle policy request was acknowledged.
+
+include::../execution.asciidoc[]
+
+
diff --git a/docs/java-rest/high-level/ilm/execute_snapshot_lifecycle_policy.asciidoc b/docs/java-rest/high-level/ilm/execute_snapshot_lifecycle_policy.asciidoc
new file mode 100644
index 0000000000000..7b3af935a27c7
--- /dev/null
+++ b/docs/java-rest/high-level/ilm/execute_snapshot_lifecycle_policy.asciidoc
@@ -0,0 +1,36 @@
+--
+:api: slm-execute-snapshot-lifecycle-policy
+:request: ExecuteSnapshotLifecyclePolicyRequest
+:response: ExecuteSnapshotLifecyclePolicyResponse
+--
+
+[id="{upid}-{api}"]
+=== Execute Snapshot Lifecycle Policy API
+
+
+[id="{upid}-{api}-request"]
+==== Request
+
+The Execute Snapshot Lifecycle Policy API allows you to execute a Snapshot Lifecycle Management
+Policy, taking a snapshot immediately.
+
+["source","java",subs="attributes,callouts,macros"]
+--------------------------------------------------
+include-tagged::{doc-tests-file}[{api}-request]
+--------------------------------------------------
+<1> The policy id to execute
+
+[id="{upid}-{api}-response"]
+==== Response
+
+The returned +{response}+ contains the name of the snapshot that was created.
+
+["source","java",subs="attributes,callouts,macros"]
+--------------------------------------------------
+include-tagged::{doc-tests-file}[{api}-response]
+--------------------------------------------------
+<1> The created snapshot name
+
+include::../execution.asciidoc[]
+
+
diff --git a/docs/java-rest/high-level/ilm/get_snapshot_lifecycle_policy.asciidoc b/docs/java-rest/high-level/ilm/get_snapshot_lifecycle_policy.asciidoc
new file mode 100644
index 0000000000000..eaa8af7969ee0
--- /dev/null
+++ b/docs/java-rest/high-level/ilm/get_snapshot_lifecycle_policy.asciidoc
@@ -0,0 +1,39 @@
+--
+:api: slm-get-snapshot-lifecycle-policy
+:request: GetSnapshotLifecyclePolicyRequest
+:response: GetSnapshotLifecyclePolicyResponse
+--
+
+[id="{upid}-{api}"]
+=== Get Snapshot Lifecycle Policy API
+
+
+[id="{upid}-{api}-request"]
+==== Request
+
+The Get Snapshot Lifecycle Policy API allows you to retrieve the definition of a Snapshot Lifecycle
+Management Policy from the cluster.
+
+["source","java",subs="attributes,callouts,macros"]
+--------------------------------------------------
+include-tagged::{doc-tests-file}[{api}-request]
+--------------------------------------------------
+<1> Gets all policies.
+<2> Gets `policy_id`
+
+[id="{upid}-{api}-response"]
+==== Response
+
+The returned +{response}+ contains a map of `SnapshotLifecyclePolicyMetadata`, accessible by the id
+of the policy, which contains data about each policy, as well as the policy definition.
+
+["source","java",subs="attributes,callouts,macros"]
+--------------------------------------------------
+include-tagged::{doc-tests-file}[{api}-response]
+--------------------------------------------------
+<1> The retrieved policies are retrieved by id.
+<2> The policy definition itself.
+
+include::../execution.asciidoc[]
+
+
diff --git a/docs/java-rest/high-level/ilm/put_snapshot_lifecycle_policy.asciidoc b/docs/java-rest/high-level/ilm/put_snapshot_lifecycle_policy.asciidoc
new file mode 100644
index 0000000000000..7fe7fec26c3b7
--- /dev/null
+++ b/docs/java-rest/high-level/ilm/put_snapshot_lifecycle_policy.asciidoc
@@ -0,0 +1,35 @@
+--
+:api: slm-put-snapshot-lifecycle-policy
+:request: PutSnapshotLifecyclePolicyRequest
+:response: AcknowledgedResponse
+--
+
+[id="{upid}-{api}"]
+=== Put Snapshot Lifecycle Policy API
+
+
+[id="{upid}-{api}-request"]
+==== Request
+
+The Put Snapshot Lifecycle Policy API allows you to add of update the definition of a Snapshot
+Lifecycle Management Policy in the cluster.
+
+["source","java",subs="attributes,callouts,macros"]
+--------------------------------------------------
+include-tagged::{doc-tests-file}[{api}-request]
+--------------------------------------------------
+
+[id="{upid}-{api}-response"]
+==== Response
+
+The returned +{response}+ indicates if the put snapshot lifecycle policy request was received.
+
+["source","java",subs="attributes,callouts,macros"]
+--------------------------------------------------
+include-tagged::{doc-tests-file}[{api}-response]
+--------------------------------------------------
+<1> Whether or not the put snapshot lifecycle policy was acknowledged.
+
+include::../execution.asciidoc[]
+
+