diff --git a/src/Nest/Analysis/Analysis.cs b/src/Nest/Analysis/Analysis.cs
index dd2b1b4f833..93e73ad86b1 100644
--- a/src/Nest/Analysis/Analysis.cs
+++ b/src/Nest/Analysis/Analysis.cs
@@ -21,7 +21,6 @@ public class Analysis : IAnalysis
 		public ICharFilters CharFilters { get; set; }
 		public ITokenFilters TokenFilters { get; set; }
 		public ITokenizers Tokenizers { get; set; }
-
 	}
 
 	public class AnalysisDescriptor : DescriptorBase<AnalysisDescriptor, IAnalysis>, IAnalysis
@@ -44,4 +43,4 @@ public AnalysisDescriptor Tokenizers(Func<TokenizersDescriptor, IPromise<ITokeni
 			Assign(a => a.Tokenizers = selector?.Invoke(new TokenizersDescriptor())?.Value);
 
 	}
-}
\ No newline at end of file
+}
diff --git a/src/Nest/Analysis/Analyzers/AnalyzerJsonConverter.cs b/src/Nest/Analysis/Analyzers/AnalyzerJsonConverter.cs
index 13e3f0819ee..215bc72b5b7 100644
--- a/src/Nest/Analysis/Analyzers/AnalyzerJsonConverter.cs
+++ b/src/Nest/Analysis/Analyzers/AnalyzerJsonConverter.cs
@@ -28,6 +28,7 @@ public override object ReadJson(JsonReader reader, Type objectType, object exist
 				case "whitespace": return o.ToObject<WhitespaceAnalyzer>(ElasticContractResolver.Empty);
 				case "simple": return o.ToObject<SimpleAnalyzer>(ElasticContractResolver.Empty);
 				case "fingerprint": return o.ToObject<FingerprintAnalyzer>(ElasticContractResolver.Empty);
+				case "kuromoji": return o.ToObject<KuromojiAnalyzer>(ElasticContractResolver.Empty);
 				default:
 					if (o.Property("tokenizer") != null)
 						return o.ToObject<CustomAnalyzer>(ElasticContractResolver.Empty);
diff --git a/src/Nest/Analysis/Analyzers/Analyzers.cs b/src/Nest/Analysis/Analyzers/Analyzers.cs
index dfb3a9a5798..990d9882417 100644
--- a/src/Nest/Analysis/Analyzers/Analyzers.cs
+++ b/src/Nest/Analysis/Analyzers/Analyzers.cs
@@ -91,5 +91,11 @@ public AnalyzersDescriptor Whitespace(string name, Func<WhitespaceAnalyzerDescri
 		public AnalyzersDescriptor Fingerprint(string name, Func<FingerprintAnalyzerDescriptor, IFingerprintAnalyzer> selector = null) =>
 			Assign(name, selector.InvokeOrDefault(new FingerprintAnalyzerDescriptor()));
 
+		/// <summary>
+		/// An analyzer tailored for japanese that is bootstrapped with defaults.
+		/// Part of the `analysis-kuromoji` plugin: https://www.elastic.co/guide/en/elasticsearch/plugins/current/analysis-kuromoji.html
+		/// </summary>
+		public AnalyzersDescriptor Kuromoji(string name, Func<KuromojiAnalyzerDescriptor, IKuromojiAnalyzer> selector = null) =>
+			Assign(name, selector.InvokeOrDefault(new KuromojiAnalyzerDescriptor()));
 	}
 }
diff --git a/src/Nest/Analysis/CharFilters/CharFilterJsonConverter.cs b/src/Nest/Analysis/CharFilters/CharFilterJsonConverter.cs
index ec159a5995a..5d225d60f4f 100644
--- a/src/Nest/Analysis/CharFilters/CharFilterJsonConverter.cs
+++ b/src/Nest/Analysis/CharFilters/CharFilterJsonConverter.cs
@@ -23,6 +23,7 @@ public override object ReadJson(JsonReader reader, Type objectType, object exist
 				case "html_strip": return o.ToObject<HtmlStripCharFilter>(ElasticContractResolver.Empty);
 				case "mapping": return o.ToObject<MappingCharFilter>(ElasticContractResolver.Empty);
 				case "pattern_replace": return o.ToObject<PatternReplaceCharFilter>(ElasticContractResolver.Empty);
+				case "kuromoji_iteration_mark": return o.ToObject<KuromojiIterationMarkCharFilter>(ElasticContractResolver.Empty);
 			}
 			return null;
 		}
diff --git a/src/Nest/Analysis/CharFilters/CharFilters.cs b/src/Nest/Analysis/CharFilters/CharFilters.cs
index 53616fb66e2..1d64057e01b 100644
--- a/src/Nest/Analysis/CharFilters/CharFilters.cs
+++ b/src/Nest/Analysis/CharFilters/CharFilters.cs
@@ -24,9 +24,9 @@ public class CharFiltersDescriptor : IsADictionaryDescriptorBase<CharFiltersDesc
 		public CharFiltersDescriptor() : base(new CharFilters()) { }
 
 		public CharFiltersDescriptor UserDefined(string name, ICharFilter analyzer) => Assign(name, analyzer);
-		
+
 		/// <summary>
-		/// The pattern_replace char filter allows the use of a regex to manipulate the characters in a string before analysis. 
+		/// The pattern_replace char filter allows the use of a regex to manipulate the characters in a string before analysis.
 		/// </summary>
 		public CharFiltersDescriptor PatternReplace(string name, Func<PatternReplaceCharFilterDescriptor, IPatternReplaceCharFilter> selector) =>
 			Assign(name, selector?.Invoke(new PatternReplaceCharFilterDescriptor()));
@@ -43,5 +43,12 @@ public CharFiltersDescriptor HtmlStrip(string name, Func<HtmlStripCharFilterDesc
 		public CharFiltersDescriptor Mapping(string name, Func<MappingCharFilterDescriptor, IMappingCharFilter> selector) =>
 			Assign(name, selector?.Invoke(new MappingCharFilterDescriptor()));
 
+		/// <summary>
+		/// The kuromoji_iteration_mark normalizes Japanese horizontal iteration marks (odoriji) to their expanded form.
+		/// Part of the `analysis-kuromoji` plugin: https://www.elastic.co/guide/en/elasticsearch/plugins/current/analysis-kuromoji.html
+		/// </summary>
+		public CharFiltersDescriptor KuromojiIterationMark(string name, Func<KuromojiIterationMarkCharFilterDescriptor, IKuromojiIterationMarkCharFilter> selector = null) =>
+			Assign(name, selector?.InvokeOrDefault(new KuromojiIterationMarkCharFilterDescriptor()));
+
 	}
 }
diff --git a/src/Nest/Analysis/Plugins/Kuromoji/KuromojiAnalyzer.cs b/src/Nest/Analysis/Plugins/Kuromoji/KuromojiAnalyzer.cs
new file mode 100644
index 00000000000..d99140f0ce6
--- /dev/null
+++ b/src/Nest/Analysis/Plugins/Kuromoji/KuromojiAnalyzer.cs
@@ -0,0 +1,43 @@
+using System.Collections.Generic;
+using Newtonsoft.Json;
+
+namespace Nest
+{
+	/// <summary>
+	/// An analyzer tailored for japanese that is bootstrapped with defaults.
+	/// Part of the `analysis-kuromoji` plugin: https://www.elastic.co/guide/en/elasticsearch/plugins/current/analysis-kuromoji.html
+	/// </summary>
+	public interface IKuromojiAnalyzer : IAnalyzer
+	{
+		[JsonProperty("mode")]
+		KuromojiTokenizationMode? Mode { get; set; }
+
+		[JsonProperty("user_dictionary")]
+		string UserDictionary { get; set; }
+	}
+
+	/// <inheritdoc/>
+	public class KuromojiAnalyzer : AnalyzerBase, IKuromojiAnalyzer
+	{
+		public KuromojiAnalyzer() : base("kuromoji") {}
+
+		public KuromojiTokenizationMode? Mode { get; set; }
+
+		public string UserDictionary { get; set; }
+	}
+
+	/// <inheritdoc/>
+	public class KuromojiAnalyzerDescriptor :
+		AnalyzerDescriptorBase<KuromojiAnalyzerDescriptor, IKuromojiAnalyzer>, IKuromojiAnalyzer
+	{
+		protected override string Type => "kuromoji";
+
+		KuromojiTokenizationMode? IKuromojiAnalyzer.Mode { get; set; }
+		string IKuromojiAnalyzer.UserDictionary { get; set; }
+
+		public KuromojiAnalyzerDescriptor Mode(KuromojiTokenizationMode? mode) => Assign(a => a.Mode = mode);
+
+		public KuromojiAnalyzerDescriptor UserDictionary(string userDictionary) => Assign(a => a.UserDictionary = userDictionary);
+
+	}
+}
diff --git a/src/Nest/Analysis/Plugins/Kuromoji/KuromojiIterationMarkCharFilter.cs b/src/Nest/Analysis/Plugins/Kuromoji/KuromojiIterationMarkCharFilter.cs
new file mode 100644
index 00000000000..9f30fc52c79
--- /dev/null
+++ b/src/Nest/Analysis/Plugins/Kuromoji/KuromojiIterationMarkCharFilter.cs
@@ -0,0 +1,47 @@
+using System.Collections.Generic;
+using Newtonsoft.Json;
+
+namespace Nest
+{
+	/// <summary>
+	/// The kuromoji_iteration_mark normalizes Japanese horizontal iteration marks (odoriji) to their expanded form.
+	/// Part of the `analysis-kuromoji` plugin: https://www.elastic.co/guide/en/elasticsearch/plugins/current/analysis-kuromoji.html
+	/// </summary>
+	public interface IKuromojiIterationMarkCharFilter : ICharFilter
+	{
+		[JsonProperty("normalize_kanji")]
+		bool? NormalizeKanji { get; set; }
+
+		[JsonProperty("normalize_kana")]
+		bool? NormalizeKana { get; set; }
+	}
+	/// <inheritdoc/>
+	public class KuromojiIterationMarkCharFilter : CharFilterBase, IKuromojiIterationMarkCharFilter
+	{
+		public KuromojiIterationMarkCharFilter() : base("kuromoji_iteration_mark") { }
+
+		/// <inheritdoc/>
+		public bool? NormalizeKanji { get; set; }
+
+		/// <inheritdoc/>
+		public bool? NormalizeKana { get; set; }
+	}
+
+	/// <inheritdoc/>
+	public class KuromojiIterationMarkCharFilterDescriptor
+		: CharFilterDescriptorBase<KuromojiIterationMarkCharFilterDescriptor, IKuromojiIterationMarkCharFilter>, IKuromojiIterationMarkCharFilter
+	{
+		protected override string Type => "kuromoji_iteration_mark";
+		bool? IKuromojiIterationMarkCharFilter.NormalizeKanji { get; set; }
+		bool? IKuromojiIterationMarkCharFilter.NormalizeKana { get; set; }
+
+		/// <inheritdoc/>
+		public KuromojiIterationMarkCharFilterDescriptor NormalizeKanji(bool? normalize = true) =>
+			Assign(a => a.NormalizeKanji = normalize);
+
+		/// <inheritdoc/>
+		public KuromojiIterationMarkCharFilterDescriptor NormalizeKana(bool? normalize = true) =>
+			Assign(a => a.NormalizeKana = normalize);
+
+	}
+}
diff --git a/src/Nest/Analysis/Plugins/Kuromoji/KuromojiPartOfSpeechTokenFilter.cs b/src/Nest/Analysis/Plugins/Kuromoji/KuromojiPartOfSpeechTokenFilter.cs
new file mode 100644
index 00000000000..b244f976973
--- /dev/null
+++ b/src/Nest/Analysis/Plugins/Kuromoji/KuromojiPartOfSpeechTokenFilter.cs
@@ -0,0 +1,45 @@
+using System.Collections.Generic;
+using Newtonsoft.Json;
+
+namespace Nest
+{
+	/// <summary>
+	/// The kuromoji_part_of_speech token filter removes tokens that match a set of part-of-speech tags.
+	/// Part of the `analysis-kuromoji` plugin: https://www.elastic.co/guide/en/elasticsearch/plugins/current/analysis-kuromoji.html
+	/// </summary>
+	public interface IKuromojiPartOfSpeechTokenFilter : ITokenFilter
+	{
+		/// <summary>
+		/// An array of part-of-speech tags that should be removed. It defaults to the stoptags.txt file embedded
+		/// in the lucene-analyzer-kuromoji.jar.
+		/// </summary>
+		[JsonProperty("stoptags")]
+		IEnumerable<string> StopTags { get; set; }
+	}
+
+	/// <inheritdoc/>
+	public class KuromojiPartOfSpeechTokenFilter : TokenFilterBase, IKuromojiPartOfSpeechTokenFilter
+	{
+		public KuromojiPartOfSpeechTokenFilter() : base("kuromoji_part_of_speech") { }
+
+		/// <inheritdoc/>
+		public IEnumerable<string> StopTags { get; set; }
+	}
+
+	///<inheritdoc/>
+	public class KuromojiPartOfSpeechTokenFilterDescriptor
+		: TokenFilterDescriptorBase<KuromojiPartOfSpeechTokenFilterDescriptor, IKuromojiPartOfSpeechTokenFilter>, IKuromojiPartOfSpeechTokenFilter
+	{
+		protected override string Type => "kuromoji_part_of_speech";
+
+		IEnumerable<string> IKuromojiPartOfSpeechTokenFilter.StopTags { get; set; }
+
+		///<inheritdoc/>
+		public KuromojiPartOfSpeechTokenFilterDescriptor StopTags(IEnumerable<string> stopTags) => Assign(a => a.StopTags = stopTags);
+
+		///<inheritdoc/>
+		public KuromojiPartOfSpeechTokenFilterDescriptor StopTags(params string[] stopTags) => Assign(a => a.StopTags = stopTags);
+
+	}
+
+}
diff --git a/src/Nest/Analysis/Plugins/Kuromoji/KuromojiReadingFormTokenFilter.cs b/src/Nest/Analysis/Plugins/Kuromoji/KuromojiReadingFormTokenFilter.cs
new file mode 100644
index 00000000000..4a3d21f53f6
--- /dev/null
+++ b/src/Nest/Analysis/Plugins/Kuromoji/KuromojiReadingFormTokenFilter.cs
@@ -0,0 +1,42 @@
+using System.Collections.Generic;
+using Newtonsoft.Json;
+
+namespace Nest
+{
+	/// <summary>
+	/// The kuromoji_readingform token filter replaces the token with its reading form in either katakana or romaji.
+	/// Part of the `analysis-kuromoji` plugin: https://www.elastic.co/guide/en/elasticsearch/plugins/current/analysis-kuromoji.html
+	/// </summary>
+	public interface IKuromojiReadingFormTokenFilter : ITokenFilter
+	{
+		/// <summary>
+		/// Whether romaji reading form should be output instead of katakana. Defaults to false.
+		/// </summary>
+		[JsonProperty("use_romaji")]
+		bool? UseRomaji { get; set; }
+	}
+
+	/// <inheritdoc/>
+	public class KuromojiReadingFormTokenFilter : TokenFilterBase, IKuromojiReadingFormTokenFilter
+	{
+		public KuromojiReadingFormTokenFilter() : base("kuromoji_readingform") { }
+
+		/// <inheritdoc/>
+		public bool? UseRomaji { get; set; }
+	}
+
+	///<inheritdoc/>
+	public class KuromojiReadingFormTokenFilterDescriptor
+		: TokenFilterDescriptorBase<KuromojiReadingFormTokenFilterDescriptor, IKuromojiReadingFormTokenFilter>, IKuromojiReadingFormTokenFilter
+	{
+		protected override string Type => "kuromoji_readingform";
+
+		bool? IKuromojiReadingFormTokenFilter.UseRomaji { get; set; }
+
+		///<inheritdoc/>
+		public KuromojiReadingFormTokenFilterDescriptor UseRomaji(bool? useRomaji = true) => Assign(a => a.UseRomaji = useRomaji);
+
+
+	}
+
+}
diff --git a/src/Nest/Analysis/Plugins/Kuromoji/KuromojiStemmerTokenFilter.cs b/src/Nest/Analysis/Plugins/Kuromoji/KuromojiStemmerTokenFilter.cs
new file mode 100644
index 00000000000..503923d2724
--- /dev/null
+++ b/src/Nest/Analysis/Plugins/Kuromoji/KuromojiStemmerTokenFilter.cs
@@ -0,0 +1,41 @@
+using System;
+using System.Collections.Generic;
+using Newtonsoft.Json;
+
+namespace Nest
+{
+	/// <summary>
+	/// The kuromoji_stemmer token filter normalizes common katakana spelling variations ending in a
+	/// long sound character by removing this character (U+30FC). Only full-width katakana characters are supported.
+	/// Part of the `analysis-kuromoji` plugin: https://www.elastic.co/guide/en/elasticsearch/plugins/current/analysis-kuromoji.html
+	/// </summary>
+	public interface IKuromojiStemmerTokenFilter : ITokenFilter
+	{
+		/// <summary>
+		/// Katakana words shorter than the minimum length are not stemmed (default is 4).
+		/// </summary>
+		[JsonProperty("minimum_length")]
+		int? MinimumLength { get; set; }
+	}
+
+	/// <inheritdoc/>
+	public class KuromojiStemmerTokenFilter : TokenFilterBase, IKuromojiStemmerTokenFilter
+	{
+		public KuromojiStemmerTokenFilter() : base("kuromoji_stemmer") { }
+
+		/// <inheritdoc/>
+		public int? MinimumLength { get; set; }
+	}
+
+	///<inheritdoc/>
+	public class KuromojiStemmerTokenFilterDescriptor
+		: TokenFilterDescriptorBase<KuromojiStemmerTokenFilterDescriptor, IKuromojiStemmerTokenFilter>, IKuromojiStemmerTokenFilter
+	{
+		protected override string Type => "kuromoji_stemmer";
+
+		int? IKuromojiStemmerTokenFilter.MinimumLength { get; set; }
+
+		///<inheritdoc/>
+		public KuromojiStemmerTokenFilterDescriptor MinimumLength(int? minimumLength) => Assign(a => a.MinimumLength = minimumLength);
+	}
+}
diff --git a/src/Nest/Analysis/Plugins/Kuromoji/KuromojiTokenizationMode.cs b/src/Nest/Analysis/Plugins/Kuromoji/KuromojiTokenizationMode.cs
new file mode 100644
index 00000000000..b66b54429f2
--- /dev/null
+++ b/src/Nest/Analysis/Plugins/Kuromoji/KuromojiTokenizationMode.cs
@@ -0,0 +1,32 @@
+using System.Runtime.Serialization;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
+
+namespace Nest
+{
+	/// <summary>
+	/// The tokenization mode determines how the tokenizer handles compound and unknown words.
+	/// Part of the `analysis-kuromoji` plugin: https://www.elastic.co/guide/en/elasticsearch/plugins/current/analysis-kuromoji.html
+	/// </summary>
+	[JsonConverter(typeof(StringEnumConverter))]
+	public enum KuromojiTokenizationMode
+	{
+		/// <summary>
+		/// Normal segmentation, no decomposition for compounds
+		/// </summary>
+		[EnumMember(Value = "normal")]
+		Normal,
+		/// <summary>
+		/// Segmentation geared towards search. This includes a decompounding process for long nouns,
+		/// also including the full compound token as a synonym.
+		/// </summary>
+		[EnumMember(Value = "search")]
+		Search,
+		/// <summary>
+		/// Extended mode outputs unigrams for unknown words.
+		/// </summary>
+		[EnumMember(Value = "extended")]
+		Extended
+
+	}
+}
diff --git a/src/Nest/Analysis/Plugins/Kuromoji/KuromojiTokenizer.cs b/src/Nest/Analysis/Plugins/Kuromoji/KuromojiTokenizer.cs
new file mode 100644
index 00000000000..7c1eafe9487
--- /dev/null
+++ b/src/Nest/Analysis/Plugins/Kuromoji/KuromojiTokenizer.cs
@@ -0,0 +1,94 @@
+using Newtonsoft.Json;
+
+namespace Nest
+{
+	/// <summary>
+	/// A tokenizer of type pattern that can flexibly separate text into terms via a regular expression.
+	/// Part of the `analysis-kuromoji` plugin: https://www.elastic.co/guide/en/elasticsearch/plugins/current/analysis-kuromoji.html
+	/// </summary>
+	public interface IKuromojiTokenizer : ITokenizer
+	{
+		/// <summary>
+		/// The tokenization mode determines how the tokenizer handles compound and unknown words.
+		/// </summary>
+		[JsonProperty("mode")]
+		KuromojiTokenizationMode? Mode { get; set; }
+
+		/// <summary>
+		/// Whether punctuation should be discarded from the output. Defaults to true.
+		/// </summary>
+		[JsonProperty("discard_punctuation")]
+		bool? DiscardPunctuation { get; set; }
+
+		/// <summary>
+		/// The Kuromoji tokenizer uses the MeCab-IPADIC dictionary by default. A user_dictionary may be
+		/// appended to the default dictionary.
+		/// </summary>
+		[JsonProperty("user_dictionary")]
+		string UserDictionary { get; set; }
+
+		/// <summary>
+		///The nbest_examples can be used to find a nbest_cost value based on examples. For example,
+		/// a value of /箱根山-箱根/成田空港-成田/ indicates that in the texts, 箱根山 (Mt. Hakone) and 成田空港 (Narita Airport)
+		/// we’d like a cost that gives is us 箱根 (Hakone) and 成田 (Narita).
+		/// </summary>
+		[JsonProperty("nbest_examples")]
+		string NBestExamples { get; set; }
+
+		/// <summary>
+		/// The nbest_cost parameter specifies an additional Viterbi cost. The KuromojiTokenizer will include all tokens in
+		/// Viterbi paths that are within the nbest_cost value of the best path.
+		/// </summary>
+		[JsonProperty("nbest_cost")]
+		int? NBestCost { get; set; }
+	}
+
+	/// <inheritdoc/>
+	public class KuromojiTokenizer : TokenizerBase, IKuromojiTokenizer
+    {
+		public KuromojiTokenizer() { Type = "kuromoji_tokenizer"; }
+
+		/// <inheritdoc/>
+		public KuromojiTokenizationMode? Mode { get; set; }
+
+		/// <inheritdoc/>
+		public bool? DiscardPunctuation { get; set; }
+
+		/// <inheritdoc/>
+		public string UserDictionary { get; set; }
+
+		/// <inheritdoc/>
+		public string NBestExamples { get; set; }
+
+		/// <inheritdoc/>
+		public int? NBestCost { get; set; }
+    }
+
+	/// <inheritdoc/>
+	public class KuromojiTokenizerDescriptor
+		: TokenizerDescriptorBase<KuromojiTokenizerDescriptor, IKuromojiTokenizer>, IKuromojiTokenizer
+	{
+		protected override string Type => "kuromoji_tokenizer";
+
+		KuromojiTokenizationMode? IKuromojiTokenizer.Mode { get; set; }
+		bool? IKuromojiTokenizer.DiscardPunctuation { get; set; }
+		string IKuromojiTokenizer.UserDictionary { get; set; }
+		string IKuromojiTokenizer.NBestExamples { get; set; }
+		int? IKuromojiTokenizer.NBestCost { get; set; }
+
+		/// <inheritdoc/>
+		public KuromojiTokenizerDescriptor Mode(KuromojiTokenizationMode? mode) => Assign(a => a.Mode = mode);
+
+		/// <inheritdoc/>
+		public KuromojiTokenizerDescriptor DiscardPunctuation(bool? discard = true) => Assign(a => a.DiscardPunctuation = discard);
+
+		/// <inheritdoc/>
+		public KuromojiTokenizerDescriptor UserDictionary(string userDictionary) => Assign(a => a.UserDictionary = userDictionary);
+
+		/// <inheritdoc/>
+		public KuromojiTokenizerDescriptor NBestExamples(string examples) => Assign(a => a.NBestExamples = examples);
+
+		/// <inheritdoc/>
+		public KuromojiTokenizerDescriptor NBestCost(int? cost) => Assign(a => a.NBestCost = cost);
+	}
+}
diff --git a/src/Nest/Analysis/TokenFilters/Phonetic/PhoneticEncoder.cs b/src/Nest/Analysis/Plugins/Phonetic/PhoneticEncoder.cs
similarity index 100%
rename from src/Nest/Analysis/TokenFilters/Phonetic/PhoneticEncoder.cs
rename to src/Nest/Analysis/Plugins/Phonetic/PhoneticEncoder.cs
diff --git a/src/Nest/Analysis/TokenFilters/Phonetic/PhoneticTokenFilter.cs b/src/Nest/Analysis/Plugins/Phonetic/PhoneticTokenFilter.cs
similarity index 100%
rename from src/Nest/Analysis/TokenFilters/Phonetic/PhoneticTokenFilter.cs
rename to src/Nest/Analysis/Plugins/Phonetic/PhoneticTokenFilter.cs
diff --git a/src/Nest/Analysis/TokenFilters/TokenFilterJsonConverter.cs b/src/Nest/Analysis/TokenFilters/TokenFilterJsonConverter.cs
index 0896a502923..64778db3a78 100644
--- a/src/Nest/Analysis/TokenFilters/TokenFilterJsonConverter.cs
+++ b/src/Nest/Analysis/TokenFilters/TokenFilterJsonConverter.cs
@@ -54,6 +54,9 @@ public override object ReadJson(JsonReader reader, Type objectType, object exist
 				case "uppercase": return o.ToObject<UppercaseTokenFilter>(ElasticContractResolver.Empty);
 				case "word_delimiter": return o.ToObject<WordDelimiterTokenFilter>(ElasticContractResolver.Empty);
 				case "fingerprint": return o.ToObject<FingerprintTokenFilter>(ElasticContractResolver.Empty);
+				case "kuromoji_readingform": return o.ToObject<KuromojiReadingFormTokenFilter>(ElasticContractResolver.Empty);
+				case "kuromoji_part_of_speech": return o.ToObject<KuromojiPartOfSpeechTokenFilter>(ElasticContractResolver.Empty);
+				case "kuromoji_stemmer": return o.ToObject<KuromojiStemmerTokenFilter>(ElasticContractResolver.Empty);
 			}
 			return null;
 		}
diff --git a/src/Nest/Analysis/TokenFilters/TokenFilters.cs b/src/Nest/Analysis/TokenFilters/TokenFilters.cs
index f462dbed28c..867ce37807c 100644
--- a/src/Nest/Analysis/TokenFilters/TokenFilters.cs
+++ b/src/Nest/Analysis/TokenFilters/TokenFilters.cs
@@ -239,5 +239,26 @@ public TokenFiltersDescriptor Uppercase(string name, Func<UppercaseTokenFilterDe
 		public TokenFiltersDescriptor Fingerprint(string name, Func<FingerprintTokenFilterDescriptor, IFingerprintTokenFilter> selector = null) =>
 			Assign(name, selector.InvokeOrDefault(new FingerprintTokenFilterDescriptor()));
 
+		/// <summary>
+		/// The kuromoji_stemmer token filter normalizes common katakana spelling variations ending in a
+		/// long sound character by removing this character (U+30FC). Only full-width katakana characters are supported.
+		/// Part of the `analysis-kuromoji` plugin: https://www.elastic.co/guide/en/elasticsearch/plugins/current/analysis-kuromoji.html
+		/// </summary>
+		public TokenFiltersDescriptor KuromojiStemmer(string name, Func<KuromojiStemmerTokenFilterDescriptor, IKuromojiStemmerTokenFilter> selector = null) =>
+			Assign(name, selector.InvokeOrDefault(new KuromojiStemmerTokenFilterDescriptor()));
+
+		/// <summary>
+		/// The kuromoji_readingform token filter replaces the token with its reading form in either katakana or romaji.
+		/// Part of the `analysis-kuromoji` plugin: https://www.elastic.co/guide/en/elasticsearch/plugins/current/analysis-kuromoji.html
+		/// </summary>
+		public TokenFiltersDescriptor KuromojiReadingForm(string name, Func<KuromojiReadingFormTokenFilterDescriptor, IKuromojiReadingFormTokenFilter> selector = null) =>
+			Assign(name, selector.InvokeOrDefault(new KuromojiReadingFormTokenFilterDescriptor()));
+
+		/// <summary>
+		/// The kuromoji_part_of_speech token filter removes tokens that match a set of part-of-speech tags.
+		/// Part of the `analysis-kuromoji` plugin: https://www.elastic.co/guide/en/elasticsearch/plugins/current/analysis-kuromoji.html
+		/// </summary>
+		public TokenFiltersDescriptor KuromojiPartOfSpeech(string name, Func<KuromojiPartOfSpeechTokenFilterDescriptor, IKuromojiPartOfSpeechTokenFilter> selector = null) =>
+			Assign(name, selector.InvokeOrDefault(new KuromojiPartOfSpeechTokenFilterDescriptor()));
 	}
 }
diff --git a/src/Nest/Analysis/Tokenizers/PatternTokenizer.cs b/src/Nest/Analysis/Tokenizers/PatternTokenizer.cs
index cc011f77242..23df200c6c5 100644
--- a/src/Nest/Analysis/Tokenizers/PatternTokenizer.cs
+++ b/src/Nest/Analysis/Tokenizers/PatternTokenizer.cs
@@ -3,7 +3,7 @@
 namespace Nest
 {
 	/// <summary>
-	/// A tokenizer of type pattern that can flexibly separate text into terms via a regular expression. 
+	/// A tokenizer of type pattern that can flexibly separate text into terms via a regular expression.
 	/// </summary>
 	public interface IPatternTokenizer : ITokenizer
 	{
@@ -18,7 +18,7 @@ public interface IPatternTokenizer : ITokenizer
 		/// </summary>
 		[JsonProperty("flags")]
 		string Flags { get; set; }
-		
+
 		/// <summary>
 		/// Which group to extract into tokens. Defaults to -1 (split).
 		/// </summary>
@@ -32,17 +32,17 @@ public class PatternTokenizer : TokenizerBase, IPatternTokenizer
     {
 		public PatternTokenizer() { Type = "pattern"; }
 
-		/// <summary/>
+		/// <inheritdoc/>
 		public string Pattern { get; set; }
 
-		/// <summary/>
+		/// <inheritdoc/>
 		public string Flags { get; set; }
-		
+
 		/// <summary/>
 		public int? Group { get; set; }
     }
 	/// <inheritdoc/>
-	public class PatternTokenizerDescriptor 
+	public class PatternTokenizerDescriptor
 		: TokenizerDescriptorBase<PatternTokenizerDescriptor, IPatternTokenizer>, IPatternTokenizer
 	{
 		protected override string Type => "pattern";
@@ -61,4 +61,4 @@ public class PatternTokenizerDescriptor
 		public PatternTokenizerDescriptor Flags(string flags) => Assign(a => a.Flags = flags);
 
 	}
-}
\ No newline at end of file
+}
diff --git a/src/Nest/Analysis/Tokenizers/TokenizerJsonConverter.cs b/src/Nest/Analysis/Tokenizers/TokenizerJsonConverter.cs
index 0764e5af9f2..24ab45bf308 100644
--- a/src/Nest/Analysis/Tokenizers/TokenizerJsonConverter.cs
+++ b/src/Nest/Analysis/Tokenizers/TokenizerJsonConverter.cs
@@ -28,6 +28,7 @@ public override object ReadJson(JsonReader reader, Type objectType, object exist
 				case "standard": return o.ToObject<StandardTokenizer>(ElasticContractResolver.Empty);
 				case "uax_url_email": return o.ToObject<UaxEmailUrlTokenizer>(ElasticContractResolver.Empty);
 				case "whitespace": return o.ToObject<WhitespaceTokenizer>(ElasticContractResolver.Empty);
+				case "kuromoji_tokenizer": return o.ToObject<KuromojiTokenizer>(ElasticContractResolver.Empty);
 			}
 			return null;
 		}
diff --git a/src/Nest/Analysis/Tokenizers/Tokenizers.cs b/src/Nest/Analysis/Tokenizers/Tokenizers.cs
index a1573efd890..3cd460e77a7 100644
--- a/src/Nest/Analysis/Tokenizers/Tokenizers.cs
+++ b/src/Nest/Analysis/Tokenizers/Tokenizers.cs
@@ -44,14 +44,14 @@ public TokenizersDescriptor Keyword(string name, Func<KeywordTokenizerDescriptor
 			Assign(name, selector?.Invoke(new KeywordTokenizerDescriptor()));
 
 		/// <summary>
-		/// A tokenizer of type letter that divides text at non-letters. That’s to say, it defines tokens as maximal strings of adjacent letters. 
+		/// A tokenizer of type letter that divides text at non-letters. That’s to say, it defines tokens as maximal strings of adjacent letters.
 		/// <para>Note, this does a decent job for most European languages, but does a terrible job for some Asian languages, where words are not separated by spaces.</para>
 		/// </summary>
 		public TokenizersDescriptor Letter(string name, Func<LetterTokenizerDescriptor, ILetterTokenizer> selector) =>
 			Assign(name, selector?.Invoke(new LetterTokenizerDescriptor()));
 
 		/// <summary>
-		/// A tokenizer of type lowercase that performs the function of Letter Tokenizer and Lower Case Token Filter together. 
+		/// A tokenizer of type lowercase that performs the function of Letter Tokenizer and Lower Case Token Filter together.
 		/// <para>It divides text at non-letters and converts them to lower case. </para>
 		/// <para>While it is functionally equivalent to the combination of Letter Tokenizer and Lower Case Token Filter, </para>
 		/// <para>there is a performance advantage to doing the two tasks at once, hence this (redundant) implementation.</para>
@@ -72,13 +72,13 @@ public TokenizersDescriptor PathHierarchy(string name, Func<PathHierarchyTokeniz
 			Assign(name, selector?.Invoke(new PathHierarchyTokenizerDescriptor()));
 
 		/// <summary>
-		/// A tokenizer of type pattern that can flexibly separate text into terms via a regular expression. 
+		/// A tokenizer of type pattern that can flexibly separate text into terms via a regular expression.
 		/// </summary>
 		public TokenizersDescriptor Pattern(string name, Func<PatternTokenizerDescriptor, IPatternTokenizer> selector) =>
 			Assign(name, selector?.Invoke(new PatternTokenizerDescriptor()));
 
 		/// <summary>
-		/// A tokenizer of type standard providing grammar based tokenizer that is a good tokenizer for most European language documents. 
+		/// A tokenizer of type standard providing grammar based tokenizer that is a good tokenizer for most European language documents.
 		/// <para>The tokenizer implements the Unicode Text Segmentation algorithm, as specified in Unicode Standard Annex #29.</para>
 		/// </summary>
 		public TokenizersDescriptor Standard(string name, Func<StandardTokenizerDescriptor, IStandardTokenizer> selector = null) =>
@@ -95,5 +95,12 @@ public TokenizersDescriptor UaxEmailUrl(string name, Func<UaxEmailUrlTokenizerDe
 		/// </summary>
 		public TokenizersDescriptor Whitespace(string name, Func<WhitespaceTokenizerDescriptor, IWhitespaceTokenizer> selector = null) =>
 			Assign(name, selector.InvokeOrDefault(new WhitespaceTokenizerDescriptor()));
+
+		/// <summary>
+		/// A tokenizer of type pattern that can flexibly separate text into terms via a regular expression.
+		/// Part of the `analysis-kuromoji` plugin: https://www.elastic.co/guide/en/elasticsearch/plugins/current/analysis-kuromoji.html
+		/// </summary>
+		public TokenizersDescriptor Kuromoji(string name, Func<KuromojiTokenizerDescriptor, IKuromojiTokenizer> selector) =>
+			Assign(name, selector?.Invoke(new KuromojiTokenizerDescriptor()));
 	}
 }
diff --git a/src/Nest/Nest.csproj b/src/Nest/Nest.csproj
index 406cbbff471..2b2113dba2b 100644
--- a/src/Nest/Nest.csproj
+++ b/src/Nest/Nest.csproj
@@ -191,6 +191,15 @@
     <Compile Include="Analysis\CharFilters\PatternReplaceCharFilter.cs" />
     <Compile Include="Analysis\Languages\Language.cs" />
     <Compile Include="Analysis\Languages\SnowballLanguage.cs" />
+    <Compile Include="Analysis\Plugins\Kuromoji\KuromojiPartOfSpeechTokenFilter.cs" />
+    <Compile Include="Analysis\Plugins\Kuromoji\KuromojiAnalyzer.cs" />
+    <Compile Include="Analysis\Plugins\Kuromoji\KuromojiReadingFormTokenFilter.cs" />
+    <Compile Include="Analysis\Plugins\Kuromoji\KuromojiStemmerTokenFilter.cs" />
+    <Compile Include="Analysis\Plugins\Kuromoji\KuromojiTokenizationMode.cs" />
+    <Compile Include="Analysis\Plugins\Kuromoji\KuromojiIterationMarkCharFilter.cs" />
+    <Compile Include="Analysis\Plugins\Kuromoji\KuromojiTokenizer.cs" />
+    <Compile Include="Analysis\Plugins\Phonetic\PhoneticEncoder.cs" />
+    <Compile Include="Analysis\Plugins\Phonetic\PhoneticTokenFilter.cs" />
     <Compile Include="Analysis\StopWords.cs" />
     <Compile Include="Analysis\TokenFilters\AsciiFoldingTokenFilter.cs" />
     <Compile Include="Analysis\TokenFilters\CommonGramsTokenFilter.cs" />
@@ -214,8 +223,6 @@
     <Compile Include="Analysis\TokenFilters\NgramTokenFilter.cs" />
     <Compile Include="Analysis\TokenFilters\PatternCaptureTokenFilter.cs" />
     <Compile Include="Analysis\TokenFilters\PatternReplaceTokenFilter.cs" />
-    <Compile Include="Analysis\TokenFilters\Phonetic\PhoneticEncoder.cs" />
-    <Compile Include="Analysis\TokenFilters\Phonetic\PhoneticTokenFilter.cs" />
     <Compile Include="Analysis\TokenFilters\PorterStemTokenFilter.cs" />
     <Compile Include="Analysis\TokenFilters\ReverseTokenFilter.cs" />
     <Compile Include="Analysis\TokenFilters\Shingle\ShingleTokenFilter.cs" />
diff --git a/src/Tests/Analysis/Analyzers/AnalyzerUsageTests.cs b/src/Tests/Analysis/Analyzers/AnalyzerUsageTests.cs
index 326e5d5d9e1..5c9be365a8b 100644
--- a/src/Tests/Analysis/Analyzers/AnalyzerUsageTests.cs
+++ b/src/Tests/Analysis/Analyzers/AnalyzerUsageTests.cs
@@ -23,8 +23,8 @@ public class AnalyzerUsageTests : PromiseUsageTestBase<IIndexSettings, IndexSett
 					{
 						type = "custom",
 						tokenizer = "ng",
-						filter = new[] { "myAscii", "kstem" },
-						char_filter = new[] { "stripMe", "patterned" }
+						filter = new[] {"myAscii", "kstem"},
+						char_filter = new[] {"stripMe", "patterned"}
 					},
 					myKeyword = new
 					{
@@ -39,7 +39,7 @@ public class AnalyzerUsageTests : PromiseUsageTestBase<IIndexSettings, IndexSett
 					{
 						type = "simple"
 					},
-					myLanguage = new { type = "dutch" },
+					myLanguage = new {type = "dutch"},
 					mySnow = new
 					{
 						type = "snowball",
@@ -69,7 +69,12 @@ public class AnalyzerUsageTests : PromiseUsageTestBase<IIndexSettings, IndexSett
 						preserve_original = true,
 						separator = ",",
 						max_output_size = 100,
-						stopwords = new[] { "a", "he", "the" }
+						stopwords = new[] {"a", "he", "the"}
+					},
+					kuro = new
+					{
+						type = "kuromoji",
+						mode = "search"
 					}
 				}
 			}
@@ -79,6 +84,7 @@ public class AnalyzerUsageTests : PromiseUsageTestBase<IIndexSettings, IndexSett
 		 *
 		 */
 		protected override Func<IndexSettingsDescriptor, IPromise<IIndexSettings>> Fluent => FluentExample;
+
 		public static Func<IndexSettingsDescriptor, IPromise<IndexSettings>> FluentExample => s => s
 			.Analysis(analysis => analysis
 				.Analyzers(analyzers => analyzers
@@ -103,12 +109,16 @@ public class AnalyzerUsageTests : PromiseUsageTestBase<IIndexSettings, IndexSett
 						.MaxOutputSize(100)
 						.StopWords("a", "he", "the")
 					)
+					.Kuromoji("kuro", a => a
+						.Mode(KuromojiTokenizationMode.Search)
+					)
 				)
 			);
 
 		/**
 		 */
 		protected override IndexSettings Initializer => InitializerExample;
+
 		public static IndexSettings InitializerExample =>
 			new IndexSettings
 			{
@@ -116,29 +126,37 @@ public class AnalyzerUsageTests : PromiseUsageTestBase<IIndexSettings, IndexSett
 				{
 					Analyzers = new Nest.Analyzers
 					{
-						{ "default", new KeywordAnalyzer() },
-						{ "myCustom", new CustomAnalyzer
+						{"default", new KeywordAnalyzer()},
 						{
-							CharFilter = new [] { "stripMe", "patterned"},
-							Filter = new [] { "myAscii", "kstem"},
-							Tokenizer = "ng"
-						} },
-						{ "myKeyword", new KeywordAnalyzer() },
-						{ "myPattern", new PatternAnalyzer { Pattern = @"\w" } },
-						{ "myLanguage", new LanguageAnalyzer { Language = Language.Dutch } },
-						{ "mySimple", new SimpleAnalyzer() },
-						{ "mySnow", new SnowballAnalyzer { Language = SnowballLanguage.Dutch } },
-						{ "myStandard", new StandardAnalyzer { MaxTokenLength = 2 } },
-						{ "myStop", new StopAnalyzer { StopwordsPath = "analysis/stopwords.txt" } },
-						{ "myWhiteSpace", new WhitespaceAnalyzer() },
-						{ "myWhiteSpace2", new WhitespaceAnalyzer() },
+							"myCustom", new CustomAnalyzer
+							{
+								CharFilter = new[] {"stripMe", "patterned"},
+								Filter = new[] {"myAscii", "kstem"},
+								Tokenizer = "ng"
+							}
+						},
+						{"myKeyword", new KeywordAnalyzer()},
+						{"myPattern", new PatternAnalyzer {Pattern = @"\w"}},
+						{"myLanguage", new LanguageAnalyzer {Language = Language.Dutch}},
+						{"mySimple", new SimpleAnalyzer()},
+						{"mySnow", new SnowballAnalyzer {Language = SnowballLanguage.Dutch}},
+						{"myStandard", new StandardAnalyzer {MaxTokenLength = 2}},
+						{"myStop", new StopAnalyzer {StopwordsPath = "analysis/stopwords.txt"}},
+						{"myWhiteSpace", new WhitespaceAnalyzer()},
+						{"myWhiteSpace2", new WhitespaceAnalyzer()},
 						{
 							"myFingerprint", new FingerprintAnalyzer
 							{
 								PreserveOriginal = true,
 								Separator = ",",
 								MaxOutputSize = 100,
-								StopWords = new[] { "a", "he", "the" }
+								StopWords = new[] {"a", "he", "the"}
+							}
+						},
+						{
+							"kuro", new KuromojiAnalyzer
+							{
+								Mode  = KuromojiTokenizationMode.Search
 							}
 						}
 					}
diff --git a/src/Tests/Analysis/CharFilters/CharFilterUsageTests.cs b/src/Tests/Analysis/CharFilters/CharFilterUsageTests.cs
index 6ce91ea73b8..16a668837b9 100644
--- a/src/Tests/Analysis/CharFilters/CharFilterUsageTests.cs
+++ b/src/Tests/Analysis/CharFilters/CharFilterUsageTests.cs
@@ -23,6 +23,12 @@ public class CharFilterUsageTests : PromiseUsageTestBase<IIndexSettings, IndexSe
 					{
 						mappings = new[] { "a=>b" },
 						type = "mapping"
+					},
+					kmark = new
+					{
+						normalize_kanji = true,
+						normalize_kana = true,
+						type = "kuromoji_iteration_mark"
 					}
 				}
 			}
@@ -30,7 +36,7 @@ public class CharFilterUsageTests : PromiseUsageTestBase<IIndexSettings, IndexSe
 
 
 		/**
-		 * 
+		 *
 		 */
 		protected override Func<IndexSettingsDescriptor, IPromise<IIndexSettings>> Fluent => FluentExample;
 		public static Func<IndexSettingsDescriptor, IPromise<IIndexSettings>> FluentExample => s => s
@@ -39,6 +45,7 @@ public class CharFilterUsageTests : PromiseUsageTestBase<IIndexSettings, IndexSe
 					.HtmlStrip("stripMe")
 					.PatternReplace("patterned", c => c.Pattern("x").Replacement("y"))
 					.Mapping("mapped", c => c.Mappings("a=>b"))
+					.KuromojiIterationMark("kmark", c => c.NormalizeKana().NormalizeKanji())
 				)
 			);
 
@@ -54,7 +61,12 @@ public class CharFilterUsageTests : PromiseUsageTestBase<IIndexSettings, IndexSe
 					{
 							{ "stripMe", new HtmlStripCharFilter { } },
 							{ "patterned", new PatternReplaceCharFilter { Pattern = "x", Replacement = "y" } },
-							{ "mapped", new MappingCharFilter { Mappings = new [] { "a=>b"} } }
+							{ "mapped", new MappingCharFilter { Mappings = new [] { "a=>b"} } },
+							{ "kmark", new KuromojiIterationMarkCharFilter()
+							{
+								NormalizeKana = true,
+								NormalizeKanji = true
+							} }
 					}
 				}
 			};
diff --git a/src/Tests/Analysis/TokenFilters/TokenFilterUsageTests.cs b/src/Tests/Analysis/TokenFilters/TokenFilterUsageTests.cs
index b44fc0e3704..9a72b85b83d 100644
--- a/src/Tests/Analysis/TokenFilters/TokenFilterUsageTests.cs
+++ b/src/Tests/Analysis/TokenFilters/TokenFilterUsageTests.cs
@@ -89,6 +89,22 @@ public class TokenFilterUsageTests : PromiseUsageTestBase<IIndexSettings, IndexS
 						keywords = new[] { "a", "b" },
 						ignore_case = true
 					},
+					kfr = new {
+						type = "kuromoji_readingform",
+						use_romaji = true
+					},
+					kpos = new {
+						stoptags = new [] {
+							"#  verb-main:",
+							"動詞-自立"
+						},
+						type = "kuromoji_part_of_speech"
+					},
+					ks = new {
+						minimum_length = 4,
+						type = "kuromoji_stemmer"
+					},
+
 					kstem = new
 					{
 						type = "kstem"
@@ -218,7 +234,7 @@ public class TokenFilterUsageTests : PromiseUsageTestBase<IIndexSettings, IndexS
 		};
 
 		/**
-		 * 
+		 *
 		 */
 		protected override Func<IndexSettingsDescriptor, IPromise<IIndexSettings>> Fluent => FluentExample;
 		public static Func<IndexSettingsDescriptor, IPromise<IIndexSettings>> FluentExample => s => s
@@ -339,6 +355,15 @@ public class TokenFilterUsageTests : PromiseUsageTestBase<IIndexSettings, IndexS
 						.SplitOnNumerics()
 						.StemEnglishPossessive()
 					)
+					.KuromojiPartOfSpeech("kpos", t => t
+						.StopTags("#  verb-main:", "動詞-自立")
+					)
+					.KuromojiReadingForm("kfr", t => t
+						.UseRomaji()
+					)
+					.KuromojiStemmer("ks", t => t
+						.MinimumLength(4)
+					)
 				)
 			);
 
@@ -433,7 +458,10 @@ public class TokenFilterUsageTests : PromiseUsageTestBase<IIndexSettings, IndexS
 								SplitOnCaseChange = true,
 								SplitOnNumerics = true,
 								StemEnglishPossessive = true
-							} }
+							} },
+							{ "kpos", new KuromojiPartOfSpeechTokenFilter { StopTags = new [] {"#  verb-main:", "動詞-自立"}}},
+							{ "kfr", new KuromojiReadingFormTokenFilter { UseRomaji = true }},
+							{ "ks", new KuromojiStemmerTokenFilter { MinimumLength = 4 }},
 					}
 				}
 			};
diff --git a/src/Tests/Analysis/Tokenizers/TokenizerUsageTests.cs b/src/Tests/Analysis/Tokenizers/TokenizerUsageTests.cs
index b674d3173e6..415412b6eba 100644
--- a/src/Tests/Analysis/Tokenizers/TokenizerUsageTests.cs
+++ b/src/Tests/Analysis/Tokenizers/TokenizerUsageTests.cs
@@ -19,14 +19,22 @@ public class TokenizerUsageTests : PromiseUsageTestBase<IIndexSettings, IndexSet
 					{
 						min_gram = 1,
 						max_gram = 2,
-						token_chars = new[] { "digit", "letter" },
+						token_chars = new[] {"digit", "letter"},
 						type = "edge_ngram"
 					},
+					kuromoji = new
+					{
+						discard_punctuation = true,
+						mode = "extended",
+						nbest_cost = 1000,
+						nbest_examples = "/箱根山-箱根/成田空港-成田/",
+						type = "kuromoji_tokenizer"
+					},
 					ng = new
 					{
 						min_gram = 1,
 						max_gram = 2,
-						token_chars = new[] { "digit", "letter" },
+						token_chars = new[] {"digit", "letter"},
 						type = "ngram"
 					},
 					path = new
@@ -63,9 +71,10 @@ public class TokenizerUsageTests : PromiseUsageTestBase<IIndexSettings, IndexSet
 		};
 
 		/**
-		 * 
+		 *
 		 */
 		protected override Func<IndexSettingsDescriptor, IPromise<IIndexSettings>> Fluent => FluentExample;
+
 		public static Func<IndexSettingsDescriptor, IPromise<IIndexSettings>> FluentExample => s => s
 			.Analysis(analysis => analysis
 				.Tokenizers(tokenizer => tokenizer
@@ -94,12 +103,19 @@ public class TokenizerUsageTests : PromiseUsageTestBase<IIndexSettings, IndexSet
 					.Standard("standard")
 					.UaxEmailUrl("uax", t => t.MaxTokenLength(12))
 					.Whitespace("whitespace")
+					.Kuromoji("kuromoji", t => t
+						.Mode(KuromojiTokenizationMode.Extended)
+						.DiscardPunctuation()
+						.NBestExamples("/箱根山-箱根/成田空港-成田/")
+						.NBestCost(1000)
+					)
 				)
 			);
 
 		/**
 		 */
 		protected override IndexSettings Initializer => InitializerExample;
+
 		public static IndexSettings InitializerExample =>
 			new IndexSettings
 			{
@@ -107,35 +123,52 @@ public class TokenizerUsageTests : PromiseUsageTestBase<IIndexSettings, IndexSet
 				{
 					Tokenizers = new Nest.Tokenizers
 					{
-							{ "endgen", new EdgeNGramTokenizer
+						{
+							"endgen", new EdgeNGramTokenizer
 							{
 								MaxGram = 2,
 								MinGram = 1,
-								TokenChars = new [] { TokenChar.Digit, TokenChar.Letter }
-							}},
-							{ "ng", new NGramTokenizer
+								TokenChars = new[] {TokenChar.Digit, TokenChar.Letter}
+							}
+						},
+						{
+							"ng", new NGramTokenizer
 							{
 								MaxGram = 2,
 								MinGram = 1,
-								TokenChars = new [] { TokenChar.Digit, TokenChar.Letter }
-							}},
-							{ "path", new PathHierarchyTokenizer
+								TokenChars = new[] {TokenChar.Digit, TokenChar.Letter}
+							}
+						},
+						{
+							"path", new PathHierarchyTokenizer
 							{
 								BufferSize = 2048,
 								Delimiter = '|',
 								Replacement = '-',
 								Reverse = true,
 								Skip = 1
-							} },
-							{ "pattern", new PatternTokenizer
+							}
+						},
+						{
+							"pattern", new PatternTokenizer
 							{
 								Flags = "CASE_INSENSITIVE",
 								Group = 1,
 								Pattern = @"\W+"
-							} },
-							{ "standard", new StandardTokenizer() },
-							{ "uax", new UaxEmailUrlTokenizer { MaxTokenLength = 12 } },
-							{ "whitespace", new WhitespaceTokenizer() },
+							}
+						},
+						{"standard", new StandardTokenizer()},
+						{"uax", new UaxEmailUrlTokenizer {MaxTokenLength = 12}},
+						{"whitespace", new WhitespaceTokenizer()},
+						{
+							"kuromoji", new KuromojiTokenizer
+							{
+								Mode = KuromojiTokenizationMode.Extended,
+								DiscardPunctuation = true,
+								NBestExamples = "/箱根山-箱根/成田空港-成田/",
+								NBestCost = 1000
+							}
+						},
 					}
 				}
 			};
diff --git a/src/Tests/CodeStandards/Descriptors.doc.cs b/src/Tests/CodeStandards/Descriptors.doc.cs
index b6edabcd845..ad96ebd8993 100644
--- a/src/Tests/CodeStandards/Descriptors.doc.cs
+++ b/src/Tests/CodeStandards/Descriptors.doc.cs
@@ -44,6 +44,7 @@ where t.IsClass() && typeof(IDescriptor).IsAssignableFrom(t)
 				{ typeof(ConditionDescriptor), typeof(ConditionContainer) },
 				{ typeof(TriggerDescriptor), typeof(TriggerContainer) },
 				{ typeof(TransformDescriptor), typeof(TransformContainer) },
+				{ typeof(SmoothingModelContainerDescriptor), typeof(SmoothingModelContainer) },
 				{ typeof(InputDescriptor), typeof(InputContainer) },
 				{ typeof(FluentDictionary<,>), typeof(FluentDictionary<,>) }
 			};
diff --git a/src/Tests/Framework/EndpointTests/Clusters/WritableCluster.cs b/src/Tests/Framework/EndpointTests/Clusters/WritableCluster.cs
index ad2ba60b651..a5f72614943 100644
--- a/src/Tests/Framework/EndpointTests/Clusters/WritableCluster.cs
+++ b/src/Tests/Framework/EndpointTests/Clusters/WritableCluster.cs
@@ -5,12 +5,16 @@ namespace Tests.Framework.Integration
 	/// <summary>
 	/// Use this cluster for api's that do writes. If they are however intrusive or long running consider IntrusiveOperationCluster instead.
 	/// </summary>
-	[RequiresPlugin(ElasticsearchPlugin.MapperAttachments, ElasticsearchPlugin.IngestGeoIp, ElasticsearchPlugin.IngestAttachment)]
+	[RequiresPlugin(
+		ElasticsearchPlugin.MapperAttachments,
+		ElasticsearchPlugin.IngestGeoIp,
+		ElasticsearchPlugin.AnalysisKuromoji,
+		ElasticsearchPlugin.IngestAttachment
+	)]
 	public class WritableCluster : ClusterBase
 	{
 		public override int MaxConcurrency => 4;
 
-
 		public override void Bootstrap()
 		{
 			var seeder = new Seeder(this.Node);
diff --git a/src/Tests/Framework/ManagedElasticsearch/ElasticsearchPlugin.cs b/src/Tests/Framework/ManagedElasticsearch/ElasticsearchPlugin.cs
index 182fe9429e5..c10ec7d7e7f 100644
--- a/src/Tests/Framework/ManagedElasticsearch/ElasticsearchPlugin.cs
+++ b/src/Tests/Framework/ManagedElasticsearch/ElasticsearchPlugin.cs
@@ -42,7 +42,10 @@ public enum ElasticsearchPlugin
 		IngestGeoIp,
 
 		[Moniker("ingest-attachment")]
-		IngestAttachment
+		IngestAttachment,
+
+		[Moniker("analysis-kuromoji")]
+		AnalysisKuromoji
 	}
 
 	public static class ElasticsearchPluginExtensions
@@ -71,6 +74,7 @@ public class ElasticsearchPluginCollection : KeyedCollection<ElasticsearchPlugin
 					version => version >= new ElasticsearchVersion("5.0.0-alpha3")),
 				new ElasticsearchPluginConfiguration(IngestAttachment,
 					version => version >= new ElasticsearchVersion("5.0.0-alpha3")),
+				new ElasticsearchPluginConfiguration(AnalysisKuromoji),
 			};
 
 		protected override ElasticsearchPlugin GetKeyForItem(ElasticsearchPluginConfiguration item)
diff --git a/src/Tests/Framework/ManagedElasticsearch/FileSystem/TestRunnerFileSystem.cs b/src/Tests/Framework/ManagedElasticsearch/FileSystem/TestRunnerFileSystem.cs
index 47863ca31bc..2330b66bae6 100644
--- a/src/Tests/Framework/ManagedElasticsearch/FileSystem/TestRunnerFileSystem.cs
+++ b/src/Tests/Framework/ManagedElasticsearch/FileSystem/TestRunnerFileSystem.cs
@@ -141,11 +141,11 @@ private void InstallPlugins()
 				if (Directory.Exists(pluginFolder)) continue;
 
 				Console.WriteLine($"Installing elasticsearch plugin: {plugin.Moniker} ...");
-				var timeout = TimeSpan.FromSeconds(120);
+				var timeout = TimeSpan.FromSeconds(420);
 				var handle = new ManualResetEvent(false);
 				Task.Run(() =>
 				{
-					using (var p = new ObservableProcess(this.PluginBinary, "install", installParameter))
+					using (var p = new ObservableProcess(this.PluginBinary, "install --batch", installParameter))
 					{
 						var o = p.Start();
 						Console.WriteLine($"Calling: {this.PluginBinary} install {installParameter}");