diff --git a/src/CodeGeneration/ApiGenerator/Program.cs b/src/CodeGeneration/ApiGenerator/Program.cs
index 25e65806591..9549c83c711 100644
--- a/src/CodeGeneration/ApiGenerator/Program.cs
+++ b/src/CodeGeneration/ApiGenerator/Program.cs
@@ -40,7 +40,7 @@ private static void Main(string[] args)
 				RestSpecDownloader.Download(downloadBranch);
 
 			ApiGenerator.Generate(downloadBranch, "Core", "Graph", "License", "Security", "Watcher", "Info", "MachineLearning", "Migration", "Sql",
-				"Rollup", "Ssl");
+				"Rollup", "Ccr", "Ssl");
 		}
 	}
 }
diff --git a/src/Elasticsearch.Net/Domain/RequestParameters/RequestParameters.Generated.cs b/src/Elasticsearch.Net/Domain/RequestParameters/RequestParameters.Generated.cs
index fab698bd43a..e032c8e5e69 100644
--- a/src/Elasticsearch.Net/Domain/RequestParameters/RequestParameters.Generated.cs
+++ b/src/Elasticsearch.Net/Domain/RequestParameters/RequestParameters.Generated.cs
@@ -2187,6 +2187,51 @@ public partial class UpdateByQueryRequestParameters : RequestParameters<UpdateBy
 		///<summary>The number of slices this task should be divided into. Defaults to 1 meaning the task isn't sliced into subtasks.</summary>
 		public long? Slices { get => Q<long?>("slices"); set => Q("slices", value); }
 	}
+	///<summary>Request options for CcrDeleteAutoFollowPattern<pre>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-delete-auto-follow-pattern.html</pre></summary>
+	public partial class DeleteAutoFollowPatternRequestParameters : RequestParameters<DeleteAutoFollowPatternRequestParameters> 
+	{
+		public override HttpMethod DefaultHttpMethod => HttpMethod.DELETE;
+	}
+	///<summary>Request options for CcrFollow<pre>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-put-follow.html</pre></summary>
+	public partial class CreateFollowIndexRequestParameters : RequestParameters<CreateFollowIndexRequestParameters> 
+	{
+		public override HttpMethod DefaultHttpMethod => HttpMethod.PUT;
+	}
+	///<summary>Request options for CcrFollowStats<pre>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-get-follow-stats.html</pre></summary>
+	public partial class FollowIndexStatsRequestParameters : RequestParameters<FollowIndexStatsRequestParameters> 
+	{
+		public override HttpMethod DefaultHttpMethod => HttpMethod.GET;
+	}
+	///<summary>Request options for CcrGetAutoFollowPattern<pre>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-get-auto-follow-pattern.html</pre></summary>
+	public partial class GetAutoFollowPatternRequestParameters : RequestParameters<GetAutoFollowPatternRequestParameters> 
+	{
+		public override HttpMethod DefaultHttpMethod => HttpMethod.GET;
+	}
+	///<summary>Request options for CcrPauseFollow<pre>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-post-pause-follow.html</pre></summary>
+	public partial class PauseFollowIndexRequestParameters : RequestParameters<PauseFollowIndexRequestParameters> 
+	{
+		public override HttpMethod DefaultHttpMethod => HttpMethod.POST;
+	}
+	///<summary>Request options for CcrPutAutoFollowPattern<pre>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-put-auto-follow-pattern.html</pre></summary>
+	public partial class CreateAutoFollowPatternRequestParameters : RequestParameters<CreateAutoFollowPatternRequestParameters> 
+	{
+		public override HttpMethod DefaultHttpMethod => HttpMethod.PUT;
+	}
+	///<summary>Request options for CcrResumeFollow<pre>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-post-resume-follow.html</pre></summary>
+	public partial class ResumeFollowIndexRequestParameters : RequestParameters<ResumeFollowIndexRequestParameters> 
+	{
+		public override HttpMethod DefaultHttpMethod => HttpMethod.POST;
+	}
+	///<summary>Request options for CcrStats<pre>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-get-stats.html</pre></summary>
+	public partial class CcrStatsRequestParameters : RequestParameters<CcrStatsRequestParameters> 
+	{
+		public override HttpMethod DefaultHttpMethod => HttpMethod.GET;
+	}
+	///<summary>Request options for CcrUnfollow<pre>http://www.elastic.co/guide/en/elasticsearch/reference/current</pre></summary>
+	public partial class UnfollowIndexRequestParameters : RequestParameters<UnfollowIndexRequestParameters> 
+	{
+		public override HttpMethod DefaultHttpMethod => HttpMethod.POST;
+	}
 	///<summary>Request options for XpackGraphExplore<pre>https://www.elastic.co/guide/en/elasticsearch/reference/current/graph-explore-api.html</pre></summary>
 	public partial class GraphExploreRequestParameters : RequestParameters<GraphExploreRequestParameters> 
 	{
diff --git a/src/Elasticsearch.Net/ElasticLowLevelClient.Generated.cs b/src/Elasticsearch.Net/ElasticLowLevelClient.Generated.cs
index 78bb52fc131..39279aeed86 100644
--- a/src/Elasticsearch.Net/ElasticLowLevelClient.Generated.cs
+++ b/src/Elasticsearch.Net/ElasticLowLevelClient.Generated.cs
@@ -2930,6 +2930,108 @@ public TResponse UpdateByQuery<TResponse>(string index, string type, PostData bo
 		///<param name="requestParameters">A func that allows you to describe the querystring parameters &amp; request specific connection settings.</param>
 		public Task<TResponse> UpdateByQueryAsync<TResponse>(string index, string type, PostData body, UpdateByQueryRequestParameters requestParameters = null, CancellationToken ctx = default(CancellationToken))
 			where TResponse : class, IElasticsearchResponse, new() => this.DoRequestAsync<TResponse>(POST, Url($"{index.NotNull("index")}/{type.NotNull("type")}/_update_by_query"), ctx, body, _params(requestParameters));
+		///<summary>DELETE on /_ccr/auto_follow/{name} <para>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-delete-auto-follow-pattern.html</para></summary>
+		///<param name="name">The name of the auto follow pattern.</param>
+		///<param name="requestParameters">A func that allows you to describe the querystring parameters &amp; request specific connection settings.</param>
+		public TResponse CcrDeleteAutoFollowPattern<TResponse>(string name, DeleteAutoFollowPatternRequestParameters requestParameters = null)
+			where TResponse : class, IElasticsearchResponse, new() => this.DoRequest<TResponse>(DELETE, Url($"_ccr/auto_follow/{name.NotNull("name")}"), null, _params(requestParameters));
+		///<summary>DELETE on /_ccr/auto_follow/{name} <para>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-delete-auto-follow-pattern.html</para></summary>
+		///<param name="name">The name of the auto follow pattern.</param>
+		///<param name="requestParameters">A func that allows you to describe the querystring parameters &amp; request specific connection settings.</param>
+		public Task<TResponse> CcrDeleteAutoFollowPatternAsync<TResponse>(string name, DeleteAutoFollowPatternRequestParameters requestParameters = null, CancellationToken ctx = default(CancellationToken))
+			where TResponse : class, IElasticsearchResponse, new() => this.DoRequestAsync<TResponse>(DELETE, Url($"_ccr/auto_follow/{name.NotNull("name")}"), ctx, null, _params(requestParameters));
+		///<summary>PUT on /{index}/_ccr/follow <para>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-put-follow.html</para></summary>
+		///<param name="index">The name of the follower index</param>
+		///<param name="body">The name of the leader index and other optional ccr related parameters</param>
+		///<param name="requestParameters">A func that allows you to describe the querystring parameters &amp; request specific connection settings.</param>
+		public TResponse CcrFollow<TResponse>(string index, PostData body, CreateFollowIndexRequestParameters requestParameters = null)
+			where TResponse : class, IElasticsearchResponse, new() => this.DoRequest<TResponse>(PUT, Url($"{index.NotNull("index")}/_ccr/follow"), body, _params(requestParameters));
+		///<summary>PUT on /{index}/_ccr/follow <para>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-put-follow.html</para></summary>
+		///<param name="index">The name of the follower index</param>
+		///<param name="body">The name of the leader index and other optional ccr related parameters</param>
+		///<param name="requestParameters">A func that allows you to describe the querystring parameters &amp; request specific connection settings.</param>
+		public Task<TResponse> CcrFollowAsync<TResponse>(string index, PostData body, CreateFollowIndexRequestParameters requestParameters = null, CancellationToken ctx = default(CancellationToken))
+			where TResponse : class, IElasticsearchResponse, new() => this.DoRequestAsync<TResponse>(PUT, Url($"{index.NotNull("index")}/_ccr/follow"), ctx, body, _params(requestParameters));
+		///<summary>GET on /{index}/_ccr/stats <para>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-get-follow-stats.html</para></summary>
+		///<param name="index">A comma-separated list of index patterns; use `_all` to perform the operation on all indices</param>
+		///<param name="requestParameters">A func that allows you to describe the querystring parameters &amp; request specific connection settings.</param>
+		public TResponse CcrFollowStats<TResponse>(string index, FollowIndexStatsRequestParameters requestParameters = null)
+			where TResponse : class, IElasticsearchResponse, new() => this.DoRequest<TResponse>(GET, Url($"{index.NotNull("index")}/_ccr/stats"), null, _params(requestParameters));
+		///<summary>GET on /{index}/_ccr/stats <para>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-get-follow-stats.html</para></summary>
+		///<param name="index">A comma-separated list of index patterns; use `_all` to perform the operation on all indices</param>
+		///<param name="requestParameters">A func that allows you to describe the querystring parameters &amp; request specific connection settings.</param>
+		public Task<TResponse> CcrFollowStatsAsync<TResponse>(string index, FollowIndexStatsRequestParameters requestParameters = null, CancellationToken ctx = default(CancellationToken))
+			where TResponse : class, IElasticsearchResponse, new() => this.DoRequestAsync<TResponse>(GET, Url($"{index.NotNull("index")}/_ccr/stats"), ctx, null, _params(requestParameters));
+		///<summary>GET on /_ccr/auto_follow <para>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-get-auto-follow-pattern.html</para></summary>
+		///<param name="requestParameters">A func that allows you to describe the querystring parameters &amp; request specific connection settings.</param>
+		public TResponse CcrGetAutoFollowPattern<TResponse>(GetAutoFollowPatternRequestParameters requestParameters = null)
+			where TResponse : class, IElasticsearchResponse, new() => this.DoRequest<TResponse>(GET, Url($"_ccr/auto_follow"), null, _params(requestParameters));
+		///<summary>GET on /_ccr/auto_follow <para>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-get-auto-follow-pattern.html</para></summary>
+		///<param name="requestParameters">A func that allows you to describe the querystring parameters &amp; request specific connection settings.</param>
+		public Task<TResponse> CcrGetAutoFollowPatternAsync<TResponse>(GetAutoFollowPatternRequestParameters requestParameters = null, CancellationToken ctx = default(CancellationToken))
+			where TResponse : class, IElasticsearchResponse, new() => this.DoRequestAsync<TResponse>(GET, Url($"_ccr/auto_follow"), ctx, null, _params(requestParameters));
+		///<summary>GET on /_ccr/auto_follow/{name} <para>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-get-auto-follow-pattern.html</para></summary>
+		///<param name="name">The name of the auto follow pattern.</param>
+		///<param name="requestParameters">A func that allows you to describe the querystring parameters &amp; request specific connection settings.</param>
+		public TResponse CcrGetAutoFollowPattern<TResponse>(string name, GetAutoFollowPatternRequestParameters requestParameters = null)
+			where TResponse : class, IElasticsearchResponse, new() => this.DoRequest<TResponse>(GET, Url($"_ccr/auto_follow/{name.NotNull("name")}"), null, _params(requestParameters));
+		///<summary>GET on /_ccr/auto_follow/{name} <para>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-get-auto-follow-pattern.html</para></summary>
+		///<param name="name">The name of the auto follow pattern.</param>
+		///<param name="requestParameters">A func that allows you to describe the querystring parameters &amp; request specific connection settings.</param>
+		public Task<TResponse> CcrGetAutoFollowPatternAsync<TResponse>(string name, GetAutoFollowPatternRequestParameters requestParameters = null, CancellationToken ctx = default(CancellationToken))
+			where TResponse : class, IElasticsearchResponse, new() => this.DoRequestAsync<TResponse>(GET, Url($"_ccr/auto_follow/{name.NotNull("name")}"), ctx, null, _params(requestParameters));
+		///<summary>POST on /{index}/_ccr/pause_follow <para>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-post-pause-follow.html</para></summary>
+		///<param name="index">The name of the follower index that should pause following its leader index.</param>
+		///<param name="requestParameters">A func that allows you to describe the querystring parameters &amp; request specific connection settings.</param>
+		public TResponse CcrPauseFollow<TResponse>(string index, PauseFollowIndexRequestParameters requestParameters = null)
+			where TResponse : class, IElasticsearchResponse, new() => this.DoRequest<TResponse>(POST, Url($"{index.NotNull("index")}/_ccr/pause_follow"), null, _params(requestParameters));
+		///<summary>POST on /{index}/_ccr/pause_follow <para>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-post-pause-follow.html</para></summary>
+		///<param name="index">The name of the follower index that should pause following its leader index.</param>
+		///<param name="requestParameters">A func that allows you to describe the querystring parameters &amp; request specific connection settings.</param>
+		public Task<TResponse> CcrPauseFollowAsync<TResponse>(string index, PauseFollowIndexRequestParameters requestParameters = null, CancellationToken ctx = default(CancellationToken))
+			where TResponse : class, IElasticsearchResponse, new() => this.DoRequestAsync<TResponse>(POST, Url($"{index.NotNull("index")}/_ccr/pause_follow"), ctx, null, _params(requestParameters));
+		///<summary>PUT on /_ccr/auto_follow/{name} <para>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-put-auto-follow-pattern.html</para></summary>
+		///<param name="name">The name of the auto follow pattern.</param>
+		///<param name="body">The specification of the auto follow pattern</param>
+		///<param name="requestParameters">A func that allows you to describe the querystring parameters &amp; request specific connection settings.</param>
+		public TResponse CcrPutAutoFollowPattern<TResponse>(string name, PostData body, CreateAutoFollowPatternRequestParameters requestParameters = null)
+			where TResponse : class, IElasticsearchResponse, new() => this.DoRequest<TResponse>(PUT, Url($"_ccr/auto_follow/{name.NotNull("name")}"), body, _params(requestParameters));
+		///<summary>PUT on /_ccr/auto_follow/{name} <para>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-put-auto-follow-pattern.html</para></summary>
+		///<param name="name">The name of the auto follow pattern.</param>
+		///<param name="body">The specification of the auto follow pattern</param>
+		///<param name="requestParameters">A func that allows you to describe the querystring parameters &amp; request specific connection settings.</param>
+		public Task<TResponse> CcrPutAutoFollowPatternAsync<TResponse>(string name, PostData body, CreateAutoFollowPatternRequestParameters requestParameters = null, CancellationToken ctx = default(CancellationToken))
+			where TResponse : class, IElasticsearchResponse, new() => this.DoRequestAsync<TResponse>(PUT, Url($"_ccr/auto_follow/{name.NotNull("name")}"), ctx, body, _params(requestParameters));
+		///<summary>POST on /{index}/_ccr/resume_follow <para>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-post-resume-follow.html</para></summary>
+		///<param name="index">The name of the follow index to resume following.</param>
+		///<param name="body">The name of the leader index and other optional ccr related parameters</param>
+		///<param name="requestParameters">A func that allows you to describe the querystring parameters &amp; request specific connection settings.</param>
+		public TResponse CcrResumeFollow<TResponse>(string index, PostData body, ResumeFollowIndexRequestParameters requestParameters = null)
+			where TResponse : class, IElasticsearchResponse, new() => this.DoRequest<TResponse>(POST, Url($"{index.NotNull("index")}/_ccr/resume_follow"), body, _params(requestParameters));
+		///<summary>POST on /{index}/_ccr/resume_follow <para>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-post-resume-follow.html</para></summary>
+		///<param name="index">The name of the follow index to resume following.</param>
+		///<param name="body">The name of the leader index and other optional ccr related parameters</param>
+		///<param name="requestParameters">A func that allows you to describe the querystring parameters &amp; request specific connection settings.</param>
+		public Task<TResponse> CcrResumeFollowAsync<TResponse>(string index, PostData body, ResumeFollowIndexRequestParameters requestParameters = null, CancellationToken ctx = default(CancellationToken))
+			where TResponse : class, IElasticsearchResponse, new() => this.DoRequestAsync<TResponse>(POST, Url($"{index.NotNull("index")}/_ccr/resume_follow"), ctx, body, _params(requestParameters));
+		///<summary>GET on /_ccr/stats <para>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-get-stats.html</para></summary>
+		///<param name="requestParameters">A func that allows you to describe the querystring parameters &amp; request specific connection settings.</param>
+		public TResponse CcrStats<TResponse>(CcrStatsRequestParameters requestParameters = null)
+			where TResponse : class, IElasticsearchResponse, new() => this.DoRequest<TResponse>(GET, Url($"_ccr/stats"), null, _params(requestParameters));
+		///<summary>GET on /_ccr/stats <para>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-get-stats.html</para></summary>
+		///<param name="requestParameters">A func that allows you to describe the querystring parameters &amp; request specific connection settings.</param>
+		public Task<TResponse> CcrStatsAsync<TResponse>(CcrStatsRequestParameters requestParameters = null, CancellationToken ctx = default(CancellationToken))
+			where TResponse : class, IElasticsearchResponse, new() => this.DoRequestAsync<TResponse>(GET, Url($"_ccr/stats"), ctx, null, _params(requestParameters));
+		///<summary>POST on /{index}/_ccr/unfollow <para>http://www.elastic.co/guide/en/elasticsearch/reference/current</para></summary>
+		///<param name="index">The name of the follower index that should be turned into a regular index.</param>
+		///<param name="requestParameters">A func that allows you to describe the querystring parameters &amp; request specific connection settings.</param>
+		public TResponse CcrUnfollow<TResponse>(string index, UnfollowIndexRequestParameters requestParameters = null)
+			where TResponse : class, IElasticsearchResponse, new() => this.DoRequest<TResponse>(POST, Url($"{index.NotNull("index")}/_ccr/unfollow"), null, _params(requestParameters));
+		///<summary>POST on /{index}/_ccr/unfollow <para>http://www.elastic.co/guide/en/elasticsearch/reference/current</para></summary>
+		///<param name="index">The name of the follower index that should be turned into a regular index.</param>
+		///<param name="requestParameters">A func that allows you to describe the querystring parameters &amp; request specific connection settings.</param>
+		public Task<TResponse> CcrUnfollowAsync<TResponse>(string index, UnfollowIndexRequestParameters requestParameters = null, CancellationToken ctx = default(CancellationToken))
+			where TResponse : class, IElasticsearchResponse, new() => this.DoRequestAsync<TResponse>(POST, Url($"{index.NotNull("index")}/_ccr/unfollow"), ctx, null, _params(requestParameters));
 		///<summary>GET on /{index}/_xpack/graph/_explore <para>https://www.elastic.co/guide/en/elasticsearch/reference/current/graph-explore-api.html</para></summary>
 		///<param name="index">A comma-separated list of index names to search; use the special string `_all` or Indices.All to perform the operation on all indices</param>
 		///<param name="requestParameters">A func that allows you to describe the querystring parameters &amp; request specific connection settings.</param>
diff --git a/src/Elasticsearch.Net/IElasticLowLevelClient.Generated.cs b/src/Elasticsearch.Net/IElasticLowLevelClient.Generated.cs
index 9c3ab3f798a..53e7391e819 100644
--- a/src/Elasticsearch.Net/IElasticLowLevelClient.Generated.cs
+++ b/src/Elasticsearch.Net/IElasticLowLevelClient.Generated.cs
@@ -2376,6 +2376,88 @@ public partial interface IElasticLowLevelClient
 		///<param name="body">The search definition using the Query DSL</param>
 		///<param name="requestParameters">A func that allows you to describe the querystring parameters &amp; request specific connection settings.</param>
 		Task<TResponse> UpdateByQueryAsync<TResponse>(string index, string type, PostData body, UpdateByQueryRequestParameters requestParameters = null, CancellationToken ctx = default(CancellationToken)) where TResponse : class, IElasticsearchResponse, new();
+		///<summary>DELETE on /_ccr/auto_follow/{name} <para>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-delete-auto-follow-pattern.html</para></summary>
+		///<param name="name">The name of the auto follow pattern.</param>
+		///<param name="requestParameters">A func that allows you to describe the querystring parameters &amp; request specific connection settings.</param>
+		TResponse CcrDeleteAutoFollowPattern<TResponse>(string name, DeleteAutoFollowPatternRequestParameters requestParameters = null) where TResponse : class, IElasticsearchResponse, new();
+		///<summary>DELETE on /_ccr/auto_follow/{name} <para>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-delete-auto-follow-pattern.html</para></summary>
+		///<param name="name">The name of the auto follow pattern.</param>
+		///<param name="requestParameters">A func that allows you to describe the querystring parameters &amp; request specific connection settings.</param>
+		Task<TResponse> CcrDeleteAutoFollowPatternAsync<TResponse>(string name, DeleteAutoFollowPatternRequestParameters requestParameters = null, CancellationToken ctx = default(CancellationToken)) where TResponse : class, IElasticsearchResponse, new();
+		///<summary>PUT on /{index}/_ccr/follow <para>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-put-follow.html</para></summary>
+		///<param name="index">The name of the follower index</param>
+		///<param name="body">The name of the leader index and other optional ccr related parameters</param>
+		///<param name="requestParameters">A func that allows you to describe the querystring parameters &amp; request specific connection settings.</param>
+		TResponse CcrFollow<TResponse>(string index, PostData body, CreateFollowIndexRequestParameters requestParameters = null) where TResponse : class, IElasticsearchResponse, new();
+		///<summary>PUT on /{index}/_ccr/follow <para>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-put-follow.html</para></summary>
+		///<param name="index">The name of the follower index</param>
+		///<param name="body">The name of the leader index and other optional ccr related parameters</param>
+		///<param name="requestParameters">A func that allows you to describe the querystring parameters &amp; request specific connection settings.</param>
+		Task<TResponse> CcrFollowAsync<TResponse>(string index, PostData body, CreateFollowIndexRequestParameters requestParameters = null, CancellationToken ctx = default(CancellationToken)) where TResponse : class, IElasticsearchResponse, new();
+		///<summary>GET on /{index}/_ccr/stats <para>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-get-follow-stats.html</para></summary>
+		///<param name="index">A comma-separated list of index patterns; use `_all` to perform the operation on all indices</param>
+		///<param name="requestParameters">A func that allows you to describe the querystring parameters &amp; request specific connection settings.</param>
+		TResponse CcrFollowStats<TResponse>(string index, FollowIndexStatsRequestParameters requestParameters = null) where TResponse : class, IElasticsearchResponse, new();
+		///<summary>GET on /{index}/_ccr/stats <para>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-get-follow-stats.html</para></summary>
+		///<param name="index">A comma-separated list of index patterns; use `_all` to perform the operation on all indices</param>
+		///<param name="requestParameters">A func that allows you to describe the querystring parameters &amp; request specific connection settings.</param>
+		Task<TResponse> CcrFollowStatsAsync<TResponse>(string index, FollowIndexStatsRequestParameters requestParameters = null, CancellationToken ctx = default(CancellationToken)) where TResponse : class, IElasticsearchResponse, new();
+		///<summary>GET on /_ccr/auto_follow <para>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-get-auto-follow-pattern.html</para></summary>
+		///<param name="requestParameters">A func that allows you to describe the querystring parameters &amp; request specific connection settings.</param>
+		TResponse CcrGetAutoFollowPattern<TResponse>(GetAutoFollowPatternRequestParameters requestParameters = null) where TResponse : class, IElasticsearchResponse, new();
+		///<summary>GET on /_ccr/auto_follow <para>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-get-auto-follow-pattern.html</para></summary>
+		///<param name="requestParameters">A func that allows you to describe the querystring parameters &amp; request specific connection settings.</param>
+		Task<TResponse> CcrGetAutoFollowPatternAsync<TResponse>(GetAutoFollowPatternRequestParameters requestParameters = null, CancellationToken ctx = default(CancellationToken)) where TResponse : class, IElasticsearchResponse, new();
+		///<summary>GET on /_ccr/auto_follow/{name} <para>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-get-auto-follow-pattern.html</para></summary>
+		///<param name="name">The name of the auto follow pattern.</param>
+		///<param name="requestParameters">A func that allows you to describe the querystring parameters &amp; request specific connection settings.</param>
+		TResponse CcrGetAutoFollowPattern<TResponse>(string name, GetAutoFollowPatternRequestParameters requestParameters = null) where TResponse : class, IElasticsearchResponse, new();
+		///<summary>GET on /_ccr/auto_follow/{name} <para>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-get-auto-follow-pattern.html</para></summary>
+		///<param name="name">The name of the auto follow pattern.</param>
+		///<param name="requestParameters">A func that allows you to describe the querystring parameters &amp; request specific connection settings.</param>
+		Task<TResponse> CcrGetAutoFollowPatternAsync<TResponse>(string name, GetAutoFollowPatternRequestParameters requestParameters = null, CancellationToken ctx = default(CancellationToken)) where TResponse : class, IElasticsearchResponse, new();
+		///<summary>POST on /{index}/_ccr/pause_follow <para>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-post-pause-follow.html</para></summary>
+		///<param name="index">The name of the follower index that should pause following its leader index.</param>
+		///<param name="requestParameters">A func that allows you to describe the querystring parameters &amp; request specific connection settings.</param>
+		TResponse CcrPauseFollow<TResponse>(string index, PauseFollowIndexRequestParameters requestParameters = null) where TResponse : class, IElasticsearchResponse, new();
+		///<summary>POST on /{index}/_ccr/pause_follow <para>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-post-pause-follow.html</para></summary>
+		///<param name="index">The name of the follower index that should pause following its leader index.</param>
+		///<param name="requestParameters">A func that allows you to describe the querystring parameters &amp; request specific connection settings.</param>
+		Task<TResponse> CcrPauseFollowAsync<TResponse>(string index, PauseFollowIndexRequestParameters requestParameters = null, CancellationToken ctx = default(CancellationToken)) where TResponse : class, IElasticsearchResponse, new();
+		///<summary>PUT on /_ccr/auto_follow/{name} <para>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-put-auto-follow-pattern.html</para></summary>
+		///<param name="name">The name of the auto follow pattern.</param>
+		///<param name="body">The specification of the auto follow pattern</param>
+		///<param name="requestParameters">A func that allows you to describe the querystring parameters &amp; request specific connection settings.</param>
+		TResponse CcrPutAutoFollowPattern<TResponse>(string name, PostData body, CreateAutoFollowPatternRequestParameters requestParameters = null) where TResponse : class, IElasticsearchResponse, new();
+		///<summary>PUT on /_ccr/auto_follow/{name} <para>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-put-auto-follow-pattern.html</para></summary>
+		///<param name="name">The name of the auto follow pattern.</param>
+		///<param name="body">The specification of the auto follow pattern</param>
+		///<param name="requestParameters">A func that allows you to describe the querystring parameters &amp; request specific connection settings.</param>
+		Task<TResponse> CcrPutAutoFollowPatternAsync<TResponse>(string name, PostData body, CreateAutoFollowPatternRequestParameters requestParameters = null, CancellationToken ctx = default(CancellationToken)) where TResponse : class, IElasticsearchResponse, new();
+		///<summary>POST on /{index}/_ccr/resume_follow <para>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-post-resume-follow.html</para></summary>
+		///<param name="index">The name of the follow index to resume following.</param>
+		///<param name="body">The name of the leader index and other optional ccr related parameters</param>
+		///<param name="requestParameters">A func that allows you to describe the querystring parameters &amp; request specific connection settings.</param>
+		TResponse CcrResumeFollow<TResponse>(string index, PostData body, ResumeFollowIndexRequestParameters requestParameters = null) where TResponse : class, IElasticsearchResponse, new();
+		///<summary>POST on /{index}/_ccr/resume_follow <para>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-post-resume-follow.html</para></summary>
+		///<param name="index">The name of the follow index to resume following.</param>
+		///<param name="body">The name of the leader index and other optional ccr related parameters</param>
+		///<param name="requestParameters">A func that allows you to describe the querystring parameters &amp; request specific connection settings.</param>
+		Task<TResponse> CcrResumeFollowAsync<TResponse>(string index, PostData body, ResumeFollowIndexRequestParameters requestParameters = null, CancellationToken ctx = default(CancellationToken)) where TResponse : class, IElasticsearchResponse, new();
+		///<summary>GET on /_ccr/stats <para>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-get-stats.html</para></summary>
+		///<param name="requestParameters">A func that allows you to describe the querystring parameters &amp; request specific connection settings.</param>
+		TResponse CcrStats<TResponse>(CcrStatsRequestParameters requestParameters = null) where TResponse : class, IElasticsearchResponse, new();
+		///<summary>GET on /_ccr/stats <para>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-get-stats.html</para></summary>
+		///<param name="requestParameters">A func that allows you to describe the querystring parameters &amp; request specific connection settings.</param>
+		Task<TResponse> CcrStatsAsync<TResponse>(CcrStatsRequestParameters requestParameters = null, CancellationToken ctx = default(CancellationToken)) where TResponse : class, IElasticsearchResponse, new();
+		///<summary>POST on /{index}/_ccr/unfollow <para>http://www.elastic.co/guide/en/elasticsearch/reference/current</para></summary>
+		///<param name="index">The name of the follower index that should be turned into a regular index.</param>
+		///<param name="requestParameters">A func that allows you to describe the querystring parameters &amp; request specific connection settings.</param>
+		TResponse CcrUnfollow<TResponse>(string index, UnfollowIndexRequestParameters requestParameters = null) where TResponse : class, IElasticsearchResponse, new();
+		///<summary>POST on /{index}/_ccr/unfollow <para>http://www.elastic.co/guide/en/elasticsearch/reference/current</para></summary>
+		///<param name="index">The name of the follower index that should be turned into a regular index.</param>
+		///<param name="requestParameters">A func that allows you to describe the querystring parameters &amp; request specific connection settings.</param>
+		Task<TResponse> CcrUnfollowAsync<TResponse>(string index, UnfollowIndexRequestParameters requestParameters = null, CancellationToken ctx = default(CancellationToken)) where TResponse : class, IElasticsearchResponse, new();
 		///<summary>GET on /{index}/_xpack/graph/_explore <para>https://www.elastic.co/guide/en/elasticsearch/reference/current/graph-explore-api.html</para></summary>
 		///<param name="index">A comma-separated list of index names to search; use the special string `_all` or Indices.All to perform the operation on all indices</param>
 		///<param name="requestParameters">A func that allows you to describe the querystring parameters &amp; request specific connection settings.</param>
diff --git a/src/Nest/Cluster/ClusterSettings/ClusterPutSettings/RemoteClusterConfiguration.cs b/src/Nest/Cluster/ClusterSettings/ClusterPutSettings/RemoteClusterConfiguration.cs
new file mode 100644
index 00000000000..63b7af0e9f6
--- /dev/null
+++ b/src/Nest/Cluster/ClusterSettings/ClusterPutSettings/RemoteClusterConfiguration.cs
@@ -0,0 +1,43 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Nest
+{
+	/// <summary>
+	/// Simplifies the creation of remote cluster configuration, can be combined with a dictionary using the overloaded + operator
+	/// </summary>
+	public class RemoteClusterConfiguration : IsADictionaryBase<string, object>
+	{
+		private readonly Dictionary<string, object> _remoteDictionary =
+			new Dictionary<string, object>();
+
+		public RemoteClusterConfiguration() =>
+			BackingDictionary["cluster"] = new Dictionary<string, object>()
+			{
+				{ "remote", _remoteDictionary }
+			};
+
+		public void Add(string name, params Uri[] seeds) =>
+			Add(name, seeds.Select(u => $"{u.Host}:{u.Port}").ToArray());
+
+		public void Add(string name, params string[] seeds) =>
+			_remoteDictionary[name] = new Dictionary<string, object>()
+			{
+				{ "seeds", seeds }
+			};
+
+		public static Dictionary<string, object> operator +(RemoteClusterConfiguration left, IDictionary<string, object> right) => Combine(left, right);
+		public static Dictionary<string, object> operator +(IDictionary<string, object> left, RemoteClusterConfiguration right) => Combine(left, right);
+
+		private static Dictionary<string, object> Combine(IDictionary<string, object> left, IDictionary<string, object> right)
+		{
+			if (left == null && right == null) return null;
+			if (left == null) return new Dictionary<string, object>(right);
+			if (right == null) return new Dictionary<string, object>(left);
+
+			foreach (var kv in right) left[kv.Key] = kv.Value;
+			return new Dictionary<string, object>(left);
+		}
+	}
+}
diff --git a/src/Nest/IndexModules/IndexSettings/Settings/IndexSettings.cs b/src/Nest/IndexModules/IndexSettings/Settings/IndexSettings.cs
index 81e95bb0091..6b3e22ab8f6 100644
--- a/src/Nest/IndexModules/IndexSettings/Settings/IndexSettings.cs
+++ b/src/Nest/IndexModules/IndexSettings/Settings/IndexSettings.cs
@@ -28,9 +28,7 @@ public interface IIndexSettings : IDynamicIndexSettings
 		/// </summary>
 		int? NumberOfShards { get; set; }
 
-		/// <summary>
-		/// Settings associated with queries.
-		/// </summary>
+		/// <summary> Settings associated with queries. </summary>
 		IQueriesSettings Queries { get; set; }
 
 		/// <summary>
@@ -45,7 +43,8 @@ public interface IIndexSettings : IDynamicIndexSettings
 		/// </summary>
 		ISortingSettings Sorting { get; set; }
 
-
+		/// <summary> Soft delete settings for the index </summary>
+		ISoftDeleteSettings SoftDeletes { get; set; }
 	}
 
 	/// <inheritdoc cref="IIndexSettings" />
@@ -72,6 +71,9 @@ public IndexSettings(IDictionary<string, object> container) : base(container) {
 
 		/// <inheritdoc cref="IIndexSettings.Sorting" />
 		public ISortingSettings Sorting { get; set; }
+
+		/// <inheritdoc />
+		public ISoftDeleteSettings SoftDeletes { get; set; }
 	}
 
 	/// <inheritdoc cref="IIndexSettings" />
@@ -102,5 +104,9 @@ public IndexSettingsDescriptor Queries(Func<QueriesSettingsDescriptor, IQueriesS
 		/// <inheritdoc cref="IIndexSettings.Sorting" />
 		public IndexSettingsDescriptor Sorting<T>(Func<SortingSettingsDescriptor<T>, ISortingSettings> selector) where T : class =>
 			Assign(a => a.Sorting = selector?.Invoke(new SortingSettingsDescriptor<T>()));
+
+		/// <inheritdoc cref="IIndexSettings.SoftDeletes" />
+		public IndexSettingsDescriptor SoftDeletes(Func<SoftDeleteSettingsDescriptor, ISoftDeleteSettings> selector) =>
+			Assign(a => a.SoftDeletes = selector?.Invoke(new SoftDeleteSettingsDescriptor()));
 	}
 }
diff --git a/src/Nest/IndexModules/IndexSettings/Settings/IndexSettingsConverter.cs b/src/Nest/IndexModules/IndexSettings/Settings/IndexSettingsConverter.cs
index 6d6b94dd38f..296cb161e3f 100644
--- a/src/Nest/IndexModules/IndexSettings/Settings/IndexSettingsConverter.cs
+++ b/src/Nest/IndexModules/IndexSettings/Settings/IndexSettingsConverter.cs
@@ -97,6 +97,11 @@ void Set(string knownKey, object newValue)
 			Set(NumberOfShards, indexSettings?.NumberOfShards);
 			Set(NumberOfRoutingShards, indexSettings?.NumberOfRoutingShards);
 			Set(RoutingPartitionSize, indexSettings?.RoutingPartitionSize);
+			if (indexSettings?.SoftDeletes != null)
+			{
+				Set(SoftDeletesEnabled, indexSettings?.SoftDeletes?.Enabled);
+				Set(SoftDeletesRetentionOperations, indexSettings?.SoftDeletes?.Retention?.Operations);
+			}
 
 			if (indexSettings?.Sorting != null)
 			{
@@ -208,14 +213,10 @@ private static void SetKnownIndexSettings(JsonReader reader, JsonSerializer seri
 				v => fetch.ThresholdTrace = v);
 
 			var indexing = s.SlowLog.Indexing = new SlowLogIndexing();
-			Set<Time>(s, settings, SlowlogIndexingThresholdFetchWarn,
-				v => indexing.ThresholdWarn = v);
-			Set<Time>(s, settings, SlowlogIndexingThresholdFetchInfo,
-				v => indexing.ThresholdInfo = v);
-			Set<Time>(s, settings, SlowlogIndexingThresholdFetchDebug,
-				v => indexing.ThresholdDebug = v);
-			Set<Time>(s, settings, SlowlogIndexingThresholdFetchTrace,
-				v => indexing.ThresholdTrace = v);
+			Set<Time>(s, settings, SlowlogIndexingThresholdFetchWarn, v => indexing.ThresholdWarn = v);
+			Set<Time>(s, settings, SlowlogIndexingThresholdFetchInfo, v => indexing.ThresholdInfo = v);
+			Set<Time>(s, settings, SlowlogIndexingThresholdFetchDebug, v => indexing.ThresholdDebug = v);
+			Set<Time>(s, settings, SlowlogIndexingThresholdFetchTrace, v => indexing.ThresholdTrace = v);
 			Set<LogLevel?>(s, settings, SlowlogIndexingLevel, v => indexing.LogLevel = v);
 			Set<int?>(s, settings, SlowlogIndexingSource, v => indexing.Source = v);
 			Set<int?>(s, settings, NumberOfShards, v => s.NumberOfShards = v);
@@ -233,6 +234,11 @@ private static void SetKnownIndexSettings(JsonReader reader, JsonSerializer seri
 			var queriesCache = s.Queries.Cache = new QueriesCacheSettings();
 			Set<bool?>(s, settings, QueriesCacheEnabled, v => queriesCache.Enabled = v);
 
+			var softDeletes = s.SoftDeletes = new SoftDeleteSettings();
+			Set<bool?>(s, settings, SoftDeletesEnabled, v => softDeletes.Enabled = v);
+			var softDeletesRetention = s.SoftDeletes.Retention = new SoftDeleteRetentionSettings();
+			Set<long?>(s, settings, SoftDeletesEnabled, v => softDeletesRetention.Operations = v);
+
 			IDictionary<string, object> dict = s;
 			foreach (var kv in settings)
 			{
diff --git a/src/Nest/IndexModules/IndexSettings/Settings/UpdatableIndexSettings.cs b/src/Nest/IndexModules/IndexSettings/Settings/UpdatableIndexSettings.cs
index 87c66c40d8b..2170daa5f1b 100644
--- a/src/Nest/IndexModules/IndexSettings/Settings/UpdatableIndexSettings.cs
+++ b/src/Nest/IndexModules/IndexSettings/Settings/UpdatableIndexSettings.cs
@@ -30,6 +30,9 @@ public static class UpdatableIndexSettings
 
 		public const string QueriesCacheEnabled = "index.queries.cache.enabled";
 
+		public const string SoftDeletesEnabled = "index.soft_deletes.enabled";
+		public const string SoftDeletesRetentionOperations = "index.soft_deletes.retention.operations";
+
 		public const string RecoveryInitialShards = "index.recovery.initial_shards";
 		public const string RefreshInterval = "index.refresh_interval";
 
diff --git a/src/Nest/IndexModules/IndexSettings/SoftDeletes/ISoftDeleteRetentionSettings.cs b/src/Nest/IndexModules/IndexSettings/SoftDeletes/ISoftDeleteRetentionSettings.cs
new file mode 100644
index 00000000000..d7a1a815e88
--- /dev/null
+++ b/src/Nest/IndexModules/IndexSettings/SoftDeletes/ISoftDeleteRetentionSettings.cs
@@ -0,0 +1,22 @@
+namespace Nest
+{
+	public interface ISoftDeleteRetentionSettings
+	{
+		/// <summary> How many operations should be retained </summary>
+		long? Operations { get; set; }
+	}
+
+	public class SoftDeleteRetentionSettings : ISoftDeleteRetentionSettings
+	{
+		/// <inheritdoc see cref="ISoftDeleteRetentionSettings.Operations"/>
+		public long? Operations { get; set; }
+	}
+
+	public class SoftDeleteRetentionSettingsDescriptor : DescriptorBase<SoftDeleteRetentionSettingsDescriptor, ISoftDeleteRetentionSettings>, ISoftDeleteRetentionSettings
+	{
+		long? ISoftDeleteRetentionSettings.Operations { get; set; }
+
+		/// <inheritdoc see cref="ISoftDeleteRetentionSettings.Operations"/>
+		public SoftDeleteRetentionSettingsDescriptor Operations(long? operations) => Assign(a => a.Operations = operations);
+	}
+}
diff --git a/src/Nest/IndexModules/IndexSettings/SoftDeletes/ISoftDeleteSettings.cs b/src/Nest/IndexModules/IndexSettings/SoftDeletes/ISoftDeleteSettings.cs
new file mode 100644
index 00000000000..6bf680a4335
--- /dev/null
+++ b/src/Nest/IndexModules/IndexSettings/SoftDeletes/ISoftDeleteSettings.cs
@@ -0,0 +1,34 @@
+using System;
+
+namespace Nest
+{
+	public interface ISoftDeleteSettings
+	{
+		/// <summary> Enables soft deletes on the index</summary>
+		bool? Enabled { get; set; }
+		/// <summary> Configure the retention of soft deletes on the index</summary>
+		ISoftDeleteRetentionSettings Retention { get; set; }
+	}
+
+	public class SoftDeleteSettings : ISoftDeleteSettings
+	{
+		/// <inheritdoc see cref="ISoftDeleteSettings.Retention"/>
+		public ISoftDeleteRetentionSettings Retention { get; set; }
+
+		/// <inheritdoc see cref="ISoftDeleteSettings.Enabled"/>
+		public bool? Enabled { get; set; }
+	}
+
+	public class SoftDeleteSettingsDescriptor : DescriptorBase<SoftDeleteSettingsDescriptor, ISoftDeleteSettings>, ISoftDeleteSettings
+	{
+		bool? ISoftDeleteSettings.Enabled { get; set; }
+		ISoftDeleteRetentionSettings ISoftDeleteSettings.Retention { get; set; }
+
+		/// <inheritdoc see cref="ISoftDeleteSettings.Retention"/>
+		public SoftDeleteSettingsDescriptor Retention(Func<SoftDeleteRetentionSettingsDescriptor, ISoftDeleteRetentionSettings> selector) =>
+			Assign(a => a.Retention = selector.Invoke(new SoftDeleteRetentionSettingsDescriptor()));
+
+		/// <inheritdoc see cref="ISoftDeleteSettings.Enabled"/>
+		public SoftDeleteSettingsDescriptor Enabled(bool? enabled = true) => Assign(a => a.Enabled = enabled);
+	}
+}
diff --git a/src/Nest/XPack/CrossClusterReplication/AutoFollow/CreateAutoFollowPattern/CreateAutoFollowPatternRequest.cs b/src/Nest/XPack/CrossClusterReplication/AutoFollow/CreateAutoFollowPattern/CreateAutoFollowPatternRequest.cs
new file mode 100644
index 00000000000..c8f1c91b3da
--- /dev/null
+++ b/src/Nest/XPack/CrossClusterReplication/AutoFollow/CreateAutoFollowPattern/CreateAutoFollowPatternRequest.cs
@@ -0,0 +1,116 @@
+using System.Collections.Generic;
+using Newtonsoft.Json;
+
+namespace Nest
+{
+	/// <summary>
+	/// Creates a new named collection of auto-follow patterns against the remote cluster specified
+	/// in the request body. Newly created indices on the remote cluster matching any of the specified patterns
+	/// will be automatically configured as follower indices.
+	/// </summary>
+	[MapsApi("ccr.put_auto_follow_pattern.json")]
+	[ContractJsonConverter(typeof(ReadAsTypeJsonConverter<CreateAutoFollowPatternRequest>))]
+	public partial interface ICreateAutoFollowPatternRequest : IAutoFollowPattern { }
+
+	/// <inheritdoc cref="ICreateAutoFollowPatternRequest"/>
+	public partial class CreateAutoFollowPatternRequest
+	{
+		/// <inheritdoc cref="IAutoFollowPattern.RemoteCluster"/>
+		public string RemoteCluster { get; set; }
+		/// <inheritdoc cref="IAutoFollowPattern.LeaderIndexPatterns"/>
+		public IEnumerable<string> LeaderIndexPatterns { get; set; }
+		/// <inheritdoc cref="IAutoFollowPattern.FollowIndexPattern"/>
+		public string FollowIndexPattern { get; set; }
+		/// <inheritdoc cref="IAutoFollowPattern.MaxReadRequestOperationCount"/>
+		public int? MaxReadRequestOperationCount { get; set; }
+		/// <inheritdoc cref="IAutoFollowPattern.MaxOutstandingReadRequests"/>
+		public long? MaxOutstandingReadRequests { get; set; }
+		/// <inheritdoc cref="IAutoFollowPattern.MaxReadRequestSize"/>
+		public string MaxReadRequestSize { get; set; }
+		/// <inheritdoc cref="IAutoFollowPattern.MaxWriteRequestOperationCount"/>
+		public int? MaxWriteRequestOperationCount { get; set; }
+		/// <inheritdoc cref="IAutoFollowPattern.MaxWriteRequestSize"/>
+		public string MaxWriteRequestSize { get; set; }
+		/// <inheritdoc cref="IAutoFollowPattern.MaxOutstandingWriteRequests"/>
+		public int? MaxOutstandingWriteRequests { get; set; }
+		/// <inheritdoc cref="IAutoFollowPattern.MaxWriteBufferCount"/>
+		public int? MaxWriteBufferCount { get; set; }
+		/// <inheritdoc cref="IAutoFollowPattern.MaxWriteBufferSize"/>
+		public string MaxWriteBufferSize { get; set; }
+		/// <inheritdoc cref="IAutoFollowPattern.MaxRetryDelay"/>
+		public Time MaxRetryDelay { get; set; }
+		/// <inheritdoc cref="IAutoFollowPattern.MaxPollTimeout"/>
+		public Time MaxPollTimeout { get; set; }
+	}
+
+	/// <inheritdoc cref="ICreateAutoFollowPatternRequest"/>
+	public partial class CreateAutoFollowPatternDescriptor
+	{
+		string IAutoFollowPattern.RemoteCluster { get; set; }
+		IEnumerable<string> IAutoFollowPattern.LeaderIndexPatterns { get; set; }
+		string IAutoFollowPattern.FollowIndexPattern { get; set; }
+		int? IAutoFollowPattern.MaxReadRequestOperationCount { get; set; }
+		long? IAutoFollowPattern.MaxOutstandingReadRequests { get; set; }
+		string IAutoFollowPattern.MaxReadRequestSize { get; set; }
+		int? IAutoFollowPattern.MaxWriteRequestOperationCount { get; set; }
+		string IAutoFollowPattern.MaxWriteRequestSize { get; set; }
+		int? IAutoFollowPattern.MaxOutstandingWriteRequests { get; set; }
+		int? IAutoFollowPattern.MaxWriteBufferCount { get; set; }
+		string IAutoFollowPattern.MaxWriteBufferSize { get; set; }
+		Time IAutoFollowPattern.MaxRetryDelay { get; set; }
+		Time IAutoFollowPattern.MaxPollTimeout { get; set; }
+
+		/// <inheritdoc cref="IAutoFollowPattern.RemoteCluster"/>
+		public CreateAutoFollowPatternDescriptor RemoteCluster(string remoteCluster) => Assign(a => a.RemoteCluster = remoteCluster);
+
+		/// <inheritdoc cref="IAutoFollowPattern.LeaderIndexPatterns"/>
+		public CreateAutoFollowPatternDescriptor LeaderIndexPatterns(IEnumerable<string> leaderIndexPatterns) =>
+			Assign(a => a.LeaderIndexPatterns = leaderIndexPatterns);
+
+		/// <inheritdoc cref="IAutoFollowPattern.LeaderIndexPatterns"/>
+		public CreateAutoFollowPatternDescriptor LeaderIndexPatterns(params string[] leaderIndexPatterns) =>
+			Assign(a => a.LeaderIndexPatterns = leaderIndexPatterns);
+
+		/// <inheritdoc cref="IAutoFollowPattern.FollowIndexPattern"/>
+		public CreateAutoFollowPatternDescriptor FollowIndexPattern(string followIndexPattern) =>
+			Assign(a => a.FollowIndexPattern = followIndexPattern);
+
+		/// <inheritdoc cref="IAutoFollowPattern.MaxReadRequestOperationCount"/>
+		public CreateAutoFollowPatternDescriptor MaxReadRequestOperationCount(int? maxReadRequestOperationCount) =>
+			Assign(a => a.MaxReadRequestOperationCount = maxReadRequestOperationCount);
+
+		/// <inheritdoc cref="IAutoFollowPattern.MaxOutstandingReadRequests"/>
+		public CreateAutoFollowPatternDescriptor MaxOutstandingReadRequests(long? maxOutstandingReadRequests) =>
+			Assign(a => a.MaxOutstandingReadRequests = maxOutstandingReadRequests);
+
+		/// <inheritdoc cref="IAutoFollowPattern.MaxReadRequestSize"/>
+		public CreateAutoFollowPatternDescriptor MaxReadRequestSize(string maxReadRequestSize) =>
+			Assign(a => a.MaxReadRequestSize = maxReadRequestSize);
+
+		/// <inheritdoc cref="IAutoFollowPattern.MaxWriteRequestOperationCount"/>
+		public CreateAutoFollowPatternDescriptor MaxWriteRequestOperationCount(int? maxWriteRequestOperationCount) =>
+			Assign(a => a.MaxWriteRequestOperationCount = maxWriteRequestOperationCount);
+
+		/// <inheritdoc cref="IAutoFollowPattern.MaxWriteRequestSize"/>
+		public CreateAutoFollowPatternDescriptor MaxWriteRequestSize(string maxWriteRequestSize) =>
+			Assign(a => a.MaxWriteRequestSize = maxWriteRequestSize);
+
+		/// <inheritdoc cref="IAutoFollowPattern.MaxOutstandingWriteRequests"/>
+		public CreateAutoFollowPatternDescriptor MaxOutstandingWriteRequests(int? maxOutstandingWriteRequests) =>
+			Assign(a => a.MaxOutstandingWriteRequests = maxOutstandingWriteRequests);
+
+		/// <inheritdoc cref="IAutoFollowPattern.MaxWriteBufferCount"/>
+		public CreateAutoFollowPatternDescriptor MaxWriteBufferCount(int? maxWriteBufferCount) =>
+			Assign(a => a.MaxWriteBufferCount = maxWriteBufferCount);
+
+		/// <inheritdoc cref="IAutoFollowPattern.MaxWriteBufferSize"/>
+		public CreateAutoFollowPatternDescriptor MaxWriteBufferSize(string maxWriteBufferSize) =>
+			Assign(a => a.MaxWriteBufferSize = maxWriteBufferSize);
+
+		/// <inheritdoc cref="IAutoFollowPattern.MaxRetryDelay"/>
+		public CreateAutoFollowPatternDescriptor MaxRetryDelay(Time maxRetryDelay) => Assign(a => a.MaxRetryDelay = maxRetryDelay);
+
+		/// <inheritdoc cref="IAutoFollowPattern.MaxPollTimeout"/>
+		public CreateAutoFollowPatternDescriptor MaxPollTimeout(Time maxPollTimeout) => Assign(a => a.MaxPollTimeout = maxPollTimeout);
+	}
+}
diff --git a/src/Nest/XPack/CrossClusterReplication/AutoFollow/CreateAutoFollowPattern/CreateAutoFollowPatternResponse.cs b/src/Nest/XPack/CrossClusterReplication/AutoFollow/CreateAutoFollowPattern/CreateAutoFollowPatternResponse.cs
new file mode 100644
index 00000000000..4910509f917
--- /dev/null
+++ b/src/Nest/XPack/CrossClusterReplication/AutoFollow/CreateAutoFollowPattern/CreateAutoFollowPatternResponse.cs
@@ -0,0 +1,6 @@
+namespace Nest
+{
+	public interface ICreateAutoFollowPatternResponse : IAcknowledgedResponse { }
+
+	public class CreateAutoFollowPatternResponse : AcknowledgedResponseBase, ICreateAutoFollowPatternResponse { }
+}
diff --git a/src/Nest/XPack/CrossClusterReplication/AutoFollow/CreateAutoFollowPattern/ElasticClient-CreateAutoFollowPattern.cs b/src/Nest/XPack/CrossClusterReplication/AutoFollow/CreateAutoFollowPattern/ElasticClient-CreateAutoFollowPattern.cs
new file mode 100644
index 00000000000..1be338e16ac
--- /dev/null
+++ b/src/Nest/XPack/CrossClusterReplication/AutoFollow/CreateAutoFollowPattern/ElasticClient-CreateAutoFollowPattern.cs
@@ -0,0 +1,56 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using Elasticsearch.Net;
+
+namespace Nest
+{
+	public partial interface IElasticClient
+	{
+		/// <summary>
+		/// Creates a new named collection of auto-follow patterns against the remote cluster specified
+		/// in the request body. Newly created indices on the remote cluster matching any of the specified patterns
+		/// will be automatically configured as follower indices.
+		/// </summary>
+		ICreateAutoFollowPatternResponse CreateAutoFollowPattern(Name name, Func<CreateAutoFollowPatternDescriptor, ICreateAutoFollowPatternRequest> selector);
+
+		/// <inheritdoc cref="CreateAutoFollowPattern(Name, System.Func{Nest.CreateAutoFollowPatternDescriptor,Nest.ICreateAutoFollowPatternRequest})" />
+		ICreateAutoFollowPatternResponse CreateAutoFollowPattern(ICreateAutoFollowPatternRequest request);
+
+		/// <inheritdoc cref="CreateAutoFollowPattern(Name, System.Func{Nest.CreateAutoFollowPatternDescriptor,Nest.ICreateAutoFollowPatternRequest})" />
+		Task<ICreateAutoFollowPatternResponse> CreateAutoFollowPatternAsync(Name name, Func<CreateAutoFollowPatternDescriptor, ICreateAutoFollowPatternRequest> selector,
+			CancellationToken cancellationToken = default(CancellationToken)
+		);
+
+		/// <inheritdoc cref="CreateAutoFollowPattern(Name, System.Func{Nest.CreateAutoFollowPatternDescriptor,Nest.ICreateAutoFollowPatternRequest})" />
+		Task<ICreateAutoFollowPatternResponse> CreateAutoFollowPatternAsync(ICreateAutoFollowPatternRequest request, CancellationToken cancellationToken = default);
+	}
+
+	public partial class ElasticClient
+	{
+		/// <inheritdoc cref="CreateAutoFollowPattern(Name, System.Func{Nest.CreateAutoFollowPatternDescriptor,Nest.ICreateAutoFollowPatternRequest})" />
+		public ICreateAutoFollowPatternResponse CreateAutoFollowPattern(Name name, Func<CreateAutoFollowPatternDescriptor, ICreateAutoFollowPatternRequest> selector) =>
+			CreateAutoFollowPattern(selector.InvokeOrDefault(new CreateAutoFollowPatternDescriptor(name)));
+
+		/// <inheritdoc cref="CreateAutoFollowPattern(Name, System.Func{Nest.CreateAutoFollowPatternDescriptor,Nest.ICreateAutoFollowPatternRequest})" />
+		public ICreateAutoFollowPatternResponse CreateAutoFollowPattern(ICreateAutoFollowPatternRequest request) =>
+			Dispatcher.Dispatch<ICreateAutoFollowPatternRequest, CreateAutoFollowPatternRequestParameters, CreateAutoFollowPatternResponse>(
+				request,
+				(p, d) => LowLevelDispatch.CcrPutAutoFollowPatternDispatch<CreateAutoFollowPatternResponse>(p, d)
+			);
+
+		/// <inheritdoc cref="CreateAutoFollowPattern(Name, System.Func{Nest.CreateAutoFollowPatternDescriptor,Nest.ICreateAutoFollowPatternRequest})" />
+		public Task<ICreateAutoFollowPatternResponse> CreateAutoFollowPatternAsync(Name name, Func<CreateAutoFollowPatternDescriptor, ICreateAutoFollowPatternRequest> selector,
+			CancellationToken cancellationToken = default(CancellationToken)
+		) =>
+			CreateAutoFollowPatternAsync(selector.InvokeOrDefault(new CreateAutoFollowPatternDescriptor(name)), cancellationToken);
+
+		/// <inheritdoc cref="CreateAutoFollowPattern(Name, System.Func{Nest.CreateAutoFollowPatternDescriptor,Nest.ICreateAutoFollowPatternRequest})" />
+		public Task<ICreateAutoFollowPatternResponse> CreateAutoFollowPatternAsync(ICreateAutoFollowPatternRequest request, CancellationToken cancellationToken = default) =>
+			Dispatcher.DispatchAsync<ICreateAutoFollowPatternRequest, CreateAutoFollowPatternRequestParameters, CreateAutoFollowPatternResponse, ICreateAutoFollowPatternResponse>(
+				request,
+				cancellationToken,
+				(p, d, c) => LowLevelDispatch.CcrPutAutoFollowPatternDispatchAsync<CreateAutoFollowPatternResponse>(p, d, c)
+			);
+	}
+}
diff --git a/src/Nest/XPack/CrossClusterReplication/AutoFollow/DeleteAutoFollowPattern/DeleteAutoFollowPatternRequest.cs b/src/Nest/XPack/CrossClusterReplication/AutoFollow/DeleteAutoFollowPattern/DeleteAutoFollowPatternRequest.cs
new file mode 100644
index 00000000000..5f833830774
--- /dev/null
+++ b/src/Nest/XPack/CrossClusterReplication/AutoFollow/DeleteAutoFollowPattern/DeleteAutoFollowPatternRequest.cs
@@ -0,0 +1,16 @@
+using System;
+using Newtonsoft.Json;
+
+namespace Nest
+{
+	/// <summary> Deletes a configured collection of auto-follow patterns. </summary>
+	[MapsApi("ccr.delete_auto_follow_pattern.json")]
+	[ContractJsonConverter(typeof(ReadAsTypeJsonConverter<DeleteAutoFollowPatternRequest>))]
+	public partial interface IDeleteAutoFollowPatternRequest { }
+
+	/// <inheritdoc cref="IDeleteAutoFollowPatternRequest"/>
+	public partial class DeleteAutoFollowPatternRequest { }
+
+	/// <inheritdoc cref="IDeleteAutoFollowPatternRequest"/>
+	public partial class DeleteAutoFollowPatternDescriptor { }
+}
diff --git a/src/Nest/XPack/CrossClusterReplication/AutoFollow/DeleteAutoFollowPattern/DeleteAutoFollowPatternResponse.cs b/src/Nest/XPack/CrossClusterReplication/AutoFollow/DeleteAutoFollowPattern/DeleteAutoFollowPatternResponse.cs
new file mode 100644
index 00000000000..e0ddadac11e
--- /dev/null
+++ b/src/Nest/XPack/CrossClusterReplication/AutoFollow/DeleteAutoFollowPattern/DeleteAutoFollowPatternResponse.cs
@@ -0,0 +1,6 @@
+namespace Nest
+{
+	public interface IDeleteAutoFollowPatternResponse : IAcknowledgedResponse { }
+
+	public class DeleteAutoFollowPatternResponse : AcknowledgedResponseBase, IDeleteAutoFollowPatternResponse { }
+}
diff --git a/src/Nest/XPack/CrossClusterReplication/AutoFollow/DeleteAutoFollowPattern/ElasticClient-DeleteAutoFollowPattern.cs b/src/Nest/XPack/CrossClusterReplication/AutoFollow/DeleteAutoFollowPattern/ElasticClient-DeleteAutoFollowPattern.cs
new file mode 100644
index 00000000000..ca3d5ed5567
--- /dev/null
+++ b/src/Nest/XPack/CrossClusterReplication/AutoFollow/DeleteAutoFollowPattern/ElasticClient-DeleteAutoFollowPattern.cs
@@ -0,0 +1,52 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using Elasticsearch.Net;
+
+namespace Nest
+{
+	public partial interface IElasticClient
+	{
+		/// <summary>Deletes a configured collection of auto-follow patterns.</summary>
+		IDeleteAutoFollowPatternResponse DeleteAutoFollowPattern(Name name, Func<DeleteAutoFollowPatternDescriptor, IDeleteAutoFollowPatternRequest> selector = null);
+
+		/// <inheritdoc cref="DeleteAutoFollowPattern(Name,System.Func{Nest.DeleteAutoFollowPatternDescriptor,Nest.IDeleteAutoFollowPatternRequest})" />
+		IDeleteAutoFollowPatternResponse DeleteAutoFollowPattern(IDeleteAutoFollowPatternRequest request);
+
+		/// <inheritdoc cref="DeleteAutoFollowPattern(Name,System.Func{Nest.DeleteAutoFollowPatternDescriptor,Nest.IDeleteAutoFollowPatternRequest})" />
+		Task<IDeleteAutoFollowPatternResponse> DeleteAutoFollowPatternAsync(Name name, Func<DeleteAutoFollowPatternDescriptor, IDeleteAutoFollowPatternRequest> selector = null,
+			CancellationToken cancellationToken = default
+		);
+
+		/// <inheritdoc cref="DeleteAutoFollowPattern(Name,System.Func{Nest.DeleteAutoFollowPatternDescriptor,Nest.IDeleteAutoFollowPatternRequest})" />
+		Task<IDeleteAutoFollowPatternResponse> DeleteAutoFollowPatternAsync(IDeleteAutoFollowPatternRequest request, CancellationToken cancellationToken = default);
+	}
+
+	public partial class ElasticClient
+	{
+		/// <inheritdoc cref="DeleteAutoFollowPattern(Name,System.Func{Nest.DeleteAutoFollowPatternDescriptor,Nest.IDeleteAutoFollowPatternRequest})" />
+		public IDeleteAutoFollowPatternResponse DeleteAutoFollowPattern(Name name, Func<DeleteAutoFollowPatternDescriptor, IDeleteAutoFollowPatternRequest> selector = null) =>
+			DeleteAutoFollowPattern(selector.InvokeOrDefault(new DeleteAutoFollowPatternDescriptor(name)));
+
+		/// <inheritdoc cref="DeleteAutoFollowPattern(Name,System.Func{Nest.DeleteAutoFollowPatternDescriptor,Nest.IDeleteAutoFollowPatternRequest})" />
+		public IDeleteAutoFollowPatternResponse DeleteAutoFollowPattern(IDeleteAutoFollowPatternRequest request) =>
+			Dispatcher.Dispatch<IDeleteAutoFollowPatternRequest, DeleteAutoFollowPatternRequestParameters, DeleteAutoFollowPatternResponse>(
+				request,
+				(p, d) => LowLevelDispatch.CcrDeleteAutoFollowPatternDispatch<DeleteAutoFollowPatternResponse>(p)
+			);
+
+		/// <inheritdoc cref="DeleteAutoFollowPattern(Name,System.Func{Nest.DeleteAutoFollowPatternDescriptor,Nest.IDeleteAutoFollowPatternRequest})" />
+		public Task<IDeleteAutoFollowPatternResponse> DeleteAutoFollowPatternAsync(Name name, Func<DeleteAutoFollowPatternDescriptor, IDeleteAutoFollowPatternRequest> selector = null,
+			CancellationToken cancellationToken = default
+		) =>
+			DeleteAutoFollowPatternAsync(selector.InvokeOrDefault(new DeleteAutoFollowPatternDescriptor(name)), cancellationToken);
+
+		/// <inheritdoc cref="DeleteAutoFollowPattern(Name,System.Func{Nest.DeleteAutoFollowPatternDescriptor,Nest.IDeleteAutoFollowPatternRequest})" />
+		public Task<IDeleteAutoFollowPatternResponse> DeleteAutoFollowPatternAsync(IDeleteAutoFollowPatternRequest request, CancellationToken cancellationToken = default) =>
+			Dispatcher.DispatchAsync<IDeleteAutoFollowPatternRequest, DeleteAutoFollowPatternRequestParameters, DeleteAutoFollowPatternResponse, IDeleteAutoFollowPatternResponse>(
+				request,
+				cancellationToken,
+				(p, d, c) => LowLevelDispatch.CcrDeleteAutoFollowPatternDispatchAsync<DeleteAutoFollowPatternResponse>(p, c)
+			);
+	}
+}
diff --git a/src/Nest/XPack/CrossClusterReplication/AutoFollow/GetAutoFollowPattern/ElasticClient-GetAutoFollowPattern.cs b/src/Nest/XPack/CrossClusterReplication/AutoFollow/GetAutoFollowPattern/ElasticClient-GetAutoFollowPattern.cs
new file mode 100644
index 00000000000..e6e22416022
--- /dev/null
+++ b/src/Nest/XPack/CrossClusterReplication/AutoFollow/GetAutoFollowPattern/ElasticClient-GetAutoFollowPattern.cs
@@ -0,0 +1,52 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using Elasticsearch.Net;
+
+namespace Nest
+{
+	public partial interface IElasticClient
+	{
+		/// <summary> Gets configured auto-follow patterns. Returns the specified auto-follow pattern collection. </summary>
+		IGetAutoFollowPatternResponse GetAutoFollowPattern(Func<GetAutoFollowPatternDescriptor, IGetAutoFollowPatternRequest> selector = null);
+
+		/// <inheritdoc cref="GetAutoFollowPattern(System.Func{Nest.GetAutoFollowPatternDescriptor,Nest.IGetAutoFollowPatternRequest})" />
+		IGetAutoFollowPatternResponse GetAutoFollowPattern(IGetAutoFollowPatternRequest request);
+
+		/// <inheritdoc cref="GetAutoFollowPattern(System.Func{Nest.GetAutoFollowPatternDescriptor,Nest.IGetAutoFollowPatternRequest})" />
+		Task<IGetAutoFollowPatternResponse> GetAutoFollowPatternAsync(Func<GetAutoFollowPatternDescriptor, IGetAutoFollowPatternRequest> selector = null,
+			CancellationToken cancellationToken = default
+		);
+
+		/// <inheritdoc cref="GetAutoFollowPattern(System.Func{Nest.GetAutoFollowPatternDescriptor,Nest.IGetAutoFollowPatternRequest})" />
+		Task<IGetAutoFollowPatternResponse> GetAutoFollowPatternAsync(IGetAutoFollowPatternRequest request, CancellationToken cancellationToken = default);
+	}
+
+	public partial class ElasticClient
+	{
+		/// <inheritdoc cref="GetAutoFollowPattern(System.Func{Nest.GetAutoFollowPatternDescriptor,Nest.IGetAutoFollowPatternRequest})" />
+		public IGetAutoFollowPatternResponse GetAutoFollowPattern(Func<GetAutoFollowPatternDescriptor, IGetAutoFollowPatternRequest> selector = null) =>
+			GetAutoFollowPattern(selector.InvokeOrDefault(new GetAutoFollowPatternDescriptor()));
+
+		/// <inheritdoc cref="GetAutoFollowPattern(System.Func{Nest.GetAutoFollowPatternDescriptor,Nest.IGetAutoFollowPatternRequest})" />
+		public IGetAutoFollowPatternResponse GetAutoFollowPattern(IGetAutoFollowPatternRequest request) =>
+			Dispatcher.Dispatch<IGetAutoFollowPatternRequest, GetAutoFollowPatternRequestParameters, GetAutoFollowPatternResponse>(
+				request,
+				(p, d) => LowLevelDispatch.CcrGetAutoFollowPatternDispatch<GetAutoFollowPatternResponse>(p)
+			);
+
+		/// <inheritdoc cref="GetAutoFollowPattern(System.Func{Nest.GetAutoFollowPatternDescriptor,Nest.IGetAutoFollowPatternRequest})" />
+		public Task<IGetAutoFollowPatternResponse> GetAutoFollowPatternAsync(Func<GetAutoFollowPatternDescriptor, IGetAutoFollowPatternRequest> selector = null,
+			CancellationToken cancellationToken = default
+		) =>
+			GetAutoFollowPatternAsync(selector.InvokeOrDefault(new GetAutoFollowPatternDescriptor()), cancellationToken);
+
+		/// <inheritdoc cref="GetAutoFollowPattern(System.Func{Nest.GetAutoFollowPatternDescriptor,Nest.IGetAutoFollowPatternRequest})" />
+		public Task<IGetAutoFollowPatternResponse> GetAutoFollowPatternAsync(IGetAutoFollowPatternRequest request, CancellationToken cancellationToken = default) =>
+			Dispatcher.DispatchAsync<IGetAutoFollowPatternRequest, GetAutoFollowPatternRequestParameters, GetAutoFollowPatternResponse, IGetAutoFollowPatternResponse>(
+				request,
+				cancellationToken,
+				(p, d, c) => LowLevelDispatch.CcrGetAutoFollowPatternDispatchAsync<GetAutoFollowPatternResponse>(p, c)
+			);
+	}
+}
diff --git a/src/Nest/XPack/CrossClusterReplication/AutoFollow/GetAutoFollowPattern/GetAutoFollowPatternRequest.cs b/src/Nest/XPack/CrossClusterReplication/AutoFollow/GetAutoFollowPattern/GetAutoFollowPatternRequest.cs
new file mode 100644
index 00000000000..501d731ac24
--- /dev/null
+++ b/src/Nest/XPack/CrossClusterReplication/AutoFollow/GetAutoFollowPattern/GetAutoFollowPatternRequest.cs
@@ -0,0 +1,16 @@
+using System;
+using Newtonsoft.Json;
+
+namespace Nest
+{
+	/// <summary> Gets configured auto-follow patterns. This API will return the specified auto-follow pattern collection. </summary>
+	[MapsApi("ccr.get_auto_follow_pattern.json")]
+	[ContractJsonConverter(typeof(ReadAsTypeJsonConverter<GetAutoFollowPatternRequest>))]
+	public partial interface IGetAutoFollowPatternRequest { }
+
+	/// <inheritdoc cref="IGetAutoFollowPatternRequest"/>
+	public partial class GetAutoFollowPatternRequest { }
+
+	/// <inheritdoc cref="IGetAutoFollowPatternRequest"/>
+	public partial class GetAutoFollowPatternDescriptor { }
+}
diff --git a/src/Nest/XPack/CrossClusterReplication/AutoFollow/GetAutoFollowPattern/GetAutoFollowPatternResponse.cs b/src/Nest/XPack/CrossClusterReplication/AutoFollow/GetAutoFollowPattern/GetAutoFollowPatternResponse.cs
new file mode 100644
index 00000000000..6cd8e1ee7d0
--- /dev/null
+++ b/src/Nest/XPack/CrossClusterReplication/AutoFollow/GetAutoFollowPattern/GetAutoFollowPatternResponse.cs
@@ -0,0 +1,131 @@
+using System.Collections.Generic;
+using Newtonsoft.Json;
+
+namespace Nest
+{
+	public interface IGetAutoFollowPatternResponse : IResponse
+	{
+		IReadOnlyDictionary<string, AutoFollowPattern> Patterns { get; }
+	}
+
+	[JsonObject(MemberSerialization.OptIn)]
+	[JsonConverter(typeof(DictionaryResponseJsonConverter<GetAutoFollowPatternResponse, string, AutoFollowPattern>))]
+	public class GetAutoFollowPatternResponse : DictionaryResponseBase<string, AutoFollowPattern>, IGetAutoFollowPatternResponse
+	{
+		[JsonIgnore]
+		public IReadOnlyDictionary<string, AutoFollowPattern> Patterns => Self.BackingDictionary;
+	}
+
+	public interface IAutoFollowPattern
+	{
+		/// <summary>
+		/// the remote cluster containing the leader indices to match against
+		/// </summary>
+		[JsonProperty("remote_cluster")]
+		string RemoteCluster { get; set; }
+
+		/// <summary>
+		/// an array of simple index patterns to match against indices in the remote cluster specified by the remote_cluster field
+		/// </summary>
+		[JsonProperty("leader_index_patterns")]
+		IEnumerable<string> LeaderIndexPatterns { get; set; }
+
+		/// <summary>
+		/// the name of follower index; the template {{leader_index}} can be used to derive the name of the follower index from the name of the leader index
+		/// </summary>
+		[JsonProperty("follow_index_pattern")]
+		string FollowIndexPattern { get; set; }
+
+		/// <summary>
+		/// the maximum number of operations to pull per read from the remote cluster
+		/// </summary>
+		[JsonProperty("max_read_request_operation_count")]
+		int? MaxReadRequestOperationCount { get; set; }
+
+		/// <summary>
+		/// the maximum number of outstanding reads requests from the remote cluster
+		/// </summary>
+		[JsonProperty("max_outstanding_read_requests")]
+		long? MaxOutstandingReadRequests { get; set; }
+
+		/// <summary>
+		/// the maximum size in bytes of per read of a batch of operations pulled from the remote cluster
+		/// </summary>
+		[JsonProperty("max_read_request_size")]
+		string MaxReadRequestSize { get; set; }
+
+		/// <summary>
+		/// the maximum number of operations per bulk write request executed on the follower
+		/// </summary>
+		[JsonProperty("max_write_request_operation_count")]
+		int? MaxWriteRequestOperationCount { get; set; }
+
+		/// <summary>
+		/// the maximum total bytes of operations per bulk write request executed on the follower
+		/// </summary>
+		[JsonProperty("max_write_request_size")]
+		string MaxWriteRequestSize { get; set; }
+
+		/// <summary>
+		/// the maximum number of outstanding write requests on the follower
+		/// </summary>
+		[JsonProperty("max_outstanding_write_requests")]
+		int? MaxOutstandingWriteRequests { get; set; }
+
+		/// <summary>
+		/// the maximum number of operations that can be queued for writing; when this limit is reached, reads from the remote cluster will be deferred until the number of queued operations goes below the limit
+		/// </summary>
+		[JsonProperty("max_write_buffer_count")]
+		int? MaxWriteBufferCount { get; set; }
+
+		/// <summary>
+		/// the maximum total bytes of operations that can be queued for writing; when this limit is reached, reads from the remote cluster will be deferred until the total bytes of queued operations goes below the limit
+		/// </summary>
+		[JsonProperty("max_write_buffer_size")]
+		string MaxWriteBufferSize { get; set; }
+
+		/// <summary>
+		/// the maximum time to wait before retrying an operation that failed exceptionally; an exponential backoff strategy is employed when retrying
+		/// </summary>
+		[JsonProperty("max_retry_delay")]
+		Time MaxRetryDelay { get; set; }
+
+		/// <summary>
+		/// the maximum time to wait for new operations on the remote cluster when the follower index is synchronized with the leader index; when the timeout has elapsed, the poll for operations will return to the follower so that it can update some statistics, and then the follower will immediately attempt to read from the leader again
+		/// </summary>
+		[JsonProperty("read_poll_timeout")]
+		Time MaxPollTimeout { get; set; }
+	}
+
+	public class AutoFollowPattern : IAutoFollowPattern
+	{
+		/// <inheritdoc cref="IAutoFollowPattern.RemoteCluster"/>
+		public string RemoteCluster { get; set; }
+		/// <inheritdoc cref="IAutoFollowPattern.LeaderIndexPatterns"/>
+		public IEnumerable<string> LeaderIndexPatterns { get; set; }
+		/// <inheritdoc cref="IAutoFollowPattern.FollowIndexPattern"/>
+		public string FollowIndexPattern { get; set; }
+		/// <inheritdoc cref="IAutoFollowPattern.MaxReadRequestOperationCount"/>
+		public int? MaxReadRequestOperationCount { get; set; }
+		/// <inheritdoc cref="IAutoFollowPattern.MaxOutstandingReadRequests"/>
+		public long? MaxOutstandingReadRequests { get; set; }
+		/// <inheritdoc cref="IAutoFollowPattern.MaxReadRequestSize"/>
+		public string MaxReadRequestSize { get; set; }
+		/// <inheritdoc cref="IAutoFollowPattern.MaxWriteRequestOperationCount"/>
+		public int? MaxWriteRequestOperationCount { get; set; }
+		/// <inheritdoc cref="IAutoFollowPattern.MaxWriteRequestSize"/>
+		public string MaxWriteRequestSize { get; set; }
+		/// <inheritdoc cref="IAutoFollowPattern.MaxOutstandingWriteRequests"/>
+		public int? MaxOutstandingWriteRequests { get; set; }
+		/// <inheritdoc cref="IAutoFollowPattern.MaxWriteBufferCount"/>
+		public int? MaxWriteBufferCount { get; set; }
+		/// <inheritdoc cref="IAutoFollowPattern.MaxWriteBufferSize"/>
+		public string MaxWriteBufferSize { get; set; }
+		/// <inheritdoc cref="IAutoFollowPattern.MaxRetryDelay"/>
+		public Time MaxRetryDelay { get; set; }
+		/// <inheritdoc cref="IAutoFollowPattern.MaxPollTimeout"/>
+		public Time MaxPollTimeout { get; set; }
+	}
+
+
+}
diff --git a/src/Nest/XPack/CrossClusterReplication/Follow/CreateFollowIndex/CreateFollowIndexRequest.cs b/src/Nest/XPack/CrossClusterReplication/Follow/CreateFollowIndex/CreateFollowIndexRequest.cs
new file mode 100644
index 00000000000..cd98fa81d6a
--- /dev/null
+++ b/src/Nest/XPack/CrossClusterReplication/Follow/CreateFollowIndex/CreateFollowIndexRequest.cs
@@ -0,0 +1,170 @@
+using System;
+using Elasticsearch.Net;
+using Newtonsoft.Json;
+
+namespace Nest
+{
+	/// <summary>
+	/// Creates a new follower index that is configured to follow the referenced leader index.
+	/// When this API returns, the follower index exists, and cross-cluster replication starts replicating operations
+	/// from the leader index to the follower index
+	/// </summary>
+	[MapsApi("ccr.follow.json")]
+	[ContractJsonConverter(typeof(ReadAsTypeJsonConverter<CreateFollowIndexRequest>))]
+	public partial interface ICreateFollowIndexRequest
+	{
+		/// <summary> the remote cluster containing the leader index <para>
+		[JsonProperty("remote_cluster")]
+		string RemoteCluster { get; set; }
+
+		/// <summary> the name of the index in the leader cluster to follow </summary>
+		[JsonProperty("leader_index")]
+		IndexName LeaderIndex { get; set; }
+
+		/// <summary>the maximum number of operations to pull per read from the remote cluster </summary>
+		[JsonProperty("max_read_request_operation_count")]
+		long? MaxReadRequestOperationCount { get; set; }
+
+		/// <summary>the maximum number of outstanding reads requests from the remote cluster</summary>
+		[JsonProperty("max_outstanding_read_requests")]
+		long? MaxOutstandingReadRequests { get; set; }
+
+		/// <summary>the maximum size in bytes of per read of a batch of operations pulled from the remote cluster</summary>
+		[JsonProperty("max_read_request_size")]
+		string MaxRequestSize { get; set; }
+
+		/// <summary>the maximum number of operations per bulk write request executed on the follower</summary>
+		[JsonProperty("max_write_request_operation_count")]
+		long? MaxWriteRequestOperationCount { get; set; }
+
+		/// <summary>the maximum total bytes of operations per bulk write request executed on the follower</summary>
+		[JsonProperty("max_write_request_size")]
+		string MaxWriteRequestSize { get; set; }
+
+		/// <summary>the maximum number of outstanding write requests on the follower</summary>
+		[JsonProperty("max_outstanding_write_requests")]
+		long? MaxOutstandingWriteRequests { get; set; }
+
+		/// <summary>
+		/// the maximum number of operations that can be queued for writing; when this limit is reached, reads from
+		/// the remote cluster will be deferred until the number of queued operations goes below the limit
+		/// </summary>
+		[JsonProperty("max_write_buffer_count")]
+		long? MaxWriteBufferCount { get; set; }
+
+		/// <summary>
+		/// the maximum total bytes of operations that can be queued for writing; when this limit is reached, reads
+		/// from the remote cluster will be deferred until the total bytes of queued operations goes below the limit
+		/// </summary>
+		[JsonProperty("max_write_buffer_size")]
+		string MaxWriteBufferSize { get; set; }
+
+		/// <summary>
+		/// the maximum time to wait before retrying an operation that failed exceptionally; an exponential backoff
+		/// strategy is employed when retrying
+		/// </summary>
+		[JsonProperty("max_retry_delay")]
+		Time MaxRetryDelay { get; set; }
+
+		/// <summary>
+		/// the maximum time to wait for new operations on the remote cluster when the follower index is synchronized with the
+		/// leader index; when the timeout has elapsed, the poll for operations will return to the follower so that it can
+		/// update some statistics, and then the follower will immediately attempt to read from the leader again
+		/// </summary>
+		[JsonProperty("read_poll_timeout")]
+		Time ReadPollTimeout { get; set; }
+	}
+
+	/// <inheritdoc cref="ICreateFollowIndexRequest"/>
+	public partial class CreateFollowIndexRequest
+	{
+		/// <inheritdoc cref="ICreateFollowIndexRequest.RemoteCluster"/>
+		public string RemoteCluster { get; set; }
+
+		/// <inheritdoc cref="ICreateFollowIndexRequest.LeaderIndex"/>
+		public IndexName LeaderIndex { get; set; }
+
+		/// <inheritdoc cref="ICreateFollowIndexRequest.MaxReadRequestOperationCount"/>
+		public long? MaxReadRequestOperationCount { get; set; }
+
+		/// <inheritdoc cref="ICreateFollowIndexRequest.MaxOutstandingReadRequests"/>
+		public long? MaxOutstandingReadRequests { get; set; }
+
+		/// <inheritdoc cref="ICreateFollowIndexRequest.MaxRequestSize"/>
+		public string MaxRequestSize { get; set; }
+
+		/// <inheritdoc cref="ICreateFollowIndexRequest.MaxWriteRequestOperationCount"/>
+		public long? MaxWriteRequestOperationCount { get; set; }
+
+		/// <inheritdoc cref="ICreateFollowIndexRequest.MaxWriteRequestSize"/>
+		public string MaxWriteRequestSize { get; set; }
+
+		/// <inheritdoc cref="ICreateFollowIndexRequest.MaxOutstandingWriteRequests"/>
+		public long? MaxOutstandingWriteRequests { get; set; }
+
+		/// <inheritdoc cref="ICreateFollowIndexRequest.MaxWriteBufferCount"/>
+		public long? MaxWriteBufferCount { get; set; }
+
+		/// <inheritdoc cref="ICreateFollowIndexRequest.MaxWriteBufferSize"/>
+		public string MaxWriteBufferSize { get; set; }
+
+		/// <inheritdoc cref="ICreateFollowIndexRequest.MaxRetryDelay"/>
+		public Time MaxRetryDelay { get; set; }
+
+		/// <inheritdoc cref="ICreateFollowIndexRequest.ReadPollTimeout"/>
+		public Time ReadPollTimeout { get; set; }
+	}
+
+	/// <inheritdoc cref="ICreateFollowIndexRequest"/>
+	public partial class CreateFollowIndexDescriptor
+	{
+		string ICreateFollowIndexRequest.RemoteCluster { get; set; }
+		IndexName ICreateFollowIndexRequest.LeaderIndex { get; set; }
+		long? ICreateFollowIndexRequest.MaxReadRequestOperationCount { get; set; }
+		long? ICreateFollowIndexRequest.MaxOutstandingReadRequests { get; set; }
+		string ICreateFollowIndexRequest.MaxRequestSize { get; set; }
+		long? ICreateFollowIndexRequest.MaxWriteRequestOperationCount { get; set; }
+		string ICreateFollowIndexRequest.MaxWriteRequestSize { get; set; }
+		long? ICreateFollowIndexRequest.MaxOutstandingWriteRequests { get; set; }
+		long? ICreateFollowIndexRequest.MaxWriteBufferCount { get; set; }
+		string ICreateFollowIndexRequest.MaxWriteBufferSize { get; set; }
+		Time ICreateFollowIndexRequest.MaxRetryDelay { get; set; }
+		Time ICreateFollowIndexRequest.ReadPollTimeout { get; set; }
+
+		/// <inheritdoc cref="ICreateFollowIndexRequest.RemoteCluster"/>
+		public CreateFollowIndexDescriptor RemoteCluster(string remoteCluster) => Assign(a => a.RemoteCluster = remoteCluster);
+
+		/// <inheritdoc cref="ICreateFollowIndexRequest.LeaderIndex"/>
+		public CreateFollowIndexDescriptor LeaderIndex(IndexName index) => Assign(a => a.LeaderIndex = index);
+
+		/// <inheritdoc cref="ICreateFollowIndexRequest.MaxReadRequestOperationCount"/>
+		public CreateFollowIndexDescriptor MaxReadRequestOperationCount(long? max) => Assign(a => a.MaxReadRequestOperationCount = max);
+
+		/// <inheritdoc cref="ICreateFollowIndexRequest.MaxOutstandingReadRequests"/>
+		public CreateFollowIndexDescriptor MaxOutstandingReadRequests(long? max) => Assign(a => a.MaxOutstandingReadRequests = max);
+
+		/// <inheritdoc cref="ICreateFollowIndexRequest.MaxRequestSize"/>
+		public CreateFollowIndexDescriptor MaxRequestSize(string maxRequestSize) => Assign(a => a.MaxRequestSize = maxRequestSize);
+
+		/// <inheritdoc cref="ICreateFollowIndexRequest.MaxWriteRequestOperationCount"/>
+		public CreateFollowIndexDescriptor MaxWriteRequestOperationCount(long? max) => Assign(a => a.MaxWriteRequestOperationCount = max);
+
+		/// <inheritdoc cref="ICreateFollowIndexRequest.MaxWriteRequestSize"/>
+		public CreateFollowIndexDescriptor MaxWriteRequestSize(string maxSize) => Assign(a => a.MaxWriteRequestSize = maxSize);
+
+		/// <inheritdoc cref="ICreateFollowIndexRequest.MaxOutstandingWriteRequests"/>
+		public CreateFollowIndexDescriptor MaxOutstandingWriteRequests(long? max) => Assign(a => a.MaxOutstandingWriteRequests = max);
+
+		/// <inheritdoc cref="ICreateFollowIndexRequest.MaxWriteBufferCount"/>
+		public CreateFollowIndexDescriptor MaxWriteBufferCount(long? max) => Assign(a => a.MaxWriteBufferCount = max);
+
+		/// <inheritdoc cref="ICreateFollowIndexRequest.MaxWriteBufferSize"/>
+		public CreateFollowIndexDescriptor MaxWriteBufferSize(string max) => Assign(a => a.MaxWriteBufferSize = max);
+
+		/// <inheritdoc cref="ICreateFollowIndexRequest.MaxRetryDelay"/>
+		public CreateFollowIndexDescriptor MaxRetryDelay(Time maxRetryDelay) => Assign(a => a.MaxRetryDelay = maxRetryDelay);
+
+		/// <inheritdoc cref="ICreateFollowIndexRequest.ReadPollTimeout"/>
+		public CreateFollowIndexDescriptor ReadPollTimeout(Time readPollTimeout) => Assign(a => a.ReadPollTimeout = readPollTimeout);
+	}
+}
diff --git a/src/Nest/XPack/CrossClusterReplication/Follow/CreateFollowIndex/CreateFollowIndexResponse.cs b/src/Nest/XPack/CrossClusterReplication/Follow/CreateFollowIndex/CreateFollowIndexResponse.cs
new file mode 100644
index 00000000000..cb2c3d10639
--- /dev/null
+++ b/src/Nest/XPack/CrossClusterReplication/Follow/CreateFollowIndex/CreateFollowIndexResponse.cs
@@ -0,0 +1,24 @@
+using System.Collections.Generic;
+using Newtonsoft.Json;
+
+namespace Nest
+{
+	public interface ICreateFollowIndexResponse : IResponse
+	{
+		[JsonProperty("follow_index_created")]
+		bool FollowIndexCreated { get; }
+
+		[JsonProperty("follow_index_shards_acked")]
+		bool FollowIndexShardsAcked { get; }
+
+		[JsonProperty("index_following_started")]
+		bool IndexFollowingStarted { get; }
+	}
+
+	public class CreateFollowIndexResponse : ResponseBase, ICreateFollowIndexResponse
+	{
+		public bool FollowIndexCreated { get; internal set; }
+		public bool FollowIndexShardsAcked { get; internal set; }
+		public bool IndexFollowingStarted { get; internal set; }
+	}
+}
diff --git a/src/Nest/XPack/CrossClusterReplication/Follow/CreateFollowIndex/ElasticClient-CreateFollowIndex.cs b/src/Nest/XPack/CrossClusterReplication/Follow/CreateFollowIndex/ElasticClient-CreateFollowIndex.cs
new file mode 100644
index 00000000000..63d552e78b7
--- /dev/null
+++ b/src/Nest/XPack/CrossClusterReplication/Follow/CreateFollowIndex/ElasticClient-CreateFollowIndex.cs
@@ -0,0 +1,56 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using Elasticsearch.Net;
+
+namespace Nest
+{
+	public partial interface IElasticClient
+	{
+		/// <summary>
+		/// Creates a new follower index that is configured to follow the referenced leader index.
+		/// When this API returns, the follower index exists, and cross-cluster replication starts replicating
+		/// operations from the leader index to the follower index.
+		/// </summary>
+		ICreateFollowIndexResponse CreateFollowIndex(IndexName index, Func<CreateFollowIndexDescriptor, ICreateFollowIndexRequest> selector);
+
+		/// <inheritdoc cref="CreateFollowIndex(IndexName, System.Func{Nest.CreateFollowIndexDescriptor,Nest.ICreateFollowIndexRequest})" />
+		ICreateFollowIndexResponse CreateFollowIndex(ICreateFollowIndexRequest request);
+
+		/// <inheritdoc cref="CreateFollowIndex(IndexName, System.Func{Nest.CreateFollowIndexDescriptor,Nest.ICreateFollowIndexRequest})" />
+		Task<ICreateFollowIndexResponse> CreateFollowIndexAsync(IndexName index, Func<CreateFollowIndexDescriptor, ICreateFollowIndexRequest> selector,
+			CancellationToken cancellationToken = default
+		);
+
+		/// <inheritdoc cref="CreateFollowIndex(IndexName, System.Func{Nest.CreateFollowIndexDescriptor,Nest.ICreateFollowIndexRequest})" />
+		Task<ICreateFollowIndexResponse> CreateFollowIndexAsync(ICreateFollowIndexRequest request, CancellationToken cancellationToken = default);
+	}
+
+	public partial class ElasticClient
+	{
+		/// <inheritdoc cref="CreateFollowIndex(IndexName, System.Func{Nest.CreateFollowIndexDescriptor,Nest.ICreateFollowIndexRequest})" />
+		public ICreateFollowIndexResponse CreateFollowIndex(IndexName index, Func<CreateFollowIndexDescriptor, ICreateFollowIndexRequest> selector) =>
+			CreateFollowIndex(selector.InvokeOrDefault(new CreateFollowIndexDescriptor(index)));
+
+		/// <inheritdoc cref="CreateFollowIndex(IndexName, System.Func{Nest.CreateFollowIndexDescriptor,Nest.ICreateFollowIndexRequest})" />
+		public ICreateFollowIndexResponse CreateFollowIndex(ICreateFollowIndexRequest request) =>
+			Dispatcher.Dispatch<ICreateFollowIndexRequest, CreateFollowIndexRequestParameters, CreateFollowIndexResponse>(
+				request,
+				(p, d) => LowLevelDispatch.CcrFollowDispatch<CreateFollowIndexResponse>(p, d)
+			);
+
+		/// <inheritdoc cref="CreateFollowIndex(IndexName, System.Func{Nest.CreateFollowIndexDescriptor,Nest.ICreateFollowIndexRequest})" />
+		public Task<ICreateFollowIndexResponse> CreateFollowIndexAsync(IndexName index, Func<CreateFollowIndexDescriptor, ICreateFollowIndexRequest> selector,
+			CancellationToken cancellationToken = default
+		) =>
+			CreateFollowIndexAsync(selector.InvokeOrDefault(new CreateFollowIndexDescriptor(index)), cancellationToken);
+
+		/// <inheritdoc cref="CreateFollowIndex(IndexName, System.Func{Nest.CreateFollowIndexDescriptor,Nest.ICreateFollowIndexRequest})" />
+		public Task<ICreateFollowIndexResponse> CreateFollowIndexAsync(ICreateFollowIndexRequest request, CancellationToken cancellationToken = default) =>
+			Dispatcher.DispatchAsync<ICreateFollowIndexRequest, CreateFollowIndexRequestParameters, CreateFollowIndexResponse, ICreateFollowIndexResponse>(
+				request,
+				cancellationToken,
+				(p, d, c) => LowLevelDispatch.CcrFollowDispatchAsync<CreateFollowIndexResponse>(p, d, c)
+			);
+	}
+}
diff --git a/src/Nest/XPack/CrossClusterReplication/Follow/FollowIndexStats/ElasticClient-FollowIndexStats.cs b/src/Nest/XPack/CrossClusterReplication/Follow/FollowIndexStats/ElasticClient-FollowIndexStats.cs
new file mode 100644
index 00000000000..0adfb427347
--- /dev/null
+++ b/src/Nest/XPack/CrossClusterReplication/Follow/FollowIndexStats/ElasticClient-FollowIndexStats.cs
@@ -0,0 +1,54 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using Elasticsearch.Net;
+
+namespace Nest
+{
+	public partial interface IElasticClient
+	{
+		/// <summary>
+		/// Gets follower stats. Returns shard-level stats about the following tasks associated with each shard for the specified indices.
+		/// </summary>
+		IFollowIndexStatsResponse FollowIndexStats(Indices indices, Func<FollowIndexStatsDescriptor, IFollowIndexStatsRequest> selector = null);
+
+		/// <inheritdoc cref="FollowIndexStats(Indices, System.Func{Nest.FollowIndexStatsDescriptor,Nest.IFollowIndexStatsRequest})" />
+		IFollowIndexStatsResponse FollowIndexStats(IFollowIndexStatsRequest request);
+
+		/// <inheritdoc cref="FollowIndexStats(Indices, System.Func{Nest.FollowIndexStatsDescriptor,Nest.IFollowIndexStatsRequest})" />
+		Task<IFollowIndexStatsResponse> FollowIndexStatsAsync(Indices indices, Func<FollowIndexStatsDescriptor, IFollowIndexStatsRequest> selector = null,
+			CancellationToken cancellationToken = default
+		);
+
+		/// <inheritdoc cref="FollowIndexStats(Indices, System.Func{Nest.FollowIndexStatsDescriptor,Nest.IFollowIndexStatsRequest})" />
+		Task<IFollowIndexStatsResponse> FollowIndexStatsAsync(IFollowIndexStatsRequest request, CancellationToken cancellationToken = default);
+	}
+
+	public partial class ElasticClient
+	{
+		/// <inheritdoc cref="FollowIndexStats(Indices, System.Func{Nest.FollowIndexStatsDescriptor,Nest.IFollowIndexStatsRequest})" />
+		public IFollowIndexStatsResponse FollowIndexStats(Indices indices, Func<FollowIndexStatsDescriptor, IFollowIndexStatsRequest> selector = null) =>
+			FollowIndexStats(selector.InvokeOrDefault(new FollowIndexStatsDescriptor().Index(indices)));
+
+		/// <inheritdoc cref="FollowIndexStats(Indices, System.Func{Nest.FollowIndexStatsDescriptor,Nest.IFollowIndexStatsRequest})" />
+		public IFollowIndexStatsResponse FollowIndexStats(IFollowIndexStatsRequest request) =>
+			Dispatcher.Dispatch<IFollowIndexStatsRequest, FollowIndexStatsRequestParameters, FollowIndexStatsResponse>(
+				request,
+				(p, d) => LowLevelDispatch.CcrFollowStatsDispatch<FollowIndexStatsResponse>(p)
+			);
+
+		/// <inheritdoc cref="FollowIndexStats(Indices, System.Func{Nest.FollowIndexStatsDescriptor,Nest.IFollowIndexStatsRequest})" />
+		public Task<IFollowIndexStatsResponse> FollowIndexStatsAsync(Indices indices, Func<FollowIndexStatsDescriptor, IFollowIndexStatsRequest> selector = null,
+			CancellationToken cancellationToken = default
+		) =>
+			FollowIndexStatsAsync(selector.InvokeOrDefault(new FollowIndexStatsDescriptor().Index(indices)), cancellationToken);
+
+		/// <inheritdoc cref="FollowIndexStats(Indices, System.Func{Nest.FollowIndexStatsDescriptor,Nest.IFollowIndexStatsRequest})" />
+		public Task<IFollowIndexStatsResponse> FollowIndexStatsAsync(IFollowIndexStatsRequest request, CancellationToken cancellationToken = default) =>
+			Dispatcher.DispatchAsync<IFollowIndexStatsRequest, FollowIndexStatsRequestParameters, FollowIndexStatsResponse, IFollowIndexStatsResponse>(
+				request,
+				cancellationToken,
+				(p, d, c) => LowLevelDispatch.CcrFollowStatsDispatchAsync<FollowIndexStatsResponse>(p, c)
+			);
+	}
+}
diff --git a/src/Nest/XPack/CrossClusterReplication/Follow/FollowIndexStats/FollowIndexShardStats.cs b/src/Nest/XPack/CrossClusterReplication/Follow/FollowIndexStats/FollowIndexShardStats.cs
new file mode 100644
index 00000000000..389ad5f5fe0
--- /dev/null
+++ b/src/Nest/XPack/CrossClusterReplication/Follow/FollowIndexStats/FollowIndexShardStats.cs
@@ -0,0 +1,152 @@
+using System.Collections.Generic;
+using Elasticsearch.Net;
+using Newtonsoft.Json;
+
+namespace Nest
+{
+	public class FollowIndexShardStats
+	{
+		/// <summary>
+		/// the total of transferred bytes read from the leader (note this is only an estimate, and does not
+		/// account for compression if enabled)
+		/// </summary>
+		[JsonProperty("bytes_read")]
+		public long BytesRead { get; set; }
+
+		///<summary>the number of failed reads</summary>
+		[JsonProperty("failed_read_requests")]
+		public long FailedReadRequests { get; set; }
+
+		///<summary>the number of failed bulk write requests executed on the follower</summary>
+		[JsonProperty("failed_write_requests")]
+		public long FailedWriteRequests { get; set; }
+
+		/// <summary>
+		/// the current global checkpoint on the follower; the difference between the leader_global_checkpoint and
+		/// the follower_global_checkpoint is an indication of how much the follower is lagging the leader
+		/// </summary>
+		[JsonProperty("follower_global_checkpoint")]
+		public long FollowerGlobalCheckpoint { get; set; }
+
+		///<summary>the name of the follower index</summary>
+		[JsonProperty("follower_index")]
+		public string FollowerIndex { get; set; }
+
+		///<summary>the mapping version the follower is synced up to</summary>
+		[JsonProperty("follower_mapping_version")]
+		public long FollowerMappingVersion { get; set; }
+
+		///<summary>the current maximum sequence number on the follower</summary>
+		[JsonProperty("follower_max_seq_no")]
+		public long FollowerMaxSequenceNumber { get; set; }
+
+		///<summary>the index settings version the follower is synced up to</summary>
+		[JsonProperty("follower_settings_version")]
+		public long FollowerSettingsVersion { get; set; }
+
+		///<summary>the starting sequence number of the last batch of operations requested from the leader</summary>
+		[JsonProperty("last_requested_seq_no")]
+		public long LastRequestedSequenceNumber { get; set; }
+
+		///<summary>the current global checkpoint on the leader known to the follower task</summary>
+		[JsonProperty("leader_global_checkpoint")]
+		public long LeaderGlobalCheckpoint { get; set; }
+
+		///<summary>the name of the index in the leader cluster being followed</summary>
+		[JsonProperty("leader_index")]
+		public string LeaderIndex { get; set; }
+
+		///<summary>the current maximum sequence number on the leader known to the follower task</summary>
+		[JsonProperty("leader_max_seq_no")]
+		public long LeaderMaxSequenceNumber { get; set; }
+
+		///<summary>the total number of operations read from the leader</summary>
+		[JsonProperty("operations_read")]
+		public long OperationsRead { get; set; }
+
+		///<summary>the number of operations written on the follower</summary>
+		[JsonProperty("operations_written")]
+		public long OperationsWritten { get; set; }
+
+		///<summary>the number of active read requests from the follower</summary>
+		[JsonProperty("outstanding_read_requests")]
+		public int OutstandingReadRequests { get; set; }
+
+		///<summary>the number of active bulk write requests on the follower</summary>
+		[JsonProperty("outstanding_write_requests")]
+		public int OutstandingWriteRequest { get; set; }
+
+		///<summary>the remote cluster containing the leader index</summary>
+		[JsonProperty("remote_cluster")]
+		public string RemoteCluster { get; set; }
+
+		///<summary>the numerical shard ID, with values from 0 to one less than the number of replicas</summary>
+		[JsonProperty("shard_id")]
+		public int ShardId { get; set; }
+
+		///<summary>the number of successful fetches</summary>
+		[JsonProperty("successful_read_requests")]
+		public long SuccessfulReadRequests { get; set; }
+
+		///<summary>the number of bulk write requests executed on the follower</summary>
+		[JsonProperty("successful_write_requests")]
+		public long SuccessfulWriteRequests { get; set; }
+
+		///<summary>the total time reads spent executing on the remote cluster</summary>
+		[JsonProperty("total_read_remote_exec_time_millis")]
+		public long TotalReadRemoteExecutionTimeInMilliseconds { get; set; }
+
+		/// <summary>
+		/// the total time reads were outstanding, measured from the time a read was sent to the leader to the time
+		/// a reply was returned to the follower
+		/// </summary>
+		[JsonProperty("total_read_time_millis")]
+		public long TotalReadTimeInMilliseconds { get; set; }
+
+		///<summary>the total time spent writing on the follower</summary>
+		[JsonProperty("total_write_time_millis")]
+		public long TotalWriteTimeInMilliseconds { get; set; }
+
+		///<summary>the number of write operations queued on the follower</summary>
+		[JsonProperty("write_buffer_operation_count")]
+		public long WriteBufferOperationCount { get; set; }
+
+		///<summary>the total number of bytes of operations currently queued for writing</summary>
+		[JsonProperty("write_buffer_size_in_bytes")]
+		public long WriteBufferSizeInBytes { get; set; }
+
+		[JsonProperty("read_exceptions")]
+		public IReadOnlyCollection<FollowIndexReadException> ReadExceptions { get; internal set; } = EmptyReadOnly<FollowIndexReadException>.Collection;
+
+		///<summary>
+		/// the number of milliseconds since a read request was sent to the leader; note that when the follower is caught up
+		/// to the leader, this number will increase up to the configured read_poll_timeout at which point another read request
+		/// will be sent to the leader
+		/// </summary>
+		[JsonProperty("time_since_last_read_millis")]
+		public long TimeSinceLastReadInMilliseconds { get; set; }
+
+		///<summary>
+		/// an object representing a fatal exception that cancelled the following task; in this situation,
+		/// the following task must be resumed manually with the resume follower API
+		/// </summary>
+		[JsonProperty("fatal_exception")]
+		public ErrorCause FatalException { get; set; }
+	}
+
+	public class FollowIndexReadException
+	{
+		///<summary>the starting sequence number of the batch requested from the leader</summary>
+		[JsonProperty("from_seq_no")]
+		public long FromSquenceNumber { get; set; }
+
+		///<summary>the number of times the batch has been retried</summary>
+		[JsonProperty("retries")]
+		public int Retries { get; set; }
+
+		///<summary>Represents the exception that caused the read to fail</summary>
+		[JsonProperty("exception")]
+		public ErrorCause Exception { get; set; }
+
+	}
+}
diff --git a/src/Nest/XPack/CrossClusterReplication/Follow/FollowIndexStats/FollowIndexStatsRequest.cs b/src/Nest/XPack/CrossClusterReplication/Follow/FollowIndexStats/FollowIndexStatsRequest.cs
new file mode 100644
index 00000000000..f67c612f9c5
--- /dev/null
+++ b/src/Nest/XPack/CrossClusterReplication/Follow/FollowIndexStats/FollowIndexStatsRequest.cs
@@ -0,0 +1,16 @@
+namespace Nest
+{
+	/// <summary>
+	/// Gets follower stats. Will return shard-level stats about the following tasks associated with each shard for the
+	/// specified indices.
+	/// </summary>
+	[MapsApi("ccr.follow_stats.json")]
+	[ContractJsonConverter(typeof(ReadAsTypeJsonConverter<FollowIndexStatsRequest>))]
+	public partial interface IFollowIndexStatsRequest { }
+
+	/// <inheritdoc cref="IFollowIndexStatsRequest" />
+	public partial class FollowIndexStatsRequest { }
+
+	/// <inheritdoc cref="IFollowIndexStatsRequest" />
+	public partial class FollowIndexStatsDescriptor { }
+}
diff --git a/src/Nest/XPack/CrossClusterReplication/Follow/FollowIndexStats/FollowIndexStatsResponse.cs b/src/Nest/XPack/CrossClusterReplication/Follow/FollowIndexStats/FollowIndexStatsResponse.cs
new file mode 100644
index 00000000000..4269f43150f
--- /dev/null
+++ b/src/Nest/XPack/CrossClusterReplication/Follow/FollowIndexStats/FollowIndexStatsResponse.cs
@@ -0,0 +1,27 @@
+using System.Collections.Generic;
+using Newtonsoft.Json;
+
+namespace Nest
+{
+	public interface IFollowIndexStatsResponse : IResponse
+	{
+		[JsonProperty("indices")]
+		IReadOnlyCollection<FollowIndexStats> Indices { get; }
+	}
+
+	public class FollowIndexStatsResponse : ResponseBase, IFollowIndexStatsResponse
+	{
+		/// <inheritdoc cref="IFollowIndexStatsResponse.Indices" />
+		[JsonProperty("indices")]
+		public IReadOnlyCollection<FollowIndexStats> Indices { get; internal set; } = EmptyReadOnly<FollowIndexStats>.Collection;
+	}
+
+	public class FollowIndexStats
+	{
+		[JsonProperty("index")]
+		public string Index { get; internal set; }
+
+		[JsonProperty("shards")]
+		public IReadOnlyCollection<FollowIndexShardStats> Shards { get; internal set; } = EmptyReadOnly<FollowIndexShardStats>.Collection;
+	}
+}
diff --git a/src/Nest/XPack/CrossClusterReplication/Follow/PauseFollowIndex/ElasticClient-PauseFollowIndex.cs b/src/Nest/XPack/CrossClusterReplication/Follow/PauseFollowIndex/ElasticClient-PauseFollowIndex.cs
new file mode 100644
index 00000000000..5b2199b2d5c
--- /dev/null
+++ b/src/Nest/XPack/CrossClusterReplication/Follow/PauseFollowIndex/ElasticClient-PauseFollowIndex.cs
@@ -0,0 +1,58 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using Elasticsearch.Net;
+
+namespace Nest
+{
+	public partial interface IElasticClient
+	{
+		/// <summary>
+		/// Pauses a follower index. When this API returns, the follower index will not fetch any additional operations from
+		/// the leader index. You can resume following with the resume follower API. Pausing and resuming a follower index can be
+		/// used to change the configuration of the following task.
+		/// </summary>
+		IPauseFollowIndexResponse PauseFollowIndex(IndexName index, Func<PauseFollowIndexDescriptor, IPauseFollowIndexRequest> selector = null);
+
+		/// <inheritdoc cref="PauseFollowIndex(IndexName, System.Func{Nest.PauseFollowIndexDescriptor,Nest.IPauseFollowIndexRequest})" />
+		IPauseFollowIndexResponse PauseFollowIndex(IPauseFollowIndexRequest request);
+
+		/// <inheritdoc cref="PauseFollowIndex(IndexName, System.Func{Nest.PauseFollowIndexDescriptor,Nest.IPauseFollowIndexRequest})" />
+		Task<IPauseFollowIndexResponse> PauseFollowIndexAsync(IndexName index, Func<PauseFollowIndexDescriptor, IPauseFollowIndexRequest> selector = null,
+			CancellationToken cancellationToken = default
+		);
+
+		/// <inheritdoc cref="PauseFollowIndex(IndexName, System.Func{Nest.PauseFollowIndexDescriptor,Nest.IPauseFollowIndexRequest})" />
+		Task<IPauseFollowIndexResponse> PauseFollowIndexAsync(IPauseFollowIndexRequest request, CancellationToken cancellationToken = default);
+	}
+
+	public partial class ElasticClient
+	{
+		/// <inheritdoc cref="PauseFollowIndex(IndexName, System.Func{Nest.PauseFollowIndexDescriptor,Nest.IPauseFollowIndexRequest})" />
+		public IPauseFollowIndexResponse PauseFollowIndex(IndexName index, Func<PauseFollowIndexDescriptor, IPauseFollowIndexRequest> selector = null) =>
+			PauseFollowIndex(selector.InvokeOrDefault(new PauseFollowIndexDescriptor(index)));
+
+		/// <inheritdoc cref="PauseFollowIndex(IndexName, System.Func{Nest.PauseFollowIndexDescriptor,Nest.IPauseFollowIndexRequest})" />
+		public IPauseFollowIndexResponse PauseFollowIndex(IPauseFollowIndexRequest request) =>
+			Dispatcher.Dispatch<IPauseFollowIndexRequest, PauseFollowIndexRequestParameters, PauseFollowIndexResponse>(
+				request,
+				(p, d) => LowLevelDispatch.CcrPauseFollowDispatch<PauseFollowIndexResponse>(p)
+			);
+
+		/// <inheritdoc cref="PauseFollowIndex(IndexName, System.Func{Nest.PauseFollowIndexDescriptor,Nest.IPauseFollowIndexRequest})" />
+		public Task<IPauseFollowIndexResponse> PauseFollowIndexAsync(
+			IndexName index,
+			Func<PauseFollowIndexDescriptor, IPauseFollowIndexRequest> selector = null,
+			CancellationToken cancellationToken = default
+		) =>
+			PauseFollowIndexAsync(selector.InvokeOrDefault(new PauseFollowIndexDescriptor(index)), cancellationToken);
+
+		/// <inheritdoc cref="PauseFollowIndex(IndexName, System.Func{Nest.PauseFollowIndexDescriptor,Nest.IPauseFollowIndexRequest})" />
+		public Task<IPauseFollowIndexResponse> PauseFollowIndexAsync(IPauseFollowIndexRequest request, CancellationToken cancellationToken = default) =>
+			Dispatcher.DispatchAsync<IPauseFollowIndexRequest, PauseFollowIndexRequestParameters, PauseFollowIndexResponse, IPauseFollowIndexResponse>(
+				request,
+				cancellationToken,
+				(p, d, c) => LowLevelDispatch.CcrPauseFollowDispatchAsync<PauseFollowIndexResponse>(p, c)
+			);
+	}
+}
diff --git a/src/Nest/XPack/CrossClusterReplication/Follow/PauseFollowIndex/PauseFollowIndexRequest.cs b/src/Nest/XPack/CrossClusterReplication/Follow/PauseFollowIndex/PauseFollowIndexRequest.cs
new file mode 100644
index 00000000000..75d14c29c09
--- /dev/null
+++ b/src/Nest/XPack/CrossClusterReplication/Follow/PauseFollowIndex/PauseFollowIndexRequest.cs
@@ -0,0 +1,20 @@
+using System;
+using Newtonsoft.Json;
+
+namespace Nest
+{
+	/// <summary>
+	/// Pauses a follower index. When this API returns, the follower index will not fetch any additional operations from
+	/// the leader index. You can resume following with the resume follower API. Pausing and resuming a follower index can be
+	/// used to change the configuration of the following task.
+	/// </summary>
+	[MapsApi("ccr.pause_follow.json")]
+	[ContractJsonConverter(typeof(ReadAsTypeJsonConverter<PauseFollowIndexRequest>))]
+	public partial interface IPauseFollowIndexRequest { }
+
+	/// <inheritdoc cref="IPauseFollowIndexRequest"/>
+	public partial class PauseFollowIndexRequest { }
+
+	/// <inheritdoc cref="IPauseFollowIndexRequest"/>
+	public partial class PauseFollowIndexDescriptor { }
+}
diff --git a/src/Nest/XPack/CrossClusterReplication/Follow/PauseFollowIndex/PauseFollowIndexResponse.cs b/src/Nest/XPack/CrossClusterReplication/Follow/PauseFollowIndex/PauseFollowIndexResponse.cs
new file mode 100644
index 00000000000..a87ea82f750
--- /dev/null
+++ b/src/Nest/XPack/CrossClusterReplication/Follow/PauseFollowIndex/PauseFollowIndexResponse.cs
@@ -0,0 +1,9 @@
+using System.Collections.Generic;
+using Newtonsoft.Json;
+
+namespace Nest
+{
+	public interface IPauseFollowIndexResponse : IAcknowledgedResponse { }
+
+	public class PauseFollowIndexResponse : AcknowledgedResponseBase, IPauseFollowIndexResponse { }
+}
diff --git a/src/Nest/XPack/CrossClusterReplication/Follow/ResumeFollowIndex/ElasticClient-ResumeFollowIndex.cs b/src/Nest/XPack/CrossClusterReplication/Follow/ResumeFollowIndex/ElasticClient-ResumeFollowIndex.cs
new file mode 100644
index 00000000000..43cb6691611
--- /dev/null
+++ b/src/Nest/XPack/CrossClusterReplication/Follow/ResumeFollowIndex/ElasticClient-ResumeFollowIndex.cs
@@ -0,0 +1,56 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using Elasticsearch.Net;
+
+namespace Nest
+{
+	public partial interface IElasticClient
+	{
+		/// <summary>
+		/// Resumes a follower index that has been paused either explicitly with the pause follower API or
+		/// implicitly due to execution that can not be retried due to failure during following. When this API returns,
+		/// the follower index will resume fetching operations from the leader index.
+		/// </summary>
+		IResumeFollowIndexResponse ResumeFollowIndex(IndexName index, Func<ResumeFollowIndexDescriptor, IResumeFollowIndexRequest> selector = null);
+
+		/// <inheritdoc cref="ResumeFollowIndex(IndexName, System.Func{Nest.ResumeFollowIndexDescriptor,Nest.IResumeFollowIndexRequest})" />
+		IResumeFollowIndexResponse ResumeFollowIndex(IResumeFollowIndexRequest request);
+
+		/// <inheritdoc cref="ResumeFollowIndex(IndexName, System.Func{Nest.ResumeFollowIndexDescriptor,Nest.IResumeFollowIndexRequest})" />
+		Task<IResumeFollowIndexResponse> ResumeFollowIndexAsync(IndexName index, Func<ResumeFollowIndexDescriptor, IResumeFollowIndexRequest> selector = null,
+			CancellationToken cancellationToken = default
+		);
+
+		/// <inheritdoc cref="ResumeFollowIndex(IndexName, System.Func{Nest.ResumeFollowIndexDescriptor,Nest.IResumeFollowIndexRequest})" />
+		Task<IResumeFollowIndexResponse> ResumeFollowIndexAsync(IResumeFollowIndexRequest request, CancellationToken cancellationToken = default);
+	}
+
+	public partial class ElasticClient
+	{
+		/// <inheritdoc cref="ResumeFollowIndex(IndexName, System.Func{Nest.ResumeFollowIndexDescriptor,Nest.IResumeFollowIndexRequest})" />
+		public IResumeFollowIndexResponse ResumeFollowIndex(IndexName index, Func<ResumeFollowIndexDescriptor, IResumeFollowIndexRequest> selector = null) =>
+			ResumeFollowIndex(selector.InvokeOrDefault(new ResumeFollowIndexDescriptor(index)));
+
+		/// <inheritdoc cref="ResumeFollowIndex(IndexName, System.Func{Nest.ResumeFollowIndexDescriptor,Nest.IResumeFollowIndexRequest})" />
+		public IResumeFollowIndexResponse ResumeFollowIndex(IResumeFollowIndexRequest request) =>
+			Dispatcher.Dispatch<IResumeFollowIndexRequest, ResumeFollowIndexRequestParameters, ResumeFollowIndexResponse>(
+				request,
+				(p, d) => LowLevelDispatch.CcrResumeFollowDispatch<ResumeFollowIndexResponse>(p, d)
+			);
+
+		/// <inheritdoc cref="ResumeFollowIndex(IndexName, System.Func{Nest.ResumeFollowIndexDescriptor,Nest.IResumeFollowIndexRequest})" />
+		public Task<IResumeFollowIndexResponse> ResumeFollowIndexAsync(IndexName index, Func<ResumeFollowIndexDescriptor, IResumeFollowIndexRequest> selector = null,
+			CancellationToken cancellationToken = default
+		) =>
+			ResumeFollowIndexAsync(selector.InvokeOrDefault(new ResumeFollowIndexDescriptor(index)), cancellationToken);
+
+		/// <inheritdoc cref="ResumeFollowIndex(IndexName, System.Func{Nest.ResumeFollowIndexDescriptor,Nest.IResumeFollowIndexRequest})" />
+		public Task<IResumeFollowIndexResponse> ResumeFollowIndexAsync(IResumeFollowIndexRequest request, CancellationToken cancellationToken = default) =>
+			Dispatcher.DispatchAsync<IResumeFollowIndexRequest, ResumeFollowIndexRequestParameters, ResumeFollowIndexResponse, IResumeFollowIndexResponse>(
+				request,
+				cancellationToken,
+				(p, d, c) => LowLevelDispatch.CcrResumeFollowDispatchAsync<ResumeFollowIndexResponse>(p, d, c)
+			);
+	}
+}
diff --git a/src/Nest/XPack/CrossClusterReplication/Follow/ResumeFollowIndex/ResumeFollowIndexRequest.cs b/src/Nest/XPack/CrossClusterReplication/Follow/ResumeFollowIndex/ResumeFollowIndexRequest.cs
new file mode 100644
index 00000000000..e14a239f857
--- /dev/null
+++ b/src/Nest/XPack/CrossClusterReplication/Follow/ResumeFollowIndex/ResumeFollowIndexRequest.cs
@@ -0,0 +1,135 @@
+using System;
+using Newtonsoft.Json;
+
+namespace Nest
+{
+	/// <summary>
+	/// Resumes a follower index that has been paused either explicitly with the pause follower API or
+	/// implicitly due to execution that can not be retried due to failure during following. When this API returns,
+	/// the follower index will resume fetching operations from the leader index.
+	/// </summary>
+	[MapsApi("ccr.resume_follow.json")]
+	[ContractJsonConverter(typeof(ReadAsTypeJsonConverter<ResumeFollowIndexRequest>))]
+	public partial interface IResumeFollowIndexRequest
+	{
+		/// <inheritdoc cref="ICreateFollowIndexRequest.MaxReadRequestOperationCount"/>
+		[JsonProperty("max_read_request_operation_count")]
+		long? MaxReadRequestOperationCount { get; set; }
+
+		/// <inheritdoc cref="ICreateFollowIndexRequest.MaxOutstandingReadRequests"/>
+		[JsonProperty("max_outstanding_read_requests")]
+		long? MaxOutstandingReadRequests { get; set; }
+
+		/// <inheritdoc cref="ICreateFollowIndexRequest.MaxRequestSize"/>
+		[JsonProperty("max_read_request_size")]
+		string MaxRequestSize { get; set; }
+
+		/// <inheritdoc cref="ICreateFollowIndexRequest.MaxWriteRequestOperationCount"/>
+		[JsonProperty("max_write_request_operation_count")]
+		long? MaxWriteRequestOperationCount { get; set; }
+
+		/// <inheritdoc cref="ICreateFollowIndexRequest.MaxWriteRequestSize"/>
+		[JsonProperty("max_write_request_size")]
+		string MaxWriteRequestSize { get; set; }
+
+		/// <inheritdoc cref="ICreateFollowIndexRequest.MaxOutstandingWriteRequests"/>
+		[JsonProperty("max_outstanding_write_requests")]
+		long? MaxOutstandingWriteRequests { get; set; }
+
+		/// <inheritdoc cref="ICreateFollowIndexRequest.MaxWriteBufferCount"/>
+		[JsonProperty("max_write_buffer_count")]
+		long? MaxWriteBufferCount { get; set; }
+
+		/// <inheritdoc cref="ICreateFollowIndexRequest.MaxWriteBufferSize"/>
+		[JsonProperty("max_write_buffer_size")]
+		string MaxWriteBufferSize { get; set; }
+
+		/// <inheritdoc cref="ICreateFollowIndexRequest.MaxRetryDelay"/>
+		[JsonProperty("max_retry_delay")]
+		Time MaxRetryDelay { get; set; }
+
+		/// <inheritdoc cref="ICreateFollowIndexRequest.ReadPollTimeout"/>
+		[JsonProperty("read_poll_timeout")]
+		Time ReadPollTimeout { get; set; }
+	}
+
+	/// <inheritdoc cref="IResumeFollowIndexRequest"/>
+	public partial class ResumeFollowIndexRequest
+	{
+		/// <inheritdoc cref="ICreateFollowIndexRequest.MaxReadRequestOperationCount"/>
+		public long? MaxReadRequestOperationCount { get; set; }
+
+		/// <inheritdoc cref="ICreateFollowIndexRequest.MaxOutstandingReadRequests"/>
+		public long? MaxOutstandingReadRequests { get; set; }
+
+		/// <inheritdoc cref="ICreateFollowIndexRequest.MaxRequestSize"/>
+		public string MaxRequestSize { get; set; }
+
+		/// <inheritdoc cref="ICreateFollowIndexRequest.MaxWriteRequestOperationCount"/>
+		public long? MaxWriteRequestOperationCount { get; set; }
+
+		/// <inheritdoc cref="ICreateFollowIndexRequest.MaxWriteRequestSize"/>
+		public string MaxWriteRequestSize { get; set; }
+
+		/// <inheritdoc cref="ICreateFollowIndexRequest.MaxOutstandingWriteRequests"/>
+		public long? MaxOutstandingWriteRequests { get; set; }
+
+		/// <inheritdoc cref="ICreateFollowIndexRequest.MaxWriteBufferCount"/>
+		public long? MaxWriteBufferCount { get; set; }
+
+		/// <inheritdoc cref="ICreateFollowIndexRequest.MaxWriteBufferSize"/>
+		public string MaxWriteBufferSize { get; set; }
+
+		/// <inheritdoc cref="ICreateFollowIndexRequest.MaxRetryDelay"/>
+		public Time MaxRetryDelay { get; set; }
+
+		/// <inheritdoc cref="ICreateFollowIndexRequest.ReadPollTimeout"/>
+		public Time ReadPollTimeout { get; set; }
+
+	}
+
+	/// <inheritdoc cref="IResumeFollowIndexRequest"/>
+	public partial class ResumeFollowIndexDescriptor
+	{
+		long? IResumeFollowIndexRequest.MaxReadRequestOperationCount { get; set; }
+		long? IResumeFollowIndexRequest.MaxOutstandingReadRequests { get; set; }
+		string IResumeFollowIndexRequest.MaxRequestSize { get; set; }
+		long? IResumeFollowIndexRequest.MaxWriteRequestOperationCount { get; set; }
+		string IResumeFollowIndexRequest.MaxWriteRequestSize { get; set; }
+		long? IResumeFollowIndexRequest.MaxOutstandingWriteRequests { get; set; }
+		long? IResumeFollowIndexRequest.MaxWriteBufferCount { get; set; }
+		string IResumeFollowIndexRequest.MaxWriteBufferSize { get; set; }
+		Time IResumeFollowIndexRequest.MaxRetryDelay { get; set; }
+		Time IResumeFollowIndexRequest.ReadPollTimeout { get; set; }
+
+		/// <inheritdoc cref="ICreateFollowIndexRequest.MaxReadRequestOperationCount"/>
+		public ResumeFollowIndexDescriptor MaxReadRequestOperationCount(long? max) => Assign(a => a.MaxReadRequestOperationCount = max);
+
+		/// <inheritdoc cref="ICreateFollowIndexRequest.MaxOutstandingReadRequests"/>
+		public ResumeFollowIndexDescriptor MaxOutstandingReadRequests(long? max) => Assign(a => a.MaxOutstandingReadRequests = max);
+
+		/// <inheritdoc cref="ICreateFollowIndexRequest.MaxRequestSize"/>
+		public ResumeFollowIndexDescriptor MaxRequestSize(string maxRequestSize) => Assign(a => a.MaxRequestSize = maxRequestSize);
+
+		/// <inheritdoc cref="ICreateFollowIndexRequest.MaxWriteRequestOperationCount"/>
+		public ResumeFollowIndexDescriptor MaxWriteRequestOperationCount(long? max) => Assign(a => a.MaxWriteRequestOperationCount = max);
+
+		/// <inheritdoc cref="ICreateFollowIndexRequest.MaxWriteRequestSize"/>
+		public ResumeFollowIndexDescriptor MaxWriteRequestSize(string size) => Assign(a => a.MaxWriteRequestSize = size);
+
+		/// <inheritdoc cref="ICreateFollowIndexRequest.MaxOutstandingWriteRequests"/>
+		public ResumeFollowIndexDescriptor MaxOutstandingWriteRequests(long? max) => Assign(a => a.MaxOutstandingWriteRequests = max);
+
+		/// <inheritdoc cref="ICreateFollowIndexRequest.MaxWriteBufferCount"/>
+		public ResumeFollowIndexDescriptor MaxWriteBufferCount(long? max) => Assign(a => a.MaxWriteBufferCount = max);
+
+		/// <inheritdoc cref="ICreateFollowIndexRequest.MaxWriteBufferSize"/>
+		public ResumeFollowIndexDescriptor MaxWriteBufferSize(string max) => Assign(a => a.MaxWriteBufferSize = max);
+
+		/// <inheritdoc cref="ICreateFollowIndexRequest.MaxRetryDelay"/>
+		public ResumeFollowIndexDescriptor MaxRetryDelay(Time maxRetryDelay) => Assign(a => a.MaxRetryDelay = maxRetryDelay);
+
+		/// <inheritdoc cref="ICreateFollowIndexRequest.ReadPollTimeout"/>
+		public ResumeFollowIndexDescriptor ReadPollTimeout(Time readPollTimeout) => Assign(a => a.ReadPollTimeout = readPollTimeout);
+	}
+}
diff --git a/src/Nest/XPack/CrossClusterReplication/Follow/ResumeFollowIndex/ResumeFollowIndexResponse.cs b/src/Nest/XPack/CrossClusterReplication/Follow/ResumeFollowIndex/ResumeFollowIndexResponse.cs
new file mode 100644
index 00000000000..ed9eb6d5aa7
--- /dev/null
+++ b/src/Nest/XPack/CrossClusterReplication/Follow/ResumeFollowIndex/ResumeFollowIndexResponse.cs
@@ -0,0 +1,9 @@
+using System.Collections.Generic;
+using Newtonsoft.Json;
+
+namespace Nest
+{
+	public interface IResumeFollowIndexResponse : IAcknowledgedResponse { }
+
+	public class ResumeFollowIndexResponse : AcknowledgedResponseBase, IResumeFollowIndexResponse { }
+}
diff --git a/src/Nest/XPack/CrossClusterReplication/Follow/UnfollowIndex/ElasticClient-UnfollowIndex.cs b/src/Nest/XPack/CrossClusterReplication/Follow/UnfollowIndex/ElasticClient-UnfollowIndex.cs
new file mode 100644
index 00000000000..02392f3de47
--- /dev/null
+++ b/src/Nest/XPack/CrossClusterReplication/Follow/UnfollowIndex/ElasticClient-UnfollowIndex.cs
@@ -0,0 +1,56 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using Elasticsearch.Net;
+
+namespace Nest
+{
+	public partial interface IElasticClient
+	{
+		/// <summary>
+		/// Stops the following task associated with a follower index and removes index metadata and settings associated with
+		/// cross-cluster replication. This enables the index to treated as a regular index. The follower index must be paused and closed
+		/// before invoking the unfollow API.
+		/// </summary>
+		IUnfollowIndexResponse UnfollowIndex(IndexName index, Func<UnfollowIndexDescriptor, IUnfollowIndexRequest> selector = null);
+
+		/// <inheritdoc cref="UnfollowIndex(IndexName, System.Func{Nest.UnfollowIndexDescriptor,Nest.IUnfollowIndexRequest})" />
+		IUnfollowIndexResponse UnfollowIndex(IUnfollowIndexRequest request);
+
+		/// <inheritdoc cref="UnfollowIndex(IndexName, System.Func{Nest.UnfollowIndexDescriptor,Nest.IUnfollowIndexRequest})" />
+		Task<IUnfollowIndexResponse> UnfollowIndexAsync(IndexName index, Func<UnfollowIndexDescriptor, IUnfollowIndexRequest> selector = null,
+			CancellationToken cancellationToken = default
+		);
+
+		/// <inheritdoc cref="UnfollowIndex(IndexName, System.Func{Nest.UnfollowIndexDescriptor,Nest.IUnfollowIndexRequest})" />
+		Task<IUnfollowIndexResponse> UnfollowIndexAsync(IUnfollowIndexRequest request, CancellationToken cancellationToken = default);
+	}
+
+	public partial class ElasticClient
+	{
+		/// <inheritdoc cref="UnfollowIndex(IndexName, System.Func{Nest.UnfollowIndexDescriptor,Nest.IUnfollowIndexRequest})" />
+		public IUnfollowIndexResponse UnfollowIndex(IndexName index, Func<UnfollowIndexDescriptor, IUnfollowIndexRequest> selector = null) =>
+			UnfollowIndex(selector.InvokeOrDefault(new UnfollowIndexDescriptor(index)));
+
+		/// <inheritdoc cref="UnfollowIndex(IndexName, System.Func{Nest.UnfollowIndexDescriptor,Nest.IUnfollowIndexRequest})" />
+		public IUnfollowIndexResponse UnfollowIndex(IUnfollowIndexRequest request) =>
+			Dispatcher.Dispatch<IUnfollowIndexRequest, UnfollowIndexRequestParameters, UnfollowIndexResponse>(
+				request,
+				(p, d) => LowLevelDispatch.CcrUnfollowDispatch<UnfollowIndexResponse>(p)
+			);
+
+		/// <inheritdoc cref="UnfollowIndex(IndexName, System.Func{Nest.UnfollowIndexDescriptor,Nest.IUnfollowIndexRequest})" />
+		public Task<IUnfollowIndexResponse> UnfollowIndexAsync(IndexName index, Func<UnfollowIndexDescriptor, IUnfollowIndexRequest> selector = null,
+			CancellationToken cancellationToken = default
+		) =>
+			UnfollowIndexAsync(selector.InvokeOrDefault(new UnfollowIndexDescriptor(index)), cancellationToken);
+
+		/// <inheritdoc cref="UnfollowIndex(IndexName, System.Func{Nest.UnfollowIndexDescriptor,Nest.IUnfollowIndexRequest})" />
+		public Task<IUnfollowIndexResponse> UnfollowIndexAsync(IUnfollowIndexRequest request, CancellationToken cancellationToken = default) =>
+			Dispatcher.DispatchAsync<IUnfollowIndexRequest, UnfollowIndexRequestParameters, UnfollowIndexResponse, IUnfollowIndexResponse>(
+				request,
+				cancellationToken,
+				(p, d, c) => LowLevelDispatch.CcrUnfollowDispatchAsync<UnfollowIndexResponse>(p, c)
+			);
+	}
+}
diff --git a/src/Nest/XPack/CrossClusterReplication/Follow/UnfollowIndex/UnfollowIndexRequest.cs b/src/Nest/XPack/CrossClusterReplication/Follow/UnfollowIndex/UnfollowIndexRequest.cs
new file mode 100644
index 00000000000..c5cc5476559
--- /dev/null
+++ b/src/Nest/XPack/CrossClusterReplication/Follow/UnfollowIndex/UnfollowIndexRequest.cs
@@ -0,0 +1,20 @@
+using System;
+using Newtonsoft.Json;
+
+namespace Nest
+{
+	/// <summary>
+	/// Stops the following task associated with a follower index and removes index metadata and settings associated with
+	/// cross-cluster replication. This enables the index to treated as a regular index. The follower index must be paused and closed
+	/// before invoking the unfollow API.
+	/// </summary>
+	[MapsApi("ccr.unfollow.json")]
+	[ContractJsonConverter(typeof(ReadAsTypeJsonConverter<UnfollowIndexRequest>))]
+	public partial interface IUnfollowIndexRequest { }
+
+	/// <inheritdoc cref="IUnfollowIndexRequest"/>
+	public partial class UnfollowIndexRequest { }
+
+	/// <inheritdoc cref="IUnfollowIndexRequest"/>
+	public partial class UnfollowIndexDescriptor { }
+}
diff --git a/src/Nest/XPack/CrossClusterReplication/Follow/UnfollowIndex/UnfollowIndexResponse.cs b/src/Nest/XPack/CrossClusterReplication/Follow/UnfollowIndex/UnfollowIndexResponse.cs
new file mode 100644
index 00000000000..1cc89697287
--- /dev/null
+++ b/src/Nest/XPack/CrossClusterReplication/Follow/UnfollowIndex/UnfollowIndexResponse.cs
@@ -0,0 +1,6 @@
+namespace Nest
+{
+	public interface IUnfollowIndexResponse : IAcknowledgedResponse { }
+
+	public class UnfollowIndexResponse : AcknowledgedResponseBase, IUnfollowIndexResponse { }
+}
diff --git a/src/Nest/XPack/CrossClusterReplication/Stats/CcrStatsRequest.cs b/src/Nest/XPack/CrossClusterReplication/Stats/CcrStatsRequest.cs
new file mode 100644
index 00000000000..4e97cb4bedb
--- /dev/null
+++ b/src/Nest/XPack/CrossClusterReplication/Stats/CcrStatsRequest.cs
@@ -0,0 +1,20 @@
+using System;
+using Newtonsoft.Json;
+
+namespace Nest
+{
+	/// <summary>
+	/// Gets cross-cluster replication stats. Returns all stats related to cross-cluster replication.
+	/// In particular, this API returns stats about auto-following, and returns the same shard-level stats as in the get
+	/// follower stats API. <see cref="IElasticClient.FollowIndexStats(Nest.Indices,System.Func{Nest.FollowIndexStatsDescriptor,Nest.IFollowIndexStatsRequest})"/>
+	/// </summary>
+	[MapsApi("ccr.stats.json")]
+	[ContractJsonConverter(typeof(ReadAsTypeJsonConverter<CcrStatsRequest>))]
+	public partial interface ICcrStatsRequest { }
+
+	/// <inheritdoc cref="ICcrStatsRequest"/>
+	public partial class CcrStatsRequest { }
+
+	/// <inheritdoc cref="ICcrStatsRequest"/>
+	public partial class CcrStatsDescriptor { }
+}
diff --git a/src/Nest/XPack/CrossClusterReplication/Stats/CcrStatsResponse.cs b/src/Nest/XPack/CrossClusterReplication/Stats/CcrStatsResponse.cs
new file mode 100644
index 00000000000..6f012eafca7
--- /dev/null
+++ b/src/Nest/XPack/CrossClusterReplication/Stats/CcrStatsResponse.cs
@@ -0,0 +1,59 @@
+using System.Collections.Generic;
+using Elasticsearch.Net;
+using Newtonsoft.Json;
+
+namespace Nest
+{
+	public interface ICcrStatsResponse : IResponse
+	{
+		[JsonProperty("auto_follow_stats")]
+		CcrAutoFollowStats AutoFollowStats { get; }
+
+		[JsonProperty("follow_stats")]
+		CcrFollowStats FollowStats { get; }
+	}
+
+	public class CcrStatsResponse : ResponseBase, ICcrStatsResponse
+	{
+		/// <inheritdoc cref="ICcrStatsResponse.AutoFollowStats"/>
+		public CcrAutoFollowStats AutoFollowStats { get; internal set; }
+
+		/// <inheritdoc cref="ICcrStatsResponse.FollowStats"/>
+		public CcrFollowStats FollowStats { get; internal set; }
+	}
+
+
+	public class CcrFollowStats
+	{
+		/// <inheritdoc cref="IFollowIndexStatsResponse.Indices" />
+		[JsonProperty("indices")]
+		public IReadOnlyCollection<FollowIndexStats> Indices { get; internal set; } = EmptyReadOnly<FollowIndexStats>.Collection;
+	}
+
+	public class CcrAutoFollowStats
+	{
+
+		/// <summary>
+		/// the number of indices that the auto-follow coordinator failed to automatically follow; the causes of recent failures are
+		/// captured in the logs of the elected master node, and in the auto_follow_stats.recent_auto_follow_errors field
+		/// </summary>
+		[JsonProperty("number_of_failed_follow_indices")]
+		public long NumberOfFailedFollowIndices { get; internal set; }
+
+		/// <summary>
+		/// the number of times that the auto-follow coordinator failed to retrieve the cluster state from a
+		/// remote cluster registered in a collection of auto-follow patterns
+		/// </summary>
+		[JsonProperty("number_of_failed_remote_cluster_state_requests")]
+		public long NumberOfFailedRemoteClusterStateRequests { get; internal set; }
+
+		/// <summary> the number of indices that the auto-follow coordinator successfully followed </summary>
+		[JsonProperty("number_of_successful_follow_indices")]
+		public long NumberOfSuccessfulFollowIndices { get; internal set; }
+
+		/// <summary> an array of objects representing failures by the auto-follow coordinator </summary>
+		[JsonProperty("recent_auto_follow_errors")]
+		public IReadOnlyCollection<ErrorCause> RecentAutoFollowErrors { get; internal set; } = EmptyReadOnly<ErrorCause>.Collection;
+
+	}
+}
diff --git a/src/Nest/XPack/CrossClusterReplication/Stats/ElasticClient-CcrStats.cs b/src/Nest/XPack/CrossClusterReplication/Stats/ElasticClient-CcrStats.cs
new file mode 100644
index 00000000000..60fcf4542a7
--- /dev/null
+++ b/src/Nest/XPack/CrossClusterReplication/Stats/ElasticClient-CcrStats.cs
@@ -0,0 +1,56 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using Elasticsearch.Net;
+
+namespace Nest
+{
+	public partial interface IElasticClient
+	{
+		/// <summary>
+		/// Gets cross-cluster replication stats. This API will return all stats related to cross-cluster replication.
+		/// In particular, this API returns stats about auto-following, and returns the same shard-level stats as in the get
+		/// follower stats API. <see cref="IElasticClient.FollowIndexStats(Nest.Indices,System.Func{Nest.FollowIndexStatsDescriptor,Nest.IFollowIndexStatsRequest})"/>
+		/// </summary>
+		ICcrStatsResponse CcrStats(Func<CcrStatsDescriptor, ICcrStatsRequest> selector = null);
+
+		/// <inheritdoc cref="CcrStats(System.Func{Nest.CcrStatsDescriptor,Nest.ICcrStatsRequest})" />
+		ICcrStatsResponse CcrStats(ICcrStatsRequest request);
+
+		/// <inheritdoc cref="CcrStats(System.Func{Nest.CcrStatsDescriptor,Nest.ICcrStatsRequest})" />
+		Task<ICcrStatsResponse> CcrStatsAsync(Func<CcrStatsDescriptor, ICcrStatsRequest> selector = null,
+			CancellationToken cancellationToken = default(CancellationToken)
+		);
+
+		/// <inheritdoc cref="CcrStats(System.Func{Nest.CcrStatsDescriptor,Nest.ICcrStatsRequest})" />
+		Task<ICcrStatsResponse> CcrStatsAsync(ICcrStatsRequest request, CancellationToken cancellationToken = default);
+	}
+
+	public partial class ElasticClient
+	{
+		/// <inheritdoc cref="CcrStats(System.Func{Nest.CcrStatsDescriptor,Nest.ICcrStatsRequest})" />
+		public ICcrStatsResponse CcrStats(Func<CcrStatsDescriptor, ICcrStatsRequest> selector = null) =>
+			CcrStats(selector.InvokeOrDefault(new CcrStatsDescriptor()));
+
+		/// <inheritdoc cref="CcrStats(System.Func{Nest.CcrStatsDescriptor,Nest.ICcrStatsRequest})" />
+		public ICcrStatsResponse CcrStats(ICcrStatsRequest request) =>
+			Dispatcher.Dispatch<ICcrStatsRequest, CcrStatsRequestParameters, CcrStatsResponse>(
+				request,
+				(p, d) => LowLevelDispatch.CcrStatsDispatch<CcrStatsResponse>(p)
+			);
+
+		/// <inheritdoc cref="CcrStats(System.Func{Nest.CcrStatsDescriptor,Nest.ICcrStatsRequest})" />
+		public Task<ICcrStatsResponse> CcrStatsAsync(Func<CcrStatsDescriptor, ICcrStatsRequest> selector = null,
+			CancellationToken cancellationToken = default(CancellationToken)
+		) =>
+			CcrStatsAsync(selector.InvokeOrDefault(new CcrStatsDescriptor()), cancellationToken);
+
+		/// <inheritdoc cref="CcrStats(System.Func{Nest.CcrStatsDescriptor,Nest.ICcrStatsRequest})" />
+		public Task<ICcrStatsResponse> CcrStatsAsync(ICcrStatsRequest request, CancellationToken cancellationToken = default) =>
+			Dispatcher.DispatchAsync<ICcrStatsRequest, CcrStatsRequestParameters, CcrStatsResponse, ICcrStatsResponse>(
+				request,
+				cancellationToken,
+				(p, d, c) => LowLevelDispatch.CcrStatsDispatchAsync<CcrStatsResponse>(p, c)
+			);
+	}
+}
diff --git a/src/Nest/_Generated/_Descriptors.generated.cs b/src/Nest/_Generated/_Descriptors.generated.cs
index 8df5196319c..f82cea82ac4 100644
--- a/src/Nest/_Generated/_Descriptors.generated.cs
+++ b/src/Nest/_Generated/_Descriptors.generated.cs
@@ -3831,6 +3831,144 @@ public UpdateByQueryDescriptor(Indices index) : base(r=>r.Required("index", inde
 		///<summary>The number of slices this task should be divided into. Defaults to 1 meaning the task isn't sliced into subtasks.</summary>
 		public UpdateByQueryDescriptor<T> Slices(long? slices) => Qs("slices", slices);
 	}
+	///<summary>descriptor for CcrDeleteAutoFollowPattern <pre>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-delete-auto-follow-pattern.html</pre></summary>
+	public partial class DeleteAutoFollowPatternDescriptor  : RequestDescriptorBase<DeleteAutoFollowPatternDescriptor,DeleteAutoFollowPatternRequestParameters, IDeleteAutoFollowPatternRequest>, IDeleteAutoFollowPatternRequest
+	{ 
+		/// <summary>/_ccr/auto_follow/{name}</summary>
+		///<param name="name"> this parameter is required</param>
+		public DeleteAutoFollowPatternDescriptor(Name name) : base(r=>r.Required("name", name)){}
+		// values part of the url path
+		Name IDeleteAutoFollowPatternRequest.Name => Self.RouteValues.Get<Name>("name");
+
+		// Request parameters
+
+	}
+	///<summary>descriptor for CcrFollow <pre>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-put-follow.html</pre></summary>
+	public partial class CreateFollowIndexDescriptor  : RequestDescriptorBase<CreateFollowIndexDescriptor,CreateFollowIndexRequestParameters, ICreateFollowIndexRequest>, ICreateFollowIndexRequest
+	{ 
+		/// <summary>/{index}/_ccr/follow</summary>
+		///<param name="index"> this parameter is required</param>
+		public CreateFollowIndexDescriptor(IndexName index) : base(r=>r.Required("index", index)){}
+		// values part of the url path
+		IndexName ICreateFollowIndexRequest.Index => Self.RouteValues.Get<IndexName>("index");
+
+		///<summary>The name of the follower index</summary>
+		public CreateFollowIndexDescriptor Index(IndexName index) => Assign(a=>a.RouteValues.Required("index", index));
+
+		///<summary>a shortcut into calling Index(typeof(TOther))</summary>
+		public CreateFollowIndexDescriptor Index<TOther>() where TOther : class => Assign(a=>a.RouteValues.Required("index", (IndexName)typeof(TOther)));
+
+		// Request parameters
+
+	}
+	///<summary>descriptor for CcrFollowStats <pre>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-get-follow-stats.html</pre></summary>
+	public partial class FollowIndexStatsDescriptor  : RequestDescriptorBase<FollowIndexStatsDescriptor,FollowIndexStatsRequestParameters, IFollowIndexStatsRequest>, IFollowIndexStatsRequest
+	{ 
+		/// <summary>/{index}/_ccr/stats</summary>
+		public FollowIndexStatsDescriptor() : base(){}
+		// values part of the url path
+		Indices IFollowIndexStatsRequest.Index => Self.RouteValues.Get<Indices>("index");
+
+		///<summary>A comma-separated list of index patterns; use `_all` to perform the operation on all indices</summary>
+		public FollowIndexStatsDescriptor Index(Indices index) => Assign(a=>a.RouteValues.Optional("index", index));
+
+		///<summary>a shortcut into calling Index(typeof(TOther))</summary>
+		public FollowIndexStatsDescriptor Index<TOther>() where TOther : class => Assign(a=>a.RouteValues.Optional("index", (Indices)typeof(TOther)));
+
+		///<summary>A shortcut into calling Index(Indices.All)</summary>
+		public FollowIndexStatsDescriptor AllIndices() => this.Index(Indices.All);
+
+		// Request parameters
+
+	}
+	///<summary>descriptor for CcrGetAutoFollowPattern <pre>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-get-auto-follow-pattern.html</pre></summary>
+	public partial class GetAutoFollowPatternDescriptor  : RequestDescriptorBase<GetAutoFollowPatternDescriptor,GetAutoFollowPatternRequestParameters, IGetAutoFollowPatternRequest>, IGetAutoFollowPatternRequest
+	{ 
+		/// <summary>/_ccr/auto_follow</summary>
+		public GetAutoFollowPatternDescriptor() : base(){}
+		// values part of the url path
+		Name IGetAutoFollowPatternRequest.Name => Self.RouteValues.Get<Name>("name");
+
+		///<summary>The name of the auto follow pattern.</summary>
+		public GetAutoFollowPatternDescriptor Name(Name name) => Assign(a=>a.RouteValues.Optional("name", name));
+
+		// Request parameters
+
+	}
+	///<summary>descriptor for CcrPauseFollow <pre>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-post-pause-follow.html</pre></summary>
+	public partial class PauseFollowIndexDescriptor  : RequestDescriptorBase<PauseFollowIndexDescriptor,PauseFollowIndexRequestParameters, IPauseFollowIndexRequest>, IPauseFollowIndexRequest
+	{ 
+		/// <summary>/{index}/_ccr/pause_follow</summary>
+		///<param name="index"> this parameter is required</param>
+		public PauseFollowIndexDescriptor(IndexName index) : base(r=>r.Required("index", index)){}
+		// values part of the url path
+		IndexName IPauseFollowIndexRequest.Index => Self.RouteValues.Get<IndexName>("index");
+
+		///<summary>The name of the follower index that should pause following its leader index.</summary>
+		public PauseFollowIndexDescriptor Index(IndexName index) => Assign(a=>a.RouteValues.Required("index", index));
+
+		///<summary>a shortcut into calling Index(typeof(TOther))</summary>
+		public PauseFollowIndexDescriptor Index<TOther>() where TOther : class => Assign(a=>a.RouteValues.Required("index", (IndexName)typeof(TOther)));
+
+		// Request parameters
+
+	}
+	///<summary>descriptor for CcrPutAutoFollowPattern <pre>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-put-auto-follow-pattern.html</pre></summary>
+	public partial class CreateAutoFollowPatternDescriptor  : RequestDescriptorBase<CreateAutoFollowPatternDescriptor,CreateAutoFollowPatternRequestParameters, ICreateAutoFollowPatternRequest>, ICreateAutoFollowPatternRequest
+	{ 
+		/// <summary>/_ccr/auto_follow/{name}</summary>
+		///<param name="name"> this parameter is required</param>
+		public CreateAutoFollowPatternDescriptor(Name name) : base(r=>r.Required("name", name)){}
+		// values part of the url path
+		Name ICreateAutoFollowPatternRequest.Name => Self.RouteValues.Get<Name>("name");
+
+		// Request parameters
+
+	}
+	///<summary>descriptor for CcrResumeFollow <pre>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-post-resume-follow.html</pre></summary>
+	public partial class ResumeFollowIndexDescriptor  : RequestDescriptorBase<ResumeFollowIndexDescriptor,ResumeFollowIndexRequestParameters, IResumeFollowIndexRequest>, IResumeFollowIndexRequest
+	{ 
+		/// <summary>/{index}/_ccr/resume_follow</summary>
+		///<param name="index"> this parameter is required</param>
+		public ResumeFollowIndexDescriptor(IndexName index) : base(r=>r.Required("index", index)){}
+		// values part of the url path
+		IndexName IResumeFollowIndexRequest.Index => Self.RouteValues.Get<IndexName>("index");
+
+		///<summary>The name of the follow index to resume following.</summary>
+		public ResumeFollowIndexDescriptor Index(IndexName index) => Assign(a=>a.RouteValues.Required("index", index));
+
+		///<summary>a shortcut into calling Index(typeof(TOther))</summary>
+		public ResumeFollowIndexDescriptor Index<TOther>() where TOther : class => Assign(a=>a.RouteValues.Required("index", (IndexName)typeof(TOther)));
+
+		// Request parameters
+
+	}
+	///<summary>descriptor for CcrStats <pre>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-get-stats.html</pre></summary>
+	public partial class CcrStatsDescriptor  : RequestDescriptorBase<CcrStatsDescriptor,CcrStatsRequestParameters, ICcrStatsRequest>, ICcrStatsRequest
+	{ 
+		// values part of the url path
+
+		// Request parameters
+
+	}
+	///<summary>descriptor for CcrUnfollow <pre>http://www.elastic.co/guide/en/elasticsearch/reference/current</pre></summary>
+	public partial class UnfollowIndexDescriptor  : RequestDescriptorBase<UnfollowIndexDescriptor,UnfollowIndexRequestParameters, IUnfollowIndexRequest>, IUnfollowIndexRequest
+	{ 
+		/// <summary>/{index}/_ccr/unfollow</summary>
+		///<param name="index"> this parameter is required</param>
+		public UnfollowIndexDescriptor(IndexName index) : base(r=>r.Required("index", index)){}
+		// values part of the url path
+		IndexName IUnfollowIndexRequest.Index => Self.RouteValues.Get<IndexName>("index");
+
+		///<summary>The name of the follower index that should be turned into a regular index.</summary>
+		public UnfollowIndexDescriptor Index(IndexName index) => Assign(a=>a.RouteValues.Required("index", index));
+
+		///<summary>a shortcut into calling Index(typeof(TOther))</summary>
+		public UnfollowIndexDescriptor Index<TOther>() where TOther : class => Assign(a=>a.RouteValues.Required("index", (IndexName)typeof(TOther)));
+
+		// Request parameters
+
+	}
 	///<summary>descriptor for XpackGraphExplore <pre>https://www.elastic.co/guide/en/elasticsearch/reference/current/graph-explore-api.html</pre></summary>
 	public partial class GraphExploreDescriptor<T>  : RequestDescriptorBase<GraphExploreDescriptor<T>,GraphExploreRequestParameters, IGraphExploreRequest>, IGraphExploreRequest
 	{ 
diff --git a/src/Nest/_Generated/_LowLevelDispatch.generated.cs b/src/Nest/_Generated/_LowLevelDispatch.generated.cs
index 9d708722c0d..f85c3f6fab6 100644
--- a/src/Nest/_Generated/_LowLevelDispatch.generated.cs
+++ b/src/Nest/_Generated/_LowLevelDispatch.generated.cs
@@ -2924,6 +2924,202 @@ internal partial class LowLevelDispatch
 			throw InvalidDispatch("UpdateByQuery", p, new [] { POST }, "/{index}/_update_by_query", "/{index}/{type}/_update_by_query");
 		}
 		
+		internal TResponse CcrDeleteAutoFollowPatternDispatch<TResponse>(IRequest<DeleteAutoFollowPatternRequestParameters> p) where TResponse : class, IElasticsearchResponse, new()
+		{
+			switch(p.HttpMethod)
+			{
+				case DELETE:
+					if (AllSetNoFallback(p.RouteValues.Name)) return _lowLevel.CcrDeleteAutoFollowPattern<TResponse>(p.RouteValues.Name,p.RequestParameters);
+					break;
+			}
+			throw InvalidDispatch("CcrDeleteAutoFollowPattern", p, new [] { DELETE }, "/_ccr/auto_follow/{name}");
+		}
+		
+		internal Task<TResponse> CcrDeleteAutoFollowPatternDispatchAsync<TResponse>(IRequest<DeleteAutoFollowPatternRequestParameters> p, CancellationToken ct) where TResponse : class, IElasticsearchResponse, new()
+		{
+			switch(p.HttpMethod)
+			{
+				case DELETE:
+					if (AllSetNoFallback(p.RouteValues.Name)) return _lowLevel.CcrDeleteAutoFollowPatternAsync<TResponse>(p.RouteValues.Name,p.RequestParameters,ct);
+					break;
+			}
+			throw InvalidDispatch("CcrDeleteAutoFollowPattern", p, new [] { DELETE }, "/_ccr/auto_follow/{name}");
+		}
+		
+		internal TResponse CcrFollowDispatch<TResponse>(IRequest<CreateFollowIndexRequestParameters> p,SerializableData<ICreateFollowIndexRequest> body) where TResponse : class, IElasticsearchResponse, new()
+		{
+			switch(p.HttpMethod)
+			{
+				case PUT:
+					if (AllSetNoFallback(p.RouteValues.Index)) return _lowLevel.CcrFollow<TResponse>(p.RouteValues.Index,body,p.RequestParameters);
+					break;
+			}
+			throw InvalidDispatch("CcrFollow", p, new [] { PUT }, "/{index}/_ccr/follow");
+		}
+		
+		internal Task<TResponse> CcrFollowDispatchAsync<TResponse>(IRequest<CreateFollowIndexRequestParameters> p,SerializableData<ICreateFollowIndexRequest> body, CancellationToken ct) where TResponse : class, IElasticsearchResponse, new()
+		{
+			switch(p.HttpMethod)
+			{
+				case PUT:
+					if (AllSetNoFallback(p.RouteValues.Index)) return _lowLevel.CcrFollowAsync<TResponse>(p.RouteValues.Index,body,p.RequestParameters,ct);
+					break;
+			}
+			throw InvalidDispatch("CcrFollow", p, new [] { PUT }, "/{index}/_ccr/follow");
+		}
+		
+		internal TResponse CcrFollowStatsDispatch<TResponse>(IRequest<FollowIndexStatsRequestParameters> p) where TResponse : class, IElasticsearchResponse, new()
+		{
+			switch(p.HttpMethod)
+			{
+				case GET:
+					if (AllSet(p.RouteValues.Index)) return _lowLevel.CcrFollowStats<TResponse>(p.RouteValues.Index,p.RequestParameters);
+					break;
+			}
+			throw InvalidDispatch("CcrFollowStats", p, new [] { GET }, "/{index}/_ccr/stats");
+		}
+		
+		internal Task<TResponse> CcrFollowStatsDispatchAsync<TResponse>(IRequest<FollowIndexStatsRequestParameters> p, CancellationToken ct) where TResponse : class, IElasticsearchResponse, new()
+		{
+			switch(p.HttpMethod)
+			{
+				case GET:
+					if (AllSet(p.RouteValues.Index)) return _lowLevel.CcrFollowStatsAsync<TResponse>(p.RouteValues.Index,p.RequestParameters,ct);
+					break;
+			}
+			throw InvalidDispatch("CcrFollowStats", p, new [] { GET }, "/{index}/_ccr/stats");
+		}
+		
+		internal TResponse CcrGetAutoFollowPatternDispatch<TResponse>(IRequest<GetAutoFollowPatternRequestParameters> p) where TResponse : class, IElasticsearchResponse, new()
+		{
+			switch(p.HttpMethod)
+			{
+				case GET:
+					if (AllSet(p.RouteValues.Name)) return _lowLevel.CcrGetAutoFollowPattern<TResponse>(p.RouteValues.Name,p.RequestParameters);
+						return _lowLevel.CcrGetAutoFollowPattern<TResponse>(p.RequestParameters);
+			}
+			throw InvalidDispatch("CcrGetAutoFollowPattern", p, new [] { GET }, "/_ccr/auto_follow", "/_ccr/auto_follow/{name}");
+		}
+		
+		internal Task<TResponse> CcrGetAutoFollowPatternDispatchAsync<TResponse>(IRequest<GetAutoFollowPatternRequestParameters> p, CancellationToken ct) where TResponse : class, IElasticsearchResponse, new()
+		{
+			switch(p.HttpMethod)
+			{
+				case GET:
+					if (AllSet(p.RouteValues.Name)) return _lowLevel.CcrGetAutoFollowPatternAsync<TResponse>(p.RouteValues.Name,p.RequestParameters,ct);
+						return _lowLevel.CcrGetAutoFollowPatternAsync<TResponse>(p.RequestParameters,ct);
+			}
+			throw InvalidDispatch("CcrGetAutoFollowPattern", p, new [] { GET }, "/_ccr/auto_follow", "/_ccr/auto_follow/{name}");
+		}
+		
+		internal TResponse CcrPauseFollowDispatch<TResponse>(IRequest<PauseFollowIndexRequestParameters> p) where TResponse : class, IElasticsearchResponse, new()
+		{
+			switch(p.HttpMethod)
+			{
+				case POST:
+					if (AllSetNoFallback(p.RouteValues.Index)) return _lowLevel.CcrPauseFollow<TResponse>(p.RouteValues.Index,p.RequestParameters);
+					break;
+			}
+			throw InvalidDispatch("CcrPauseFollow", p, new [] { POST }, "/{index}/_ccr/pause_follow");
+		}
+		
+		internal Task<TResponse> CcrPauseFollowDispatchAsync<TResponse>(IRequest<PauseFollowIndexRequestParameters> p, CancellationToken ct) where TResponse : class, IElasticsearchResponse, new()
+		{
+			switch(p.HttpMethod)
+			{
+				case POST:
+					if (AllSetNoFallback(p.RouteValues.Index)) return _lowLevel.CcrPauseFollowAsync<TResponse>(p.RouteValues.Index,p.RequestParameters,ct);
+					break;
+			}
+			throw InvalidDispatch("CcrPauseFollow", p, new [] { POST }, "/{index}/_ccr/pause_follow");
+		}
+		
+		internal TResponse CcrPutAutoFollowPatternDispatch<TResponse>(IRequest<CreateAutoFollowPatternRequestParameters> p,SerializableData<ICreateAutoFollowPatternRequest> body) where TResponse : class, IElasticsearchResponse, new()
+		{
+			switch(p.HttpMethod)
+			{
+				case PUT:
+					if (AllSetNoFallback(p.RouteValues.Name)) return _lowLevel.CcrPutAutoFollowPattern<TResponse>(p.RouteValues.Name,body,p.RequestParameters);
+					break;
+			}
+			throw InvalidDispatch("CcrPutAutoFollowPattern", p, new [] { PUT }, "/_ccr/auto_follow/{name}");
+		}
+		
+		internal Task<TResponse> CcrPutAutoFollowPatternDispatchAsync<TResponse>(IRequest<CreateAutoFollowPatternRequestParameters> p,SerializableData<ICreateAutoFollowPatternRequest> body, CancellationToken ct) where TResponse : class, IElasticsearchResponse, new()
+		{
+			switch(p.HttpMethod)
+			{
+				case PUT:
+					if (AllSetNoFallback(p.RouteValues.Name)) return _lowLevel.CcrPutAutoFollowPatternAsync<TResponse>(p.RouteValues.Name,body,p.RequestParameters,ct);
+					break;
+			}
+			throw InvalidDispatch("CcrPutAutoFollowPattern", p, new [] { PUT }, "/_ccr/auto_follow/{name}");
+		}
+		
+		internal TResponse CcrResumeFollowDispatch<TResponse>(IRequest<ResumeFollowIndexRequestParameters> p,SerializableData<IResumeFollowIndexRequest> body) where TResponse : class, IElasticsearchResponse, new()
+		{
+			switch(p.HttpMethod)
+			{
+				case POST:
+					if (AllSetNoFallback(p.RouteValues.Index)) return _lowLevel.CcrResumeFollow<TResponse>(p.RouteValues.Index,body,p.RequestParameters);
+					break;
+			}
+			throw InvalidDispatch("CcrResumeFollow", p, new [] { POST }, "/{index}/_ccr/resume_follow");
+		}
+		
+		internal Task<TResponse> CcrResumeFollowDispatchAsync<TResponse>(IRequest<ResumeFollowIndexRequestParameters> p,SerializableData<IResumeFollowIndexRequest> body, CancellationToken ct) where TResponse : class, IElasticsearchResponse, new()
+		{
+			switch(p.HttpMethod)
+			{
+				case POST:
+					if (AllSetNoFallback(p.RouteValues.Index)) return _lowLevel.CcrResumeFollowAsync<TResponse>(p.RouteValues.Index,body,p.RequestParameters,ct);
+					break;
+			}
+			throw InvalidDispatch("CcrResumeFollow", p, new [] { POST }, "/{index}/_ccr/resume_follow");
+		}
+		
+		internal TResponse CcrStatsDispatch<TResponse>(IRequest<CcrStatsRequestParameters> p) where TResponse : class, IElasticsearchResponse, new()
+		{
+			switch(p.HttpMethod)
+			{
+				case GET:
+						return _lowLevel.CcrStats<TResponse>(p.RequestParameters);
+			}
+			throw InvalidDispatch("CcrStats", p, new [] { GET }, "/_ccr/stats");
+		}
+		
+		internal Task<TResponse> CcrStatsDispatchAsync<TResponse>(IRequest<CcrStatsRequestParameters> p, CancellationToken ct) where TResponse : class, IElasticsearchResponse, new()
+		{
+			switch(p.HttpMethod)
+			{
+				case GET:
+						return _lowLevel.CcrStatsAsync<TResponse>(p.RequestParameters,ct);
+			}
+			throw InvalidDispatch("CcrStats", p, new [] { GET }, "/_ccr/stats");
+		}
+		
+		internal TResponse CcrUnfollowDispatch<TResponse>(IRequest<UnfollowIndexRequestParameters> p) where TResponse : class, IElasticsearchResponse, new()
+		{
+			switch(p.HttpMethod)
+			{
+				case POST:
+					if (AllSetNoFallback(p.RouteValues.Index)) return _lowLevel.CcrUnfollow<TResponse>(p.RouteValues.Index,p.RequestParameters);
+					break;
+			}
+			throw InvalidDispatch("CcrUnfollow", p, new [] { POST }, "/{index}/_ccr/unfollow");
+		}
+		
+		internal Task<TResponse> CcrUnfollowDispatchAsync<TResponse>(IRequest<UnfollowIndexRequestParameters> p, CancellationToken ct) where TResponse : class, IElasticsearchResponse, new()
+		{
+			switch(p.HttpMethod)
+			{
+				case POST:
+					if (AllSetNoFallback(p.RouteValues.Index)) return _lowLevel.CcrUnfollowAsync<TResponse>(p.RouteValues.Index,p.RequestParameters,ct);
+					break;
+			}
+			throw InvalidDispatch("CcrUnfollow", p, new [] { POST }, "/{index}/_ccr/unfollow");
+		}
+		
 		internal TResponse XpackGraphExploreDispatch<TResponse>(IRequest<GraphExploreRequestParameters> p,SerializableData<IGraphExploreRequest> body) where TResponse : class, IElasticsearchResponse, new()
 		{
 			switch(p.HttpMethod)
diff --git a/src/Nest/_Generated/_Requests.generated.cs b/src/Nest/_Generated/_Requests.generated.cs
index 3cbeef9c641..b95093f2b27 100644
--- a/src/Nest/_Generated/_Requests.generated.cs
+++ b/src/Nest/_Generated/_Requests.generated.cs
@@ -862,6 +862,18 @@ public CatThreadPoolRequest(Names thread_pool_patterns) : base(r=>r.Optional("th
 		public bool? Verbose { get => Q<bool?>("v"); set => Q("v", value); }
 	}
 	[JsonObject(MemberSerialization = MemberSerialization.OptIn)]
+	public partial interface ICcrStatsRequest : IRequest<CcrStatsRequestParameters>
+	{
+	}
+	///<summary>Request parameters for CcrStats <pre>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-get-stats.html</pre></summary>
+	public partial class CcrStatsRequest : PlainRequestBase<CcrStatsRequestParameters>, ICcrStatsRequest
+	{
+		protected ICcrStatsRequest Self => this;
+		// values part of the url path
+
+		// Request parameters
+	}
+	[JsonObject(MemberSerialization = MemberSerialization.OptIn)]
 	public partial interface IChangePasswordRequest : IRequest<ChangePasswordRequestParameters>
 	{
 		Name Username { get; }
@@ -1351,6 +1363,40 @@ public CountRequest(Indices index, Types type) : base(r=>r.Optional("index", ind
 		public long? TerminateAfter { get => Q<long?>("terminate_after"); set => Q("terminate_after", value); }
 	}
 	[JsonObject(MemberSerialization = MemberSerialization.OptIn)]
+	public partial interface ICreateAutoFollowPatternRequest : IRequest<CreateAutoFollowPatternRequestParameters>
+	{
+		Name Name { get; }
+	}
+	///<summary>Request parameters for CcrPutAutoFollowPattern <pre>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-put-auto-follow-pattern.html</pre></summary>
+	public partial class CreateAutoFollowPatternRequest : PlainRequestBase<CreateAutoFollowPatternRequestParameters>, ICreateAutoFollowPatternRequest
+	{
+		protected ICreateAutoFollowPatternRequest Self => this;
+		///<summary>/_ccr/auto_follow/{name}</summary>
+		///<param name="name">this parameter is required</param>
+		public CreateAutoFollowPatternRequest(Name name) : base(r=>r.Required("name", name)){}
+		// values part of the url path
+		Name ICreateAutoFollowPatternRequest.Name => Self.RouteValues.Get<Name>("name");
+
+		// Request parameters
+	}
+	[JsonObject(MemberSerialization = MemberSerialization.OptIn)]
+	public partial interface ICreateFollowIndexRequest : IRequest<CreateFollowIndexRequestParameters>
+	{
+		IndexName Index { get; }
+	}
+	///<summary>Request parameters for CcrFollow <pre>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-put-follow.html</pre></summary>
+	public partial class CreateFollowIndexRequest : PlainRequestBase<CreateFollowIndexRequestParameters>, ICreateFollowIndexRequest
+	{
+		protected ICreateFollowIndexRequest Self => this;
+		///<summary>/{index}/_ccr/follow</summary>
+		///<param name="index">this parameter is required</param>
+		public CreateFollowIndexRequest(IndexName index) : base(r=>r.Required("index", index)){}
+		// values part of the url path
+		IndexName ICreateFollowIndexRequest.Index => Self.RouteValues.Get<IndexName>("index");
+
+		// Request parameters
+	}
+	[JsonObject(MemberSerialization = MemberSerialization.OptIn)]
 	public partial interface ICreateIndexRequest : IRequest<CreateIndexRequestParameters>
 	{
 		IndexName Index { get; }
@@ -1520,6 +1566,23 @@ public DeleteAliasRequest(Indices index, Names name) : base(r=>r.Required("index
 		public Time MasterTimeout { get => Q<Time>("master_timeout"); set => Q("master_timeout", value); }
 	}
 	[JsonObject(MemberSerialization = MemberSerialization.OptIn)]
+	public partial interface IDeleteAutoFollowPatternRequest : IRequest<DeleteAutoFollowPatternRequestParameters>
+	{
+		Name Name { get; }
+	}
+	///<summary>Request parameters for CcrDeleteAutoFollowPattern <pre>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-delete-auto-follow-pattern.html</pre></summary>
+	public partial class DeleteAutoFollowPatternRequest : PlainRequestBase<DeleteAutoFollowPatternRequestParameters>, IDeleteAutoFollowPatternRequest
+	{
+		protected IDeleteAutoFollowPatternRequest Self => this;
+		///<summary>/_ccr/auto_follow/{name}</summary>
+		///<param name="name">this parameter is required</param>
+		public DeleteAutoFollowPatternRequest(Name name) : base(r=>r.Required("name", name)){}
+		// values part of the url path
+		Name IDeleteAutoFollowPatternRequest.Name => Self.RouteValues.Get<Name>("name");
+
+		// Request parameters
+	}
+	[JsonObject(MemberSerialization = MemberSerialization.OptIn)]
 	public partial interface IDeleteByQueryRequest : IRequest<DeleteByQueryRequestParameters>
 	{
 		Indices Index { get; }
@@ -2486,6 +2549,23 @@ public FlushRequest(Indices index) : base(r=>r.Optional("index", index)){}
 		public ExpandWildcards? ExpandWildcards { get => Q<ExpandWildcards?>("expand_wildcards"); set => Q("expand_wildcards", value); }
 	}
 	[JsonObject(MemberSerialization = MemberSerialization.OptIn)]
+	public partial interface IFollowIndexStatsRequest : IRequest<FollowIndexStatsRequestParameters>
+	{
+		Indices Index { get; }
+	}
+	///<summary>Request parameters for CcrFollowStats <pre>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-get-follow-stats.html</pre></summary>
+	public partial class FollowIndexStatsRequest : PlainRequestBase<FollowIndexStatsRequestParameters>, IFollowIndexStatsRequest
+	{
+		protected IFollowIndexStatsRequest Self => this;
+		///<summary>/{index}/_ccr/stats</summary>
+		///<param name="index">Optional, accepts null</param>
+		public FollowIndexStatsRequest(Indices index) : base(r=>r.Optional("index", index)){}
+		// values part of the url path
+		Indices IFollowIndexStatsRequest.Index => Self.RouteValues.Get<Indices>("index");
+
+		// Request parameters
+	}
+	[JsonObject(MemberSerialization = MemberSerialization.OptIn)]
 	public partial interface IForceMergeRequest : IRequest<ForceMergeRequestParameters>
 	{
 		Indices Index { get; }
@@ -2605,6 +2685,25 @@ public partial class GetBasicLicenseStatusRequest : PlainRequestBase<GetBasicLic
 		// Request parameters
 	}
 	[JsonObject(MemberSerialization = MemberSerialization.OptIn)]
+	public partial interface IGetAutoFollowPatternRequest : IRequest<GetAutoFollowPatternRequestParameters>
+	{
+		Name Name { get; }
+	}
+	///<summary>Request parameters for CcrGetAutoFollowPattern <pre>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-get-auto-follow-pattern.html</pre></summary>
+	public partial class GetAutoFollowPatternRequest : PlainRequestBase<GetAutoFollowPatternRequestParameters>, IGetAutoFollowPatternRequest
+	{
+		protected IGetAutoFollowPatternRequest Self => this;
+		///<summary>/_ccr/auto_follow</summary>
+		public GetAutoFollowPatternRequest() : base(){}
+		///<summary>/_ccr/auto_follow/{name}</summary>
+		///<param name="name">Optional, accepts null</param>
+		public GetAutoFollowPatternRequest(Name name) : base(r=>r.Optional("name", name)){}
+		// values part of the url path
+		Name IGetAutoFollowPatternRequest.Name => Self.RouteValues.Get<Name>("name");
+
+		// Request parameters
+	}
+	[JsonObject(MemberSerialization = MemberSerialization.OptIn)]
 	public partial interface IGetBucketsRequest : IRequest<GetBucketsRequestParameters>
 	{
 		Id JobId { get; }
@@ -4105,6 +4204,23 @@ public OpenJobRequest(Id job_id) : base(r=>r.Required("job_id", job_id)){}
 		// Request parameters
 	}
 	[JsonObject(MemberSerialization = MemberSerialization.OptIn)]
+	public partial interface IPauseFollowIndexRequest : IRequest<PauseFollowIndexRequestParameters>
+	{
+		IndexName Index { get; }
+	}
+	///<summary>Request parameters for CcrPauseFollow <pre>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-post-pause-follow.html</pre></summary>
+	public partial class PauseFollowIndexRequest : PlainRequestBase<PauseFollowIndexRequestParameters>, IPauseFollowIndexRequest
+	{
+		protected IPauseFollowIndexRequest Self => this;
+		///<summary>/{index}/_ccr/pause_follow</summary>
+		///<param name="index">this parameter is required</param>
+		public PauseFollowIndexRequest(IndexName index) : base(r=>r.Required("index", index)){}
+		// values part of the url path
+		IndexName IPauseFollowIndexRequest.Index => Self.RouteValues.Get<IndexName>("index");
+
+		// Request parameters
+	}
+	[JsonObject(MemberSerialization = MemberSerialization.OptIn)]
 	public partial interface IPingRequest : IRequest<PingRequestParameters>
 	{
 	}
@@ -4662,6 +4778,23 @@ public RestoreRequest(Name repository, Name snapshot) : base(r=>r.Required("repo
 		public bool? WaitForCompletion { get => Q<bool?>("wait_for_completion"); set => Q("wait_for_completion", value); }
 	}
 	[JsonObject(MemberSerialization = MemberSerialization.OptIn)]
+	public partial interface IResumeFollowIndexRequest : IRequest<ResumeFollowIndexRequestParameters>
+	{
+		IndexName Index { get; }
+	}
+	///<summary>Request parameters for CcrResumeFollow <pre>https://www.elastic.co/guide/en/elasticsearch/reference/current/ccr-post-resume-follow.html</pre></summary>
+	public partial class ResumeFollowIndexRequest : PlainRequestBase<ResumeFollowIndexRequestParameters>, IResumeFollowIndexRequest
+	{
+		protected IResumeFollowIndexRequest Self => this;
+		///<summary>/{index}/_ccr/resume_follow</summary>
+		///<param name="index">this parameter is required</param>
+		public ResumeFollowIndexRequest(IndexName index) : base(r=>r.Required("index", index)){}
+		// values part of the url path
+		IndexName IResumeFollowIndexRequest.Index => Self.RouteValues.Get<IndexName>("index");
+
+		// Request parameters
+	}
+	[JsonObject(MemberSerialization = MemberSerialization.OptIn)]
 	public partial interface IRevertModelSnapshotRequest : IRequest<RevertModelSnapshotRequestParameters>
 	{
 		Id JobId { get; }
@@ -5697,6 +5830,23 @@ public TypeExistsRequest(Indices index, Types type) : base(r=>r.Required("index"
 		public bool? Local { get => Q<bool?>("local"); set => Q("local", value); }
 	}
 	[JsonObject(MemberSerialization = MemberSerialization.OptIn)]
+	public partial interface IUnfollowIndexRequest : IRequest<UnfollowIndexRequestParameters>
+	{
+		IndexName Index { get; }
+	}
+	///<summary>Request parameters for CcrUnfollow <pre>http://www.elastic.co/guide/en/elasticsearch/reference/current</pre></summary>
+	public partial class UnfollowIndexRequest : PlainRequestBase<UnfollowIndexRequestParameters>, IUnfollowIndexRequest
+	{
+		protected IUnfollowIndexRequest Self => this;
+		///<summary>/{index}/_ccr/unfollow</summary>
+		///<param name="index">this parameter is required</param>
+		public UnfollowIndexRequest(IndexName index) : base(r=>r.Required("index", index)){}
+		// values part of the url path
+		IndexName IUnfollowIndexRequest.Index => Self.RouteValues.Get<IndexName>("index");
+
+		// Request parameters
+	}
+	[JsonObject(MemberSerialization = MemberSerialization.OptIn)]
 	public partial interface IUpdateByQueryRequest : IRequest<UpdateByQueryRequestParameters>
 	{
 		Indices Index { get; }
diff --git a/src/Tests/Tests.Core/ManagedElasticsearch/NodeSeeders/DefaultSeeder.cs b/src/Tests/Tests.Core/ManagedElasticsearch/NodeSeeders/DefaultSeeder.cs
index 1f88aea4631..50b95560954 100644
--- a/src/Tests/Tests.Core/ManagedElasticsearch/NodeSeeders/DefaultSeeder.cs
+++ b/src/Tests/Tests.Core/ManagedElasticsearch/NodeSeeders/DefaultSeeder.cs
@@ -17,6 +17,8 @@ public class DefaultSeeder
 		public const string ProjectsAliasName = "projects-alias";
 		public const string TestsIndexTemplateName = "nest_tests";
 
+		public const string RemoteClusterName = "remote-cluster";
+
 		public const string PipelineName = "nest-pipeline";
 
 		private readonly IIndexSettings _defaultIndexSettings = new IndexSettings()
@@ -83,11 +85,21 @@ public async Task ClusterSettingsAsync()
 		{
 			if (TestConfiguration.Instance.InRange("<6.1.0")) return;
 
-			var putSettingsResponse = await Client.ClusterPutSettingsAsync(s => s
-				.Transient(t => t
-					.Add("cluster.routing.use_adaptive_replica_selection", true)
-				)
-			);
+			var clusterConfiguration = new Dictionary<string, object>()
+			{
+				{ "cluster.routing.use_adaptive_replica_selection", true }
+			};
+
+			if (TestConfiguration.Instance.InRange(">=6.5.0"))
+				clusterConfiguration += new RemoteClusterConfiguration()
+				{
+					{ RemoteClusterName, "127.0.0.1:9300" }
+				};
+
+			var putSettingsResponse = await Client.ClusterPutSettingsAsync(new ClusterPutSettingsRequest
+			{
+				Transient = clusterConfiguration
+			});
 
 			putSettingsResponse.ShouldBeValid();
 		}
diff --git a/src/Tests/Tests/Cluster/RemoteInfo/RemoteInfoApiTests.cs b/src/Tests/Tests/Cluster/RemoteInfo/RemoteInfoApiTests.cs
index b3cbb8a8aec..c4274428b05 100644
--- a/src/Tests/Tests/Cluster/RemoteInfo/RemoteInfoApiTests.cs
+++ b/src/Tests/Tests/Cluster/RemoteInfo/RemoteInfoApiTests.cs
@@ -23,33 +23,43 @@ public RemoteInfoApiTests(ReadOnlyCluster cluster, EndpointUsage usage) : base(c
 
 		protected override void IntegrationSetup(IElasticClient client, CallUniqueValues values)
 		{
-			var enableRemoteClusters = client.ClusterPutSettings(new ClusterPutSettingsRequest
+			var oldWay = new M
 			{
-				Transient = new M
 				{
+					"search", new M
 					{
-						"search", new M
 						{
+							"remote", new M
 							{
-								"remote", new M
 								{
+									"cluster_one", new M
 									{
-										"cluster_one", new M
-										{
-											{ "seeds", new[] { "127.0.0.1:9300", "127.0.0.1:9301" } }
-										}
-									},
+										{ "seeds", new[] { "127.0.0.1:9300", "127.0.0.1:9301" } }
+									}
+								},
+								{
+									"cluster_two", new M
 									{
-										"cluster_two", new M
-										{
-											{ "seeds", new[] { "127.0.0.1:9300" } }
-										}
+										{ "seeds", new[] { "127.0.0.1:9300" } }
 									}
 								}
 							}
 						}
 					}
 				}
+			};
+			/**
+			 * As of 6.5.0 you can also use the following helper class which uses
+			 * the new way to configure remote clusters.
+			 */
+			var newWay = new RemoteClusterConfiguration()
+			{
+				{ "cluster_one", "127.0.0.1:9300", "127.0.0.1:9301" },
+				{ "cluster_two", "127.0.0.1:9300" }
+			};
+			var enableRemoteClusters = client.ClusterPutSettings(new ClusterPutSettingsRequest
+			{
+				Transient = oldWay
 			});
 			enableRemoteClusters.ShouldBeValid();
 
diff --git a/src/Tests/Tests/Framework/EndpointTests/CoordinatedIntegrationTestBase.cs b/src/Tests/Tests/Framework/EndpointTests/CoordinatedIntegrationTestBase.cs
new file mode 100644
index 00000000000..e87b7ac64d6
--- /dev/null
+++ b/src/Tests/Tests/Framework/EndpointTests/CoordinatedIntegrationTestBase.cs
@@ -0,0 +1,60 @@
+using System;
+using System.Threading.Tasks;
+using Elastic.Managed.Ephemeral;
+using Elastic.Xunit.XunitPlumbing;
+using Nest;
+using Tests.Core.ManagedElasticsearch.Clusters;
+using Tests.Framework.EndpointTests.TestState;
+using Tests.Framework.Integration;
+using Xunit;
+
+namespace Tests.Framework
+{
+	public abstract class CoordinatedIntegrationTestBase<TCluster>
+		: IClusterFixture<TCluster>, IClassFixture<EndpointUsage>
+		where TCluster : IEphemeralCluster<EphemeralClusterConfiguration>, INestTestCluster, new()
+	{
+		private readonly CoordinatedUsage _coordinatedUsage;
+
+		protected CoordinatedIntegrationTestBase(CoordinatedUsage coordinatedUsage) => _coordinatedUsage = coordinatedUsage;
+
+		protected async Task Assert<TResponse>(string name, Action<TResponse> assert)
+			where TResponse : class, IResponse
+		{
+			var lazyResponses = await ExecuteOnceInOrderUntil(name);
+			if (lazyResponses == null) throw new Exception($"{name} is defined but it yields no LazyResponses object");
+
+			await AssertOnAllResponses(lazyResponses, assert);
+		}
+
+		protected async Task AssertRunsToCompletion(string name)
+		{
+			var lazyResponses = await ExecuteOnceInOrderUntil(name);
+			if (lazyResponses == null) throw new Exception($"{name} is defined but it yields no LazyResponses object");
+		}
+
+		protected async Task AssertOnAllResponses<TResponse>(LazyResponses responses, Action<TResponse> assert)
+			where TResponse : class, IResponse
+		{
+			foreach (var (_, value) in await responses)
+			{
+				if (!(value is TResponse response))
+					throw new Exception($"{value.GetType()} is not expected response type {typeof(TResponse)}");
+
+				assert(response);
+			}
+		}
+
+		private async Task<LazyResponses> ExecuteOnceInOrderUntil(string name)
+		{
+			if (!_coordinatedUsage.Contains(name)) throw new Exception($"{name} is not a keyed after create response");
+
+			foreach (var lazyResponses in _coordinatedUsage)
+			{
+				await lazyResponses;
+				if (lazyResponses.Name == name) return lazyResponses;
+			}
+			return null;
+		}
+	}
+}
diff --git a/src/Tests/Tests/Framework/EndpointTests/CrudTestBase.cs b/src/Tests/Tests/Framework/EndpointTests/CrudTestBase.cs
index 09db2dc2755..7c00749618f 100644
--- a/src/Tests/Tests/Framework/EndpointTests/CrudTestBase.cs
+++ b/src/Tests/Tests/Framework/EndpointTests/CrudTestBase.cs
@@ -1,5 +1,8 @@
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Collections.Specialized;
 using System.Diagnostics.CodeAnalysis;
 using System.Threading.Tasks;
 using Elastic.Managed.Ephemeral;
@@ -129,7 +132,6 @@ public abstract class CrudTestBase<TCluster, TCreateResponse, TReadResponse, TUp
 		private readonly LazyResponses _updateResponse;
 		private readonly EndpointUsage _usage;
 
-
 		[SuppressMessage("Potential Code Quality Issues", "RECS0021:Warns about calls to virtual member functions occuring in the constructor",
 			Justification = "Expected behaviour")]
 		protected CrudTestBase(TCluster cluster, EndpointUsage usage)
diff --git a/src/Tests/Tests/Framework/EndpointTests/TestState/ClientMethod.cs b/src/Tests/Tests/Framework/EndpointTests/TestState/ClientMethod.cs
index ace1230ee34..ed0c5fbe93c 100644
--- a/src/Tests/Tests/Framework/EndpointTests/TestState/ClientMethod.cs
+++ b/src/Tests/Tests/Framework/EndpointTests/TestState/ClientMethod.cs
@@ -5,6 +5,6 @@ public enum ClientMethod
 		Fluent,
 		FluentAsync,
 		Initializer,
-		InitializerAsync
+		InitializerAsync,
 	}
 }
diff --git a/src/Tests/Tests/Framework/EndpointTests/TestState/CoordinatedUsage.cs b/src/Tests/Tests/Framework/EndpointTests/TestState/CoordinatedUsage.cs
new file mode 100644
index 00000000000..489c3203852
--- /dev/null
+++ b/src/Tests/Tests/Framework/EndpointTests/TestState/CoordinatedUsage.cs
@@ -0,0 +1,126 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Threading.Tasks;
+using Nest;
+using Tests.Core.ManagedElasticsearch.Clusters;
+using Tests.Framework.Integration;
+
+namespace Tests.Framework.EndpointTests.TestState
+{
+	public class CoordinatedUsage : KeyedCollection<string, LazyResponses>
+	{
+		public static readonly IResponse VoidResponse = new PingResponse();
+		private readonly INestTestCluster _cluster;
+		private readonly EndpointUsage _usage;
+
+		public CoordinatedUsage(INestTestCluster cluster, EndpointUsage usage, string prefix = null)
+		{
+			_cluster = cluster;
+			_usage = usage;
+			Prefix = prefix;
+		}
+
+		protected IElasticClient Client => _cluster.Client;
+		private string Prefix { get; }
+		private static string RandomFluent { get; } = $"f-{RandomString()}";
+		private static string RandomFluentAsync { get; } = $"fa-{RandomString()}";
+		private static string RandomInitializer { get; } = $"o-{RandomString()}";
+		private static string RandomInitializerAsync { get; } = $"oa-{RandomString()}";
+
+		protected override string GetKeyForItem(LazyResponses item) => item.Name;
+
+		public void Add(string name, Func<CoordinatedUsage, Func<string, LazyResponses>> create)
+		{
+			var responses = create(this)(name);
+			Add(responses);
+		}
+
+		protected static string RandomString() => Guid.NewGuid().ToString("N").Substring(0, 8);
+
+		public Func<string, LazyResponses> Calls<TDescriptor, TInitializer, TInterface, TResponse>(
+			Func<string, TInitializer> initializerBody,
+			Func<string, TDescriptor, TInterface> fluentBody,
+			Func<string, IElasticClient, Func<TDescriptor, TInterface>, TResponse> fluent,
+			Func<string, IElasticClient, Func<TDescriptor, TInterface>, Task<TResponse>> fluentAsync,
+			Func<string, IElasticClient, TInitializer, TResponse> request,
+			Func<string, IElasticClient, TInitializer, Task<TResponse>> requestAsync
+		)
+			where TResponse : class, IResponse
+			where TDescriptor : class, TInterface
+			where TInitializer : class, TInterface
+			where TInterface : class
+		{
+			var client = Client;
+			return k => _usage.CallOnce(
+				() => new LazyResponses(k,
+					async () => await CallAllClientMethodsOverloads(initializerBody, fluentBody, fluent, fluentAsync, request, requestAsync, client))
+				, k);
+		}
+
+		public Func<string, LazyResponses> Call(Func<string, IElasticClient, Task> call) =>
+			Call(async (s, c) =>
+			{
+				await call(s, c);
+
+				return VoidResponse;
+			});
+
+		public Func<string, LazyResponses> Call(Func<string, IElasticClient, Task<IResponse>> call)
+		{
+			var client = Client;
+			return k => _usage.CallOnce(
+				() => new LazyResponses(k, async () =>
+				{
+					var dict = new Dictionary<ClientMethod, IResponse>();
+					var values = new[]
+					{
+						(ClientMethod.Fluent, Sanitize(RandomFluent)),
+						(ClientMethod.Initializer, Sanitize(RandomInitializer)),
+						(ClientMethod.FluentAsync, Sanitize(RandomFluentAsync)),
+						(ClientMethod.InitializerAsync, Sanitize(RandomInitializerAsync))
+					};
+					foreach (var (m, v) in values)
+					{
+						var response = await call(v, client);
+						dict.Add(m, response);
+					}
+
+					return dict;
+				})
+				, k);
+		}
+
+		private string Sanitize(string value) => string.IsNullOrEmpty(Prefix) ? value : $"{Prefix}-{value}";
+
+		private async Task<Dictionary<ClientMethod, IResponse>> CallAllClientMethodsOverloads<TDescriptor, TInitializer, TInterface, TResponse>(
+			Func<string, TInitializer> initializerBody,
+			Func<string, TDescriptor, TInterface> fluentBody,
+			Func<string, IElasticClient, Func<TDescriptor, TInterface>, TResponse> fluent,
+			Func<string, IElasticClient, Func<TDescriptor, TInterface>, Task<TResponse>> fluentAsync,
+			Func<string, IElasticClient, TInitializer, TResponse> request,
+			Func<string, IElasticClient, TInitializer, Task<TResponse>> requestAsync,
+			IElasticClient client
+		)
+			where TResponse : class, IResponse
+			where TDescriptor : class, TInterface
+			where TInitializer : class, TInterface
+			where TInterface : class
+		{
+			var dict = new Dictionary<ClientMethod, IResponse>();
+
+			var sf = Sanitize(RandomFluent);
+			dict.Add(ClientMethod.Fluent, fluent(sf, client, f => fluentBody(sf, f)));
+
+			var sfa = Sanitize(RandomFluentAsync);
+			dict.Add(ClientMethod.FluentAsync, await fluentAsync(sfa, client, f => fluentBody(sfa, f)));
+
+			var si = Sanitize(RandomInitializer);
+			dict.Add(ClientMethod.Initializer, request(si, client, initializerBody(si)));
+
+			var sia = Sanitize(RandomInitializerAsync);
+			dict.Add(ClientMethod.InitializerAsync, await requestAsync(sia, client, initializerBody(sia)));
+			return dict;
+		}
+	}
+}
diff --git a/src/Tests/Tests/Framework/EndpointTests/TestState/EndpointUsage.cs b/src/Tests/Tests/Framework/EndpointTests/TestState/EndpointUsage.cs
index be322360727..f2867132b22 100644
--- a/src/Tests/Tests/Framework/EndpointTests/TestState/EndpointUsage.cs
+++ b/src/Tests/Tests/Framework/EndpointTests/TestState/EndpointUsage.cs
@@ -16,7 +16,7 @@ namespace Tests.Framework.Integration
 	public class EndpointUsage
 	{
 		private readonly object _lock = new object();
-		private readonly ConcurrentDictionary<int, LazyResponses> _usages = new ConcurrentDictionary<int, LazyResponses>();
+		private readonly ConcurrentDictionary<string, LazyResponses> _usages = new ConcurrentDictionary<string, LazyResponses>();
 
 		public EndpointUsage() : this("nest") { }
 
@@ -27,19 +27,21 @@ public EndpointUsage() : this("nest") { }
 
 		public CallUniqueValues CallUniqueValues { get; }
 
-		public LazyResponses CallOnce(Func<LazyResponses> clientUsage, int k = 0)
+		public LazyResponses CallOnce(Func<LazyResponses> clientUsage, string key)
 		{
-			if (_usages.TryGetValue(k, out var lazyResponses)) return lazyResponses;
+			if (_usages.TryGetValue(key, out var lazyResponses)) return lazyResponses;
 
 			lock (_lock)
 			{
-				if (_usages.TryGetValue(k, out lazyResponses)) return lazyResponses;
+				if (_usages.TryGetValue(key, out lazyResponses)) return lazyResponses;
 
 				var response = clientUsage();
-				_usages.TryAdd(k, response);
+				_usages.TryAdd(key, response);
 				return response;
 			}
 		}
+
+		public LazyResponses CallOnce(Func<LazyResponses> clientUsage, int k = 0) => CallOnce(clientUsage, k.ToString());
 	}
 
 	public class SingleEndpointUsage<TResponse> : EndpointUsage
diff --git a/src/Tests/Tests/Framework/EndpointTests/TestState/LazyResponses.cs b/src/Tests/Tests/Framework/EndpointTests/TestState/LazyResponses.cs
index 81e8342d8ce..6399925a839 100644
--- a/src/Tests/Tests/Framework/EndpointTests/TestState/LazyResponses.cs
+++ b/src/Tests/Tests/Framework/EndpointTests/TestState/LazyResponses.cs
@@ -8,10 +8,16 @@ namespace Tests.Framework
 {
 	public class LazyResponses : AsyncLazy<Dictionary<ClientMethod, IResponse>>
 	{
-		public LazyResponses(Func<Dictionary<ClientMethod, IResponse>> factory) : base(factory) { }
+		public LazyResponses(Func<Dictionary<ClientMethod, IResponse>> factory) : this("__ignored__", factory) {}
 
-		public LazyResponses(Func<Task<Dictionary<ClientMethod, IResponse>>> factory) : base(factory) { }
+		public LazyResponses(Func<Task<Dictionary<ClientMethod, IResponse>>> factory) : this("__ignored__", factory) {}
 
-		public static LazyResponses Empty { get; } = new LazyResponses(() => new Dictionary<ClientMethod, IResponse>());
+		public LazyResponses(string name, Func<Dictionary<ClientMethod, IResponse>> factory) : base(factory) => Name = name;
+
+		public LazyResponses(string name, Func<Task<Dictionary<ClientMethod, IResponse>>> factory) : base(factory) => Name = name;
+
+		public static LazyResponses Empty { get; } = new LazyResponses("__empty__", () => new Dictionary<ClientMethod, IResponse>());
+
+		public string Name { get; }
 	}
 }
diff --git a/src/Tests/Tests/XPack/CrossClusterReplication/AutoFollow/CreateAutoFollowPattern/CreateAutoFollowPatternApiTests.cs b/src/Tests/Tests/XPack/CrossClusterReplication/AutoFollow/CreateAutoFollowPattern/CreateAutoFollowPatternApiTests.cs
new file mode 100644
index 00000000000..c1457f3ed3f
--- /dev/null
+++ b/src/Tests/Tests/XPack/CrossClusterReplication/AutoFollow/CreateAutoFollowPattern/CreateAutoFollowPatternApiTests.cs
@@ -0,0 +1,79 @@
+using System;
+using Elasticsearch.Net;
+using Nest;
+using Tests.Core.ManagedElasticsearch.Clusters;
+using Tests.Framework;
+using Tests.Framework.Integration;
+
+namespace Tests.XPack.CrossClusterReplication.AutoFollow.CreateAutoFollowPattern
+{
+	public class CreateAutoFollowPatternApiTests : ApiTestBase<XPackCluster, ICreateAutoFollowPatternResponse, ICreateAutoFollowPatternRequest, CreateAutoFollowPatternDescriptor, CreateAutoFollowPatternRequest>
+	{
+		public CreateAutoFollowPatternApiTests(XPackCluster cluster, EndpointUsage usage) : base(cluster, usage) { }
+
+		protected override object ExpectJson { get; } = new
+		{
+			follow_index_pattern = "y",
+			leader_index_patterns = new [] { "z" },
+			max_outstanding_read_requests = 100,
+			max_outstanding_write_requests = 101,
+			max_read_request_operation_count = 102,
+			max_read_request_size = "2mb",
+			max_retry_delay = "1m",
+			max_write_buffer_count = 104,
+			max_write_buffer_size = "1mb",
+			max_write_request_operation_count = 103,
+			max_write_request_size = "3mb",
+			read_poll_timeout = "2m",
+			remote_cluster = "x"
+		};
+
+		protected override CreateAutoFollowPatternDescriptor NewDescriptor() => new CreateAutoFollowPatternDescriptor("x");
+
+		protected override Func<CreateAutoFollowPatternDescriptor, ICreateAutoFollowPatternRequest> Fluent => d => d
+			.RemoteCluster("x")
+			.FollowIndexPattern("y")
+			.LeaderIndexPatterns("z")
+			.MaxWriteBufferSize("1mb")
+			.MaxOutstandingReadRequests(100)
+			.MaxOutstandingWriteRequests( 101)
+			.MaxReadRequestOperationCount(102)
+			.MaxWriteRequestOperationCount(103)
+			.MaxRetryDelay("1m")
+			.MaxPollTimeout("2m")
+			.MaxReadRequestSize("2mb")
+			.MaxWriteBufferCount(104)
+			.MaxWriteRequestSize("3mb")
+		;
+
+		protected override HttpMethod HttpMethod => HttpMethod.PUT;
+
+		protected override CreateAutoFollowPatternRequest Initializer => new CreateAutoFollowPatternRequest("x")
+		{
+			RemoteCluster = "x",
+			FollowIndexPattern = "y",
+			LeaderIndexPatterns = new []{"z"},
+			MaxWriteBufferSize = "1mb",
+			MaxOutstandingReadRequests = 100,
+			MaxOutstandingWriteRequests = 101,
+			MaxReadRequestOperationCount = 102,
+			MaxWriteRequestOperationCount = 103,
+			MaxRetryDelay = "1m",
+			MaxPollTimeout = "2m",
+			MaxReadRequestSize = "2mb",
+			MaxWriteBufferCount = 104,
+			MaxWriteRequestSize = "3mb"
+
+		};
+
+		protected override bool SupportsDeserialization => false;
+		protected override string UrlPath => $"/_ccr/auto_follow/x";
+
+		protected override LazyResponses ClientUsage() => Calls(
+			(client, f) => client.CreateAutoFollowPattern("x", f),
+			(client, f) => client.CreateAutoFollowPatternAsync("x", f),
+			(client, r) => client.CreateAutoFollowPattern(r),
+			(client, r) => client.CreateAutoFollowPatternAsync(r)
+		);
+	}
+}
diff --git a/src/Tests/Tests/XPack/CrossClusterReplication/AutoFollow/CreateAutoFollowPattern/CreateAutoFollowPatternUrlTests.cs b/src/Tests/Tests/XPack/CrossClusterReplication/AutoFollow/CreateAutoFollowPattern/CreateAutoFollowPatternUrlTests.cs
new file mode 100644
index 00000000000..7f2b5645d3b
--- /dev/null
+++ b/src/Tests/Tests/XPack/CrossClusterReplication/AutoFollow/CreateAutoFollowPattern/CreateAutoFollowPatternUrlTests.cs
@@ -0,0 +1,21 @@
+using System.Threading.Tasks;
+using Elastic.Xunit.XunitPlumbing;
+using Nest;
+using Tests.Framework;
+
+namespace Tests.XPack.CrossClusterReplication.AutoFollow.CreateAutoFollowPattern
+{
+	public class CreateAutoFollowPatternUrlTests : UrlTestsBase
+	{
+		[U] public override async Task Urls()
+		{
+			var name = "x";
+			await UrlTester.PUT($"/_ccr/auto_follow/{name}")
+				.Fluent(c => c.CreateAutoFollowPattern(name, d => d))
+				.Request(c => c.CreateAutoFollowPattern(new CreateAutoFollowPatternRequest(name)))
+				.FluentAsync(c => c.CreateAutoFollowPatternAsync(name, d => d))
+				.RequestAsync(c => c.CreateAutoFollowPatternAsync(new CreateAutoFollowPatternRequest(name)));
+
+		}
+	}
+}
diff --git a/src/Tests/Tests/XPack/CrossClusterReplication/AutoFollow/DeleteAutoFollowPattern/DeleteAutoFollowPatternUrlTests.cs b/src/Tests/Tests/XPack/CrossClusterReplication/AutoFollow/DeleteAutoFollowPattern/DeleteAutoFollowPatternUrlTests.cs
new file mode 100644
index 00000000000..64dde25f4f4
--- /dev/null
+++ b/src/Tests/Tests/XPack/CrossClusterReplication/AutoFollow/DeleteAutoFollowPattern/DeleteAutoFollowPatternUrlTests.cs
@@ -0,0 +1,21 @@
+using System.Threading.Tasks;
+using Elastic.Xunit.XunitPlumbing;
+using Nest;
+using Tests.Framework;
+
+namespace Tests.XPack.CrossClusterReplication.AutoFollow.DeleteAutoFollowPattern
+{
+	public class DeleteAutoFollowPatternUrlTests : UrlTestsBase
+	{
+		[U] public override async Task Urls()
+		{
+			var name = "x";
+			await UrlTester.DELETE($"/_ccr/auto_follow/{name}")
+				.Fluent(c => c.DeleteAutoFollowPattern(name, d => d))
+				.Request(c => c.DeleteAutoFollowPattern(new DeleteAutoFollowPatternRequest(name)))
+				.FluentAsync(c => c.DeleteAutoFollowPatternAsync(name, d => d))
+				.RequestAsync(c => c.DeleteAutoFollowPatternAsync(new DeleteAutoFollowPatternRequest(name)));
+
+		}
+	}
+}
diff --git a/src/Tests/Tests/XPack/CrossClusterReplication/AutoFollow/GetAutoFollowPattern/GetAutoFollowPatternUrlTests.cs b/src/Tests/Tests/XPack/CrossClusterReplication/AutoFollow/GetAutoFollowPattern/GetAutoFollowPatternUrlTests.cs
new file mode 100644
index 00000000000..6fc22d8f5c0
--- /dev/null
+++ b/src/Tests/Tests/XPack/CrossClusterReplication/AutoFollow/GetAutoFollowPattern/GetAutoFollowPatternUrlTests.cs
@@ -0,0 +1,27 @@
+using System.Threading.Tasks;
+using Elastic.Xunit.XunitPlumbing;
+using Nest;
+using Tests.Framework;
+
+namespace Tests.XPack.CrossClusterReplication.AutoFollow.GetAutoFollowPattern
+{
+	public class GetAutoFollowPatternUrlTests : UrlTestsBase
+	{
+		[U] public override async Task Urls()
+		{
+			var name = "x";
+			await UrlTester.GET($"/_ccr/auto_follow/{name}")
+				.Fluent(c => c.GetAutoFollowPattern(d => d.Name(name)))
+				.Request(c => c.GetAutoFollowPattern(new GetAutoFollowPatternRequest(name)))
+				.FluentAsync(c => c.GetAutoFollowPatternAsync(d => d.Name(name)))
+				.RequestAsync(c => c.GetAutoFollowPatternAsync(new GetAutoFollowPatternRequest(name)));
+
+			await UrlTester.GET($"/_ccr/auto_follow")
+				.Fluent(c => c.GetAutoFollowPattern(d => d))
+				.Request(c => c.GetAutoFollowPattern(new GetAutoFollowPatternRequest()))
+				.FluentAsync(c => c.GetAutoFollowPatternAsync(d => d))
+				.RequestAsync(c => c.GetAutoFollowPatternAsync(new GetAutoFollowPatternRequest()));
+
+		}
+	}
+}
diff --git a/src/Tests/Tests/XPack/CrossClusterReplication/CrossClusterReplicationAutoFollowTests .cs b/src/Tests/Tests/XPack/CrossClusterReplication/CrossClusterReplicationAutoFollowTests .cs
new file mode 100644
index 00000000000..360c4ca2d4b
--- /dev/null
+++ b/src/Tests/Tests/XPack/CrossClusterReplication/CrossClusterReplicationAutoFollowTests .cs	
@@ -0,0 +1,117 @@
+using System;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Elastic.Xunit.XunitPlumbing;
+using FluentAssertions;
+using Nest;
+using Tests.Core.ManagedElasticsearch.Clusters;
+using Tests.Core.ManagedElasticsearch.NodeSeeders;
+using Tests.Domain;
+using Tests.Framework;
+using Tests.Framework.EndpointTests.TestState;
+using Tests.Framework.Integration;
+
+namespace Tests.XPack.CrossClusterReplication
+{
+	[SkipVersion("<6.5.0", "")]
+	public class CrossClusterReplicationAutoFollowTests : CoordinatedIntegrationTestBase<WritableCluster>
+	{
+		private const string CreateAutoFollowStep = nameof(CreateAutoFollowStep);
+		private const string GetAutoFollowStep = nameof(GetAutoFollowStep);
+		private const string DeleteAutoFollowStep = nameof(DeleteAutoFollowStep);
+		private const string GlobalStatsStep = nameof(GlobalStatsStep);
+
+		private static readonly Project[] Data = Project.Generator.GenerateLazy(1000).ToArray();
+
+		public CrossClusterReplicationAutoFollowTests(WritableCluster cluster, EndpointUsage usage) : base(new CoordinatedUsage(cluster, usage, Prefix)
+		{
+			{
+				CreateAutoFollowStep, u =>
+					u.Calls<CreateAutoFollowPatternDescriptor, CreateAutoFollowPatternRequest, ICreateAutoFollowPatternRequest, ICreateAutoFollowPatternResponse>(
+						v => new CreateAutoFollowPatternRequest(AutoPattern(v))
+						{
+							RemoteCluster = DefaultSeeder.RemoteClusterName,
+							LeaderIndexPatterns = new [] { $"{LeaderPrefix}*"},
+							FollowIndexPattern = $"{FollowerPrefix}{{{{leader_index}}}}",
+							MaxWriteBufferSize = "1mb"
+						},
+						(v, d) => d
+							.RemoteCluster(DefaultSeeder.RemoteClusterName)
+							.LeaderIndexPatterns($"{LeaderPrefix}*")
+							.FollowIndexPattern($"{FollowerPrefix}{{{{leader_index}}}}")
+							.MaxWriteBufferSize("1mb")
+						,
+						(v, c, f) => c.CreateAutoFollowPattern(AutoPattern(v), f),
+						(v, c, f) => c.CreateAutoFollowPatternAsync(AutoPattern(v), f),
+						(v, c, r) => c.CreateAutoFollowPattern(r),
+						(v, c, r) => c.CreateAutoFollowPatternAsync(r)
+					)
+			},
+			{
+				GetAutoFollowStep, u =>
+					u.Calls<GetAutoFollowPatternDescriptor, GetAutoFollowPatternRequest, IGetAutoFollowPatternRequest, IGetAutoFollowPatternResponse>(
+						v => new GetAutoFollowPatternRequest(AutoPattern(v)),
+						(v, d) => d.Name(AutoPattern(v)),
+						(v, c, f) => c.GetAutoFollowPattern(f),
+						(v, c, f) => c.GetAutoFollowPatternAsync(f),
+						(v, c, r) => c.GetAutoFollowPattern(r),
+						(v, c, r) => c.GetAutoFollowPatternAsync(r)
+					)
+			},
+			{
+				DeleteAutoFollowStep, u =>
+					u.Calls<DeleteAutoFollowPatternDescriptor, DeleteAutoFollowPatternRequest, IDeleteAutoFollowPatternRequest, IDeleteAutoFollowPatternResponse>(
+						v => new DeleteAutoFollowPatternRequest(AutoPattern(v)),
+						(v, d) => d,
+						(v, c, f) => c.DeleteAutoFollowPattern(AutoPattern(v), f),
+						(v, c, f) => c.DeleteAutoFollowPatternAsync(AutoPattern(v), f),
+						(v, c, r) => c.DeleteAutoFollowPattern(r),
+						(v, c, r) => c.DeleteAutoFollowPatternAsync(r)
+					)
+			},
+			{
+				GlobalStatsStep, u => u.Calls<CcrStatsDescriptor, CcrStatsRequest, ICcrStatsRequest, ICcrStatsResponse>(
+						v => new CcrStatsRequest(),
+						(v, d) => d,
+						(v, c, f) => c.CcrStats(f),
+						(v, c, f) => c.CcrStatsAsync(f),
+						(v, c, r) => c.CcrStats(r),
+						(v, c, r) => c.CcrStatsAsync(r)
+					)
+			}
+		}) { }
+
+		protected static string Prefix { get; } = $"autof-{Guid.NewGuid().ToString("N").Substring(0, 4)}";
+		protected static string LeaderPrefix { get; } = $"leader-{Prefix}";
+		protected static string FollowerPrefix { get; } = "follower-";
+
+		private static string LeaderIndex(string v) => $"{LeaderPrefix}{v}";
+		private static string FollowIndex(string v) => $"{FollowerPrefix}{LeaderPrefix}{v}";
+		private static string AutoPattern(string v) => $"auto-pattern-{v}";
+
+		[I] public async Task CreateIsAcked() => await Assert<CreateAutoFollowPatternResponse>(CreateAutoFollowStep, r => r.Acknowledged.Should().BeTrue());
+
+		[I] public async Task DeleteIsAcked() => await Assert<DeleteAutoFollowPatternResponse>(DeleteAutoFollowStep, r => r.Acknowledged.Should().BeTrue());
+
+		[I] public async Task GetReturnsAndIsMapped() => await Assert<GetAutoFollowPatternResponse>(GetAutoFollowStep, r =>
+		{
+			r.Patterns.Should().NotBeNull().And.HaveCount(1);
+
+			var autoPattern = r.Patterns.First().Value;
+			autoPattern.Should().NotBeNull();
+			autoPattern.MaxWriteBufferSize.Should().Be("1mb");
+			autoPattern.RemoteCluster.Should().Be(DefaultSeeder.RemoteClusterName);
+			autoPattern.FollowIndexPattern.Should().Contain("follower");
+			autoPattern.LeaderIndexPatterns.Should().NotBeEmpty().And.HaveCount(1);
+		});
+
+		[I] public async Task GlobalStatsResponse() => await Assert<CcrStatsResponse>(GlobalStatsStep, r =>
+		{
+			r.IsValid.Should().BeTrue();
+			r.AutoFollowStats.Should().NotBeNull();
+			r.AutoFollowStats.RecentAutoFollowErrors.Should().NotBeNull().And.BeEmpty();
+		});
+
+	}
+}
diff --git a/src/Tests/Tests/XPack/CrossClusterReplication/CrossClusterReplicationFollowTests.cs b/src/Tests/Tests/XPack/CrossClusterReplication/CrossClusterReplicationFollowTests.cs
new file mode 100644
index 00000000000..588df1f7ce2
--- /dev/null
+++ b/src/Tests/Tests/XPack/CrossClusterReplication/CrossClusterReplicationFollowTests.cs
@@ -0,0 +1,312 @@
+using System;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Elastic.Xunit.XunitPlumbing;
+using FluentAssertions;
+using Nest;
+using Tests.Core.ManagedElasticsearch.Clusters;
+using Tests.Core.ManagedElasticsearch.NodeSeeders;
+using Tests.Domain;
+using Tests.Framework;
+using Tests.Framework.EndpointTests.TestState;
+using Tests.Framework.Integration;
+
+namespace Tests.XPack.CrossClusterReplication
+{
+	[SkipVersion("<6.5.0", "")]
+	public class CrossClusterReplicationFollowTests : CoordinatedIntegrationTestBase<WritableCluster>
+	{
+		private const string CloseIndexStep = nameof(CloseIndexStep);
+		private const string CountAfterStep = nameof(CountAfterStep);
+		private const string CountBeforeStep = nameof(CountBeforeStep);
+		private const string CreateIndexStep = nameof(CreateIndexStep);
+		private const string DeleteOriginalIndicesStep = nameof(DeleteOriginalIndicesStep);
+		private const string FollowIndexStep = nameof(FollowIndexStep);
+		private const string FollowStatsAgainStep = nameof(FollowStatsAgainStep);
+		private const string FollowStatsStep = nameof(FollowStatsStep);
+		private const string IndexDataStep = nameof(IndexDataStep);
+		private const string PauseFollowStep = nameof(PauseFollowStep);
+		private const string PauseForCloseStep = nameof(PauseForCloseStep);
+		private const string ResumeFollowStep = nameof(ResumeFollowStep);
+		private const string UnfollowAgainStep = nameof(UnfollowAgainStep);
+		private const string UnfollowStep = nameof(UnfollowStep);
+		private const string GlobalStatsStep = nameof(GlobalStatsStep);
+
+		private static readonly Project[] Data = Project.Generator.GenerateLazy(1000).ToArray();
+
+		public CrossClusterReplicationFollowTests(WritableCluster cluster, EndpointUsage usage) : base(new CoordinatedUsage(cluster, usage, Prefix)
+		{
+			{
+				CreateIndexStep, u => u.Calls<CreateIndexDescriptor, CreateIndexRequest, ICreateIndexRequest, ICreateIndexResponse>(
+					v => new CreateIndexRequest(v)
+					{
+						Settings = new IndexSettings()
+						{
+							NumberOfShards = 1,
+							NumberOfReplicas = 0,
+							SoftDeletes = new SoftDeleteSettings
+							{
+								Enabled = true,
+								Retention = new SoftDeleteRetentionSettings { Operations = 1024 }
+							}
+						}
+					},
+					(v, d) => d.Settings(s => s
+						.NumberOfShards(1)
+						.NumberOfReplicas(0)
+						.SoftDeletes(sd => sd
+							.Enabled()
+							.Retention(r => r.Operations(1024))
+						)
+					),
+					(v, c, f) => c.CreateIndex(v, f),
+					(v, c, f) => c.CreateIndexAsync(v, f),
+					(v, c, r) => c.CreateIndex(r),
+					(v, c, r) => c.CreateIndexAsync(r)
+				)
+			},
+			{
+				FollowIndexStep, u =>
+					u.Calls<CreateFollowIndexDescriptor, CreateFollowIndexRequest, ICreateFollowIndexRequest, ICreateFollowIndexResponse>(
+						v => new CreateFollowIndexRequest(CopyIndex(v))
+						{
+							RemoteCluster = DefaultSeeder.RemoteClusterName,
+							LeaderIndex = v
+						},
+						(v, d) => d
+							.RemoteCluster(DefaultSeeder.RemoteClusterName)
+							.LeaderIndex(v),
+						(v, c, f) => c.CreateFollowIndex(CopyIndex(v), f),
+						(v, c, f) => c.CreateFollowIndexAsync(CopyIndex(v), f),
+						(v, c, r) => c.CreateFollowIndex(r),
+						(v, c, r) => c.CreateFollowIndexAsync(r)
+					)
+			},
+			{
+				IndexDataStep, u => u.Call((v, c) =>
+				{
+					var seenPages = 0;
+					var tokenSource = new CancellationTokenSource();
+					var bulkAllObservable = c.BulkAll(Data, b => b.Index(v).Size(1000).RefreshOnCompleted(), tokenSource.Token);
+					bulkAllObservable.Wait(TimeSpan.FromSeconds(20), x => Interlocked.Increment(ref seenPages));
+					return Task.CompletedTask;
+				})
+			},
+			{
+				CountBeforeStep, u => u.Call(async (v, c) => await c.CountAsync<Project>(d => d.Index(v)))
+			},
+			{
+				PauseFollowStep, u =>
+					u.Calls<PauseFollowIndexDescriptor, PauseFollowIndexRequest, IPauseFollowIndexRequest, IPauseFollowIndexResponse>(
+						v => new PauseFollowIndexRequest(CopyIndex(v)),
+						(v, d) => d,
+						(v, c, f) => c.PauseFollowIndex(CopyIndex(v), f),
+						(v, c, f) => c.PauseFollowIndexAsync(CopyIndex(v), f),
+						(v, c, r) => c.PauseFollowIndex(r),
+						(v, c, r) => c.PauseFollowIndexAsync(r)
+					)
+			},
+			{
+				ResumeFollowStep, u =>
+					u.Calls<ResumeFollowIndexDescriptor, ResumeFollowIndexRequest, IResumeFollowIndexRequest, IResumeFollowIndexResponse>(
+						v => new ResumeFollowIndexRequest(CopyIndex(v)),
+						(v, d) => d,
+						(v, c, f) => c.ResumeFollowIndex(CopyIndex(v), f),
+						(v, c, f) => c.ResumeFollowIndexAsync(CopyIndex(v), f),
+						(v, c, r) => c.ResumeFollowIndex(r),
+						(v, c, r) => c.ResumeFollowIndexAsync(r)
+					)
+			},
+			{
+				CountAfterStep, u => u.Call(async (v, c) => await c.CountAsync<Project>(d => d.Index(CopyIndex(v))))
+			},
+			{
+				FollowStatsStep, u =>
+					u.Calls<FollowIndexStatsDescriptor, FollowIndexStatsRequest, IFollowIndexStatsRequest, IFollowIndexStatsResponse>(
+						v => new FollowIndexStatsRequest(CopyIndex(v)),
+						(v, d) => d,
+						(v, c, f) => c.FollowIndexStats(CopyIndex(v), f),
+						(v, c, f) => c.FollowIndexStatsAsync(CopyIndex(v), f),
+						(v, c, r) => c.FollowIndexStats(r),
+						(v, c, r) => c.FollowIndexStatsAsync(r)
+					)
+			},
+			{
+				DeleteOriginalIndicesStep, u => u.Calls<DeleteIndexDescriptor, DeleteIndexRequest, IDeleteIndexRequest, IDeleteIndexResponse>
+				(
+					v => new DeleteIndexRequest(v),
+					(v, d) => d,
+					(v, c, f) => c.DeleteIndex(v, f),
+					(v, c, f) => c.DeleteIndexAsync(v, f),
+					(v, c, r) => c.DeleteIndex(r),
+					(v, c, r) => c.DeleteIndexAsync(r)
+				)
+			},
+			{
+				//This time we get exceptions on the stats
+				FollowStatsAgainStep, u =>
+					u.Calls<FollowIndexStatsDescriptor, FollowIndexStatsRequest, IFollowIndexStatsRequest, IFollowIndexStatsResponse>(
+						v => new FollowIndexStatsRequest(CopyIndex(v)),
+						(v, d) => d,
+						(v, c, f) => c.FollowIndexStats(CopyIndex(v), f),
+						(v, c, f) => c.FollowIndexStatsAsync(CopyIndex(v), f),
+						(v, c, r) => c.FollowIndexStats(r),
+						(v, c, r) => c.FollowIndexStatsAsync(r)
+					)
+			},
+			{
+				GlobalStatsStep, u => u.Calls<CcrStatsDescriptor, CcrStatsRequest, ICcrStatsRequest, ICcrStatsResponse>(
+						v => new CcrStatsRequest(),
+						(v, d) => d,
+						(v, c, f) => c.CcrStats(f),
+						(v, c, f) => c.CcrStatsAsync(f),
+						(v, c, r) => c.CcrStats(r),
+						(v, c, r) => c.CcrStatsAsync(r)
+					)
+			},
+			{
+				UnfollowStep, u => u.Calls<UnfollowIndexDescriptor, UnfollowIndexRequest, IUnfollowIndexRequest, IUnfollowIndexResponse>
+				(
+					v => new UnfollowIndexRequest(CopyIndex(v)),
+					(v, d) => d,
+					(v, c, f) => c.UnfollowIndex(CopyIndex(v), f),
+					(v, c, f) => c.UnfollowIndexAsync(CopyIndex(v), f),
+					(v, c, r) => c.UnfollowIndex(r),
+					(v, c, r) => c.UnfollowIndexAsync(r)
+				)
+			},
+			{
+				PauseForCloseStep, u => u.Call(async (v, c) => await c.PauseFollowIndexAsync(CopyIndex(v)))
+			},
+			{
+				CloseIndexStep, u => u.Call(async (v, c) => await c.CloseIndexAsync(CopyIndex(v)))
+			},
+			{
+				UnfollowAgainStep, u => u.Calls<UnfollowIndexDescriptor, UnfollowIndexRequest, IUnfollowIndexRequest, IUnfollowIndexResponse>
+				(
+					v => new UnfollowIndexRequest(CopyIndex(v)),
+					(v, d) => d,
+					(v, c, f) => c.UnfollowIndex(CopyIndex(v), f),
+					(v, c, f) => c.UnfollowIndexAsync(CopyIndex(v), f),
+					(v, c, r) => c.UnfollowIndex(r),
+					(v, c, r) => c.UnfollowIndexAsync(r)
+				)
+			},
+		}) { }
+
+		protected static string Prefix { get; } = $"f{Guid.NewGuid().ToString("N").Substring(0, 4)}";
+
+		private static string CopyIndex(string v) => $"{v}-copy";
+
+		[I] public async Task CreateReadOnlyIndexIsOk() => await Assert<CreateIndexResponse>(CreateIndexStep, r => r.Acknowledged.Should().BeTrue());
+
+		[I] public async Task IndexingDataIsOk() => await AssertRunsToCompletion(IndexDataStep);
+
+		[I] public async Task FollowResponseIsValid() => await Assert<CreateFollowIndexResponse>(FollowIndexStep, r =>
+		{
+			r.IsValid.Should().BeTrue();
+			r.FollowIndexCreated.Should().BeTrue();
+			r.FollowIndexShardsAcked.Should().BeTrue();
+			r.IndexFollowingStarted.Should().BeTrue();
+		});
+
+		[I] public async Task PauseIsAcked() => await Assert<PauseFollowIndexResponse>(PauseFollowStep, r => r.Acknowledged.Should().BeTrue());
+
+		[I] public async Task ResumeIsAcked() => await Assert<ResumeFollowIndexResponse>(ResumeFollowStep, r => r.Acknowledged.Should().BeTrue());
+
+		[I] public async Task CountBeforeHasDocs() => await Assert<CountResponse>(CountBeforeStep, r => r.Count.Should().Be(1000));
+
+		[I] public async Task FollowStatsResponse() => await Assert<FollowIndexStatsResponse>(FollowStatsStep, r =>
+		{
+			r.IsValid.Should().BeTrue();
+			r.Indices.Should().NotBeEmpty();
+			r.Indices.Count.Should().BeGreaterOrEqualTo(4);
+			var currentIndices = r.Indices.Where(i => i.Index.StartsWith(Prefix)).ToArray();
+			currentIndices.Should().HaveCount(4);
+			foreach (var i in currentIndices)
+			{
+				i.Index.Should().NotBeNullOrWhiteSpace("index name");
+				i.Shards.Should().NotBeEmpty();
+				foreach (var s in i.Shards)
+				{
+					var because = $"index: {i.Index} shard: {s.ShardId}";
+					s.RemoteCluster.Should().Be(DefaultSeeder.RemoteClusterName);
+					s.LeaderIndex.Should().NotBeNullOrWhiteSpace("leader_index");
+					s.FollowerIndex.Should().NotBeNullOrWhiteSpace("follower_index");
+					s.LeaderGlobalCheckpoint.Should().BeGreaterOrEqualTo(-1, nameof(FollowIndexShardStats.LeaderGlobalCheckpoint));
+					s.LeaderMaxSequenceNumber.Should().BeGreaterOrEqualTo(-1, nameof(FollowIndexShardStats.LeaderMaxSequenceNumber));
+					s.LastRequestedSequenceNumber.Should().BeGreaterOrEqualTo(-1, nameof(FollowIndexShardStats.LastRequestedSequenceNumber));
+					s.ReadExceptions.Should().NotBeNull(because).And.BeEmpty(because);
+				}
+			}
+		});
+
+		[I] public async Task GlobalStatsResponse() => await Assert<CcrStatsResponse>(GlobalStatsStep, r =>
+		{
+			r.IsValid.Should().BeTrue();
+			r.FollowStats.Should().NotBeNull();
+			var indices = r.FollowStats.Indices;
+			indices.Should().NotBeEmpty();
+			indices.Count.Should().BeGreaterOrEqualTo(4);
+			var currentIndices = indices.Where(i => i.Index.StartsWith(Prefix)).ToArray();
+			currentIndices.Should().HaveCount(4);
+			AssertErrorsOnShardStats(currentIndices);
+		});
+
+		[I] public async Task LeadersAreDeleted() =>
+			await Assert<DeleteIndexResponse>(DeleteOriginalIndicesStep, r => r.Acknowledged.Should().BeTrue());
+
+		[I] public async Task FollowStatsResponseAgain() => await Assert<FollowIndexStatsResponse>(FollowStatsAgainStep, r =>
+		{
+			r.IsValid.Should().BeTrue();
+			r.Indices.Should().NotBeEmpty();
+			var currentIndices = r.Indices.Where(i => i.Index.StartsWith(Prefix)).ToArray();
+			currentIndices.Should().HaveCount(4);
+			AssertErrorsOnShardStats(currentIndices);
+		});
+
+		private static void AssertErrorsOnShardStats(FollowIndexStats[] currentIndices)
+		{
+			foreach (var i in currentIndices)
+			{
+				i.Index.Should().NotBeNullOrWhiteSpace("index name");
+				i.Shards.Should().NotBeEmpty($"shards is empty on {i.Index}");
+				foreach (var s in i.Shards)
+				{
+					var because = $"index: {i.Index} shard: {s.ShardId}";
+					s.ReadExceptions.Should().NotBeEmpty(because);
+					foreach (var e in s.ReadExceptions)
+					{
+						e.Retries.Should().BeGreaterThan(0, because);
+						e.FromSquenceNumber.Should().BeGreaterThan(0, because);
+						e.Exception.Should().NotBeNull(because);
+						e.Exception.Type.Should().NotBeNullOrWhiteSpace().And.EndWith("_exception", because);
+					}
+					if (s.FatalException != null)
+					{
+						//eventhough read exceptions is set fatal exception can still be null (race condition?).
+						s.FatalException.Should().NotBeNull($"{s.FollowerIndex}", because);
+						s.FatalException.Type.Should().NotBeNullOrWhiteSpace().And.EndWith("_exception", because);
+					}
+				}
+			}
+		}
+
+		[I] public async Task UnfollowReturns() => await AssertRunsToCompletion(UnfollowAgainStep);
+
+		[I] public async Task UnfollowWithoutCloseIsAcked() => await Assert<UnfollowIndexResponse>(UnfollowStep, r =>
+		{
+			r.IsValid.Should().BeFalse();
+			r.ServerError.Should().NotBeNull();
+		});
+
+		[I] public async Task PauseBeforeCloseIsAcked() =>
+			await Assert<PauseFollowIndexResponse>(PauseForCloseStep, r => r.Acknowledged.Should().BeTrue());
+
+		[I] public async Task CloseIsAcked() => await Assert<CloseIndexResponse>(CloseIndexStep, r => r.Acknowledged.Should().BeTrue());
+
+		[I] public async Task UnfollowAfterCloseIsAcked() =>
+			await Assert<UnfollowIndexResponse>(UnfollowAgainStep, r => r.Acknowledged.Should().BeTrue());
+	}
+}
diff --git a/src/Tests/Tests/XPack/CrossClusterReplication/Follow/CreateFollowIndex/CreateFollowIndexApiTests.cs b/src/Tests/Tests/XPack/CrossClusterReplication/Follow/CreateFollowIndex/CreateFollowIndexApiTests.cs
new file mode 100644
index 00000000000..c1100f7d9b8
--- /dev/null
+++ b/src/Tests/Tests/XPack/CrossClusterReplication/Follow/CreateFollowIndex/CreateFollowIndexApiTests.cs
@@ -0,0 +1,75 @@
+using System;
+using Elasticsearch.Net;
+using Nest;
+using Tests.Core.ManagedElasticsearch.Clusters;
+using Tests.Framework;
+using Tests.Framework.Integration;
+
+namespace Tests.XPack.CrossClusterReplication.Follow.CreateFollowIndex
+{
+	public class CreateFollowIndexApiTests : ApiTestBase<XPackCluster, ICreateFollowIndexResponse, ICreateFollowIndexRequest, CreateFollowIndexDescriptor, CreateFollowIndexRequest>
+	{
+		public CreateFollowIndexApiTests(XPackCluster cluster, EndpointUsage usage) : base(cluster, usage) { }
+
+		protected override object ExpectJson { get; } = new
+		{
+			leader_index = "leader",
+			max_outstanding_read_requests = 100,
+			max_outstanding_write_requests = 101,
+			max_read_request_operation_count = 102,
+			max_read_request_size = "4mb",
+			max_retry_delay = "1m",
+			max_write_buffer_count = 104,
+			max_write_buffer_size = "1mb",
+			max_write_request_operation_count = 103,
+			max_write_request_size = "3mb",
+			read_poll_timeout = "2m",
+			remote_cluster = "x"
+		};
+
+		protected override CreateFollowIndexDescriptor NewDescriptor() => new CreateFollowIndexDescriptor("x");
+
+		protected override Func<CreateFollowIndexDescriptor, ICreateFollowIndexRequest> Fluent => d => d
+			.RemoteCluster("x")
+			.MaxWriteBufferSize("1mb")
+			.MaxOutstandingReadRequests(100)
+			.MaxOutstandingWriteRequests( 101)
+			.MaxReadRequestOperationCount(102)
+			.MaxWriteRequestOperationCount(103)
+			.MaxRetryDelay("1m")
+			.MaxWriteBufferCount(104)
+			.MaxWriteRequestSize("3mb")
+			.MaxRequestSize("4mb")
+			.ReadPollTimeout("2m")
+			.LeaderIndex("leader")
+		;
+
+		protected override HttpMethod HttpMethod => HttpMethod.PUT;
+
+		protected override CreateFollowIndexRequest Initializer => new CreateFollowIndexRequest("x")
+		{
+			RemoteCluster = "x",
+			MaxWriteBufferSize = "1mb",
+			MaxOutstandingReadRequests = 100,
+			MaxOutstandingWriteRequests = 101,
+			MaxReadRequestOperationCount = 102,
+			MaxWriteRequestOperationCount = 103,
+			MaxRetryDelay = "1m",
+			MaxWriteBufferCount = 104,
+			MaxWriteRequestSize = "3mb",
+			MaxRequestSize = "4mb",
+			ReadPollTimeout = "2m",
+			LeaderIndex = "leader",
+		};
+
+		protected override bool SupportsDeserialization => false;
+		protected override string UrlPath => $"/x/_ccr/follow";
+
+		protected override LazyResponses ClientUsage() => Calls(
+			(client, f) => client.CreateFollowIndex("x", f),
+			(client, f) => client.CreateFollowIndexAsync("x", f),
+			(client, r) => client.CreateFollowIndex(r),
+			(client, r) => client.CreateFollowIndexAsync(r)
+		);
+	}
+}
diff --git a/src/Tests/Tests/XPack/CrossClusterReplication/Follow/CreateFollowIndex/CreateFollowIndexUrlTests.cs b/src/Tests/Tests/XPack/CrossClusterReplication/Follow/CreateFollowIndex/CreateFollowIndexUrlTests.cs
new file mode 100644
index 00000000000..78dff5cb3da
--- /dev/null
+++ b/src/Tests/Tests/XPack/CrossClusterReplication/Follow/CreateFollowIndex/CreateFollowIndexUrlTests.cs
@@ -0,0 +1,21 @@
+using System.Threading.Tasks;
+using Elastic.Xunit.XunitPlumbing;
+using Nest;
+using Tests.Framework;
+
+namespace Tests.XPack.CrossClusterReplication.Follow.CreateFollowIndex
+{
+	public class CreateFollowIndexUrlTests : UrlTestsBase
+	{
+		[U] public override async Task Urls()
+		{
+			var name = "x";
+			await UrlTester.PUT($"/{name}/_ccr/follow")
+				.Fluent(c => c.CreateFollowIndex(name, d => d))
+				.Request(c => c.CreateFollowIndex(new CreateFollowIndexRequest(name)))
+				.FluentAsync(c => c.CreateFollowIndexAsync(name, d => d))
+				.RequestAsync(c => c.CreateFollowIndexAsync(new CreateFollowIndexRequest(name)));
+
+		}
+	}
+}
diff --git a/src/Tests/Tests/XPack/CrossClusterReplication/Follow/FollowIndexStats/FollowIndexStatsUrlTests.cs b/src/Tests/Tests/XPack/CrossClusterReplication/Follow/FollowIndexStats/FollowIndexStatsUrlTests.cs
new file mode 100644
index 00000000000..ccb1ed250ab
--- /dev/null
+++ b/src/Tests/Tests/XPack/CrossClusterReplication/Follow/FollowIndexStats/FollowIndexStatsUrlTests.cs
@@ -0,0 +1,21 @@
+using System.Threading.Tasks;
+using Elastic.Xunit.XunitPlumbing;
+using Nest;
+using Tests.Framework;
+
+namespace Tests.XPack.CrossClusterReplication.Follow.FollowIndexStats
+{
+	public class FollowIndexStatsUrlTests : UrlTestsBase
+	{
+		[U] public override async Task Urls()
+		{
+			var name = "x";
+			await UrlTester.GET($"/{name}/_ccr/stats")
+				.Fluent(c => c.FollowIndexStats(name, d => d))
+				.Request(c => c.FollowIndexStats(new FollowIndexStatsRequest(name)))
+				.FluentAsync(c => c.FollowIndexStatsAsync(name, d => d))
+				.RequestAsync(c => c.FollowIndexStatsAsync(new FollowIndexStatsRequest(name)));
+
+		}
+	}
+}
diff --git a/src/Tests/Tests/XPack/CrossClusterReplication/Follow/PauseFollowIndex/PauseFollowIndexUrlTests.cs b/src/Tests/Tests/XPack/CrossClusterReplication/Follow/PauseFollowIndex/PauseFollowIndexUrlTests.cs
new file mode 100644
index 00000000000..a1124838c65
--- /dev/null
+++ b/src/Tests/Tests/XPack/CrossClusterReplication/Follow/PauseFollowIndex/PauseFollowIndexUrlTests.cs
@@ -0,0 +1,21 @@
+using System.Threading.Tasks;
+using Elastic.Xunit.XunitPlumbing;
+using Nest;
+using Tests.Framework;
+
+namespace Tests.XPack.CrossClusterReplication.Follow.PauseFollowIndex
+{
+	public class PauseFollowIndexUrlTests : UrlTestsBase
+	{
+		[U] public override async Task Urls()
+		{
+			var name = "x";
+			await UrlTester.POST($"/{name}/_ccr/pause_follow")
+				.Fluent(c => c.PauseFollowIndex(name, d => d))
+				.Request(c => c.PauseFollowIndex(new PauseFollowIndexRequest(name)))
+				.FluentAsync(c => c.PauseFollowIndexAsync(name, d => d))
+				.RequestAsync(c => c.PauseFollowIndexAsync(new PauseFollowIndexRequest(name)));
+
+		}
+	}
+}
diff --git a/src/Tests/Tests/XPack/CrossClusterReplication/Follow/ResumeFollowIndex/ResumeFollowIndexApiTests.cs b/src/Tests/Tests/XPack/CrossClusterReplication/Follow/ResumeFollowIndex/ResumeFollowIndexApiTests.cs
new file mode 100644
index 00000000000..61e5fbe6dcc
--- /dev/null
+++ b/src/Tests/Tests/XPack/CrossClusterReplication/Follow/ResumeFollowIndex/ResumeFollowIndexApiTests.cs
@@ -0,0 +1,69 @@
+using System;
+using Elasticsearch.Net;
+using Nest;
+using Tests.Core.ManagedElasticsearch.Clusters;
+using Tests.Framework;
+using Tests.Framework.Integration;
+
+namespace Tests.XPack.CrossClusterReplication.Follow.ResumeFollowIndex
+{
+	public class ResumeFollowIndexApiTests : ApiTestBase<XPackCluster, IResumeFollowIndexResponse, IResumeFollowIndexRequest, ResumeFollowIndexDescriptor, ResumeFollowIndexRequest>
+	{
+		public ResumeFollowIndexApiTests(XPackCluster cluster, EndpointUsage usage) : base(cluster, usage) { }
+
+		protected override object ExpectJson { get; } = new
+		{
+			max_outstanding_read_requests = 100,
+			max_outstanding_write_requests = 101,
+			max_read_request_operation_count = 102,
+			max_read_request_size = "4mb",
+			max_retry_delay = "1m",
+			max_write_buffer_count = 104,
+			max_write_buffer_size = "1mb",
+			max_write_request_operation_count = 103,
+			max_write_request_size = "3mb",
+			read_poll_timeout = "2m",
+		};
+
+		protected override ResumeFollowIndexDescriptor NewDescriptor() => new ResumeFollowIndexDescriptor("x");
+
+		protected override Func<ResumeFollowIndexDescriptor, IResumeFollowIndexRequest> Fluent => d => d
+			.MaxWriteBufferSize("1mb")
+			.MaxOutstandingReadRequests(100)
+			.MaxOutstandingWriteRequests( 101)
+			.MaxReadRequestOperationCount(102)
+			.MaxWriteRequestOperationCount(103)
+			.MaxRetryDelay("1m")
+			.MaxWriteBufferCount(104)
+			.MaxWriteRequestSize("3mb")
+			.MaxRequestSize("4mb")
+			.ReadPollTimeout("2m")
+		;
+
+		protected override HttpMethod HttpMethod => HttpMethod.POST;
+
+		protected override ResumeFollowIndexRequest Initializer => new ResumeFollowIndexRequest("x")
+		{
+			MaxWriteBufferSize = "1mb",
+			MaxOutstandingReadRequests = 100,
+			MaxOutstandingWriteRequests = 101,
+			MaxReadRequestOperationCount = 102,
+			MaxWriteRequestOperationCount = 103,
+			MaxRetryDelay = "1m",
+			MaxWriteBufferCount = 104,
+			MaxWriteRequestSize = "3mb",
+			MaxRequestSize = "4mb",
+			ReadPollTimeout = "2m",
+		};
+
+		protected override bool SupportsDeserialization => false;
+		protected override string UrlPath => $"/x/_ccr/resume_follow";
+
+		protected override LazyResponses ClientUsage() => Calls(
+			(client, f) => client.ResumeFollowIndex("x", f),
+			(client, f) => client.ResumeFollowIndexAsync("x", f),
+			(client, r) => client.ResumeFollowIndex(r),
+			(client, r) => client.ResumeFollowIndexAsync(r)
+		);
+	}
+}
diff --git a/src/Tests/Tests/XPack/CrossClusterReplication/Follow/ResumeFollowIndex/ResumeFollowIndexUrlTests.cs b/src/Tests/Tests/XPack/CrossClusterReplication/Follow/ResumeFollowIndex/ResumeFollowIndexUrlTests.cs
new file mode 100644
index 00000000000..2c2c3db99f0
--- /dev/null
+++ b/src/Tests/Tests/XPack/CrossClusterReplication/Follow/ResumeFollowIndex/ResumeFollowIndexUrlTests.cs
@@ -0,0 +1,21 @@
+using System.Threading.Tasks;
+using Elastic.Xunit.XunitPlumbing;
+using Nest;
+using Tests.Framework;
+
+namespace Tests.XPack.CrossClusterReplication.Follow.ResumeFollowIndex
+{
+	public class ResumeFollowIndexUrlTests : UrlTestsBase
+	{
+		[U] public override async Task Urls()
+		{
+			var name = "x";
+			await UrlTester.POST($"/{name}/_ccr/resume_follow")
+				.Fluent(c => c.ResumeFollowIndex(name, d => d))
+				.Request(c => c.ResumeFollowIndex(new ResumeFollowIndexRequest(name)))
+				.FluentAsync(c => c.ResumeFollowIndexAsync(name, d => d))
+				.RequestAsync(c => c.ResumeFollowIndexAsync(new ResumeFollowIndexRequest(name)));
+
+		}
+	}
+}
diff --git a/src/Tests/Tests/XPack/CrossClusterReplication/Follow/UnfollowIndex/UnfollowIndexUrlTests.cs b/src/Tests/Tests/XPack/CrossClusterReplication/Follow/UnfollowIndex/UnfollowIndexUrlTests.cs
new file mode 100644
index 00000000000..c572f8d4759
--- /dev/null
+++ b/src/Tests/Tests/XPack/CrossClusterReplication/Follow/UnfollowIndex/UnfollowIndexUrlTests.cs
@@ -0,0 +1,21 @@
+using System.Threading.Tasks;
+using Elastic.Xunit.XunitPlumbing;
+using Nest;
+using Tests.Framework;
+
+namespace Tests.XPack.CrossClusterReplication.Follow.UnfollowIndex
+{
+	public class UnfollowIndexUrlTests : UrlTestsBase
+	{
+		[U] public override async Task Urls()
+		{
+			var name = "x";
+			await UrlTester.POST($"/{name}/_ccr/unfollow")
+				.Fluent(c => c.UnfollowIndex(name, d => d))
+				.Request(c => c.UnfollowIndex(new UnfollowIndexRequest(name)))
+				.FluentAsync(c => c.UnfollowIndexAsync(name, d => d))
+				.RequestAsync(c => c.UnfollowIndexAsync(new UnfollowIndexRequest(name)));
+
+		}
+	}
+}
diff --git a/src/Tests/Tests/XPack/CrossClusterReplication/Stats/CcrStatsUrlTests.cs b/src/Tests/Tests/XPack/CrossClusterReplication/Stats/CcrStatsUrlTests.cs
new file mode 100644
index 00000000000..18caf7e1bb5
--- /dev/null
+++ b/src/Tests/Tests/XPack/CrossClusterReplication/Stats/CcrStatsUrlTests.cs
@@ -0,0 +1,17 @@
+using System.Threading.Tasks;
+using Elastic.Xunit.XunitPlumbing;
+using Nest;
+using Tests.Framework;
+
+namespace Tests.XPack.CrossClusterReplication.Stats
+{
+	public class CcrStatsUrlTests : UrlTestsBase
+	{
+		[U] public override async Task Urls() =>
+			await UrlTester.GET($"/_ccr/stats")
+				.Fluent(c => c.CcrStats(d => d))
+				.Request(c => c.CcrStats(new CcrStatsRequest()))
+				.FluentAsync(c => c.CcrStatsAsync(d => d))
+				.RequestAsync(c => c.CcrStatsAsync(new CcrStatsRequest()));
+	}
+}