All Classes

All Classes Interface Summary Class Summary Enum Summary Exception Summary Error Summary Annotation Types Summary
Class	Description
AbstractAnalysisFactory	Abstract parent class for analysis factories `TokenizerFactory`, `TokenFilterFactory` and `CharFilterFactory`.
AbstractBlockPackedWriter
AbstractDictionary	SmartChineseAnalyzer abstract dictionary implementation.
AbstractEncoder	Base class for payload encoders.
AbstractIterator<E>	Simplifies the implementation of iterators a bit.
AbstractKnnCollector	AbstractKnnCollector is the default implementation for a knn collector used for gathering kNN results and providing topDocs from the gathered neighbors
AbstractKnnVectorQuery	Uses `KnnVectorsReader.search(java.lang.String, float[], org.apache.lucene.search.KnnCollector, org.apache.lucene.util.Bits)` to perform nearest neighbour search.
AbstractKnnVectorQuery.DocAndScoreQuery	Caches the results of a KnnVector search: a list of docs and their scores
AbstractMultiTermQueryConstantScoreWrapper<Q extends MultiTermQuery>	Contains functionality common to both `MultiTermQueryConstantScoreBlendedWrapper` and `MultiTermQueryConstantScoreWrapper`.
AbstractMultiTermQueryConstantScoreWrapper.RewritingWeight
AbstractMultiTermQueryConstantScoreWrapper.TermAndState
AbstractMultiTermQueryConstantScoreWrapper.WeightOrDocIdSetIterator
AbstractPagedMutable<T extends AbstractPagedMutable<T>>	Base implementation for `PagedMutable` and `PagedGrowableWriter`.
AbstractQueryConfig	This class is the base of `QueryConfigHandler` and `FieldConfig`.
AbstractRangeQueryNode<T extends FieldValuePairQueryNode<?>>	This class should be extended by nodes intending to represent range queries.
AbstractVectorSimilarityQuery	Search for all (approximate) vectors above a similarity threshold.
AbstractVectorSimilarityQuery.VectorSimilarityScorer
AbstractWordsFileFilterFactory	Abstract parent class for analysis factories that accept a stopwords file as input.
Accountable	An object whose RAM usage can be computed.
Accountables	Helper methods for constructing nested resource descriptions and debugging RAM usage.
AffixCondition	Checks the "condition" part of affix definition, as in
AffixedWord	An object representing the analysis result of a simple (non-compound) word
AffixedWord.Affix	An object representing a prefix or a suffix applied to a word stem
AffixKind
After	Node that represents `Intervals.after(IntervalsSource, IntervalsSource)`.
AfterEffect	This class acts as the base class for the implementations of the first normalization of the informative content in the DFR framework.
AfterEffectB	Model of the information gain based on the ratio of two Bernoulli processes.
AfterEffectL	Model of the information gain based on Laplace's law of succession.
AllGroupHeadsCollector<T>	This collector specializes in collecting the most relevant document (group head) for each group that matches the query.
AllGroupHeadsCollector.GroupHead<T>	Represents a group head.
AllGroupHeadsCollector.ScoringGroupHead<T>
AllGroupHeadsCollector.ScoringGroupHeadsCollector<T>	Specialized implementation for sorting by score
AllGroupHeadsCollector.SortingGroupHead<T>
AllGroupHeadsCollector.SortingGroupHeadsCollector<T>	General implementation using a `FieldComparator` to select the group head
AllGroupsCollector<T>	A collector that collects all groups that match the query.
AllowLeadingWildcardProcessor	This processor verifies if `StandardQueryConfigHandler.ConfigurationKeys.ALLOW_LEADING_WILDCARD` is defined in the `QueryConfigHandler`.
AlreadyClosedException	This exception is thrown when there is an attempt to access something that has already been closed.
Among	Internal class used by Snowball stemmers
AnalysisOffsetStrategy	Provides a base class for analysis based offset strategies to extend from.
AnalysisOffsetStrategy.MultiValueTokenStream	Wraps an `Analyzer` and string text that represents multiple values delimited by a specified character.
AnalysisSPILoader<S extends AbstractAnalysisFactory>	Helper class for loading named SPIs from classpath (e.g.
AnalyzedText	Node that represents `Intervals.analyzedText(String, Analyzer, String, int, boolean)`.
Analyzer	An Analyzer builds TokenStreams, which analyze text.
Analyzer.ReuseStrategy	Strategy defining how TokenStreamComponents are reused per call to `Analyzer.tokenStream(String, java.io.Reader)`.
Analyzer.StringTokenStream
Analyzer.TokenStreamComponents	This class encapsulates the outer components of a token stream.
AnalyzerProfile	Manages analysis data configuration for SmartChineseAnalyzer
AnalyzerQueryNodeProcessor	This processor verifies if `StandardQueryConfigHandler.ConfigurationKeys.ANALYZER` is defined in the `QueryConfigHandler`.
AnalyzerWrapper	Extension to `Analyzer` suitable for Analyzers which wrap other Analyzers.
AnalyzingInfixSuggester	Analyzes the input text and then suggests matches based on prefix matches to any tokens in the indexed text.
AnalyzingSuggester	Suggester that first analyzes the surface form, adds the analyzed form to a weighted FST, and then does the same thing at lookup time.
AnalyzingSuggester.AnalyzingComparator
AndQuery	Factory for conjunctions
AndQueryNode	A `AndQueryNode` represents an AND boolean operation performed on a list of nodes.
AnyQueryNode	A `AnyQueryNode` represents an ANY operator performed on a list of nodes.
AnyQueryNodeBuilder	Builds a BooleanQuery of SHOULD clauses, possibly with some minimum number to match.
ApostropheFilter	Strips all characters after an apostrophe (including the apostrophe itself).
ApostropheFilterFactory	Factory for `ApostropheFilter`.
ApproximatePriorityQueue<T>	An approximate priority queue, which attempts to poll items by decreasing log of the weight, though exact ordering is not guaranteed.
ArabicAnalyzer	`Analyzer` for Arabic.
ArabicAnalyzer.DefaultSetHolder	Atomically loads the DEFAULT_STOP_SET in a lazy fashion once the outer class accesses the static final set the first time.;
ArabicNormalizationFilter	A `TokenFilter` that applies `ArabicNormalizer` to normalize the orthography.
ArabicNormalizationFilterFactory	Factory for `ArabicNormalizationFilter`.
ArabicNormalizer	Normalizer for Arabic.
ArabicStemFilter	A `TokenFilter` that applies `ArabicStemmer` to stem Arabic words..
ArabicStemFilterFactory	Factory for `ArabicStemFilter`.
ArabicStemmer	Stemmer for Arabic.
ArabicStemmer	This class implements the stemming algorithm defined by a snowball script.
ArcDistance	Arc distance computation style.
ArmenianAnalyzer	`Analyzer` for Armenian.
ArmenianAnalyzer.DefaultSetHolder	Atomically loads the DEFAULT_STOP_SET in a lazy fashion once the outer class accesses the static final set the first time.;
ArmenianStemmer	This class implements the stemming algorithm defined by a snowball script.
ArrayInPlaceMergeSorter<T>	An `InPlaceMergeSorter` for object arrays.
ArrayIntroSorter<T>	An `IntroSorter` for object arrays.
ArrayTimSorter<T>	A `TimSorter` for object arrays.
ArrayUtil	Methods for manipulating arrays.
ArrayUtil.ByteArrayComparator	Comparator for a fixed number of bytes.
ASCIIFoldingFilter	This class converts alphabetic, numeric, and symbolic Unicode characters which are not in the first 127 ASCII characters (the "Basic Latin" Unicode block) into their ASCII equivalents, if one exists.
ASCIIFoldingFilterFactory	Factory for `ASCIIFoldingFilter`.
AtLeast	Node that represents `Intervals.atLeast(int, IntervalsSource...)`.
Attribute	Base interface for attributes.
AttributeFactory	An AttributeFactory creates instances of `AttributeImpl`s.
AttributeFactory.DefaultAttributeFactory
AttributeFactory.StaticImplementationAttributeFactory<A extends AttributeImpl>	Expert: AttributeFactory returning an instance of the given `clazz` for the attributes it implements.
AttributeImpl	Base class for Attributes that can be added to a `AttributeSource`.
AttributeReflector	This interface is used to reflect contents of `AttributeSource` or `AttributeImpl`.
AttributeSource	An AttributeSource contains a list of different `AttributeImpl`s, and methods to add and get them.
AttributeSource.State	This class holds the state of an AttributeSource.
Automata	Construction of basic automata.
Automaton	Represents an automaton and all its states and transitions.
Automaton.Builder	Records new states and transitions and then `Automaton.Builder.finish()` creates the `Automaton`.
AutomatonProvider	Automaton provider for `RegExp.` `RegExp.toAutomaton(AutomatonProvider,int)`
AutomatonQuery	A `Query` that will match terms against a finite-state machine.
AutomatonTermsEnum	A FilteredTermsEnum that enumerates terms based upon what is accepted by a DFA.
AutomatonToTokenStream	Converts an Automaton into a TokenStream.
AutomatonToTokenStream.EdgeToken	Edge between position nodes.
AutomatonToTokenStream.RemapNode	Node that contains original node id and position in TokenStream
AutomatonToTokenStream.TopoTokenStream	Token Stream that outputs tokens from a topo sorted graph.
AveragePayloadFunction	Calculate the final score as the average score of all payloads seen.
Axiomatic	Axiomatic approaches for IR.
AxiomaticF1EXP	F1EXP is defined as Sum(tf(term_doc_freq)ln(docLen)IDF(term)) where IDF(t) = pow((N+1)/df(t), k) N=total num of docs, df=doc freq
AxiomaticF1LOG	F1LOG is defined as Sum(tf(term_doc_freq)ln(docLen)IDF(term)) where IDF(t) = ln((N+1)/df(t)) N=total num of docs, df=doc freq
AxiomaticF2EXP	F2EXP is defined as Sum(tfln(term_doc_freq, docLen)*IDF(term)) where IDF(t) = pow((N+1)/df(t), k) N=total num of docs, df=doc freq
AxiomaticF2LOG	F2EXP is defined as Sum(tfln(term_doc_freq, docLen)*IDF(term)) where IDF(t) = ln((N+1)/df(t)) N=total num of docs, df=doc freq
AxiomaticF3EXP	F3EXP is defined as Sum(tf(term_doc_freq)IDF(term)-gamma(docLen, queryLen)) where IDF(t) = pow((N+1)/df(t), k) N=total num of docs, df=doc freq gamma(docLen, queryLen) = (docLen-queryLen)queryLen*s/avdl NOTE: the gamma function of this similarity creates negative scores
AxiomaticF3LOG	F3EXP is defined as Sum(tf(term_doc_freq)IDF(term)-gamma(docLen, queryLen)) where IDF(t) = ln((N+1)/df(t)) N=total num of docs, df=doc freq gamma(docLen, queryLen) = (docLen-queryLen)queryLen*s/avdl NOTE: the gamma function of this similarity creates negative scores
BaseCharFilter	Base utility class for implementing a `CharFilter`.
BaseCompositeReader<R extends IndexReader>	Base class for implementing `CompositeReader`s based on an array of sub-readers.
BaseDirectory	Base implementation for a concrete `Directory` that uses a `LockFactory` for locking.
BaseFormAttribute	Attribute for `Token.getBaseForm()`.
BaseFormAttributeImpl	Attribute for `Token.getBaseForm()`.
BaseFragListBuilder	A abstract implementation of `FragListBuilder`.
BaseFragListBuilder.IteratorQueue<T>
BaseFragmentsBuilder	Base FragmentsBuilder implementation that supports colored pre/post tags and multivalued fields.
BaseGlobalOrdinalScorer
BasePlanetObject	All Geo3D shapes can derive from this base class, which furnishes some common code
BaseShapeDocValuesQuery	Base query class for ShapeDocValues queries.
BaseTermsEnum	A base TermsEnum that adds default implementations for `BaseTermsEnum.attributes()` `BaseTermsEnum.termState()` `BaseTermsEnum.seekExact(BytesRef)` `BaseTermsEnum.seekExact(BytesRef, TermState)` In some cases, the default implementation may be slow and consume huge memory, so subclass SHOULD have its own implementation if possible.
BaseXYZSolid	Base class of a family of 3D rectangles, bounded on six sides by X,Y,Z limits
BasicModel	This class acts as the base class for the specific basic model implementations in the DFR framework.
BasicModelG	Geometric as limiting form of the Bose-Einstein model.
BasicModelIF	An approximation of the I(n_e) model.
BasicModelIn	The basic tf-idf model of randomness.
BasicModelIne	Tf-idf model of randomness, based on a mixture of Poisson and inverse document frequency.
BasicQueryFactory	Factory for creating basic term queries
BasicStats	Stores all statistics commonly used ranking methods.
BasqueAnalyzer	`Analyzer` for Basque.
BasqueAnalyzer.DefaultSetHolder	Atomically loads the DEFAULT_STOP_SET in a lazy fashion once the outer class accesses the static final set the first time.;
BasqueStemmer	This class implements the stemming algorithm defined by a snowball script.
Before	Node that represents `Intervals.before(IntervalsSource, IntervalsSource)`.
BeiderMorseFilter	TokenFilter for Beider-Morse phonetic encoding.
BeiderMorseFilterFactory	Factory for `BeiderMorseFilter`.
BengaliAnalyzer	Analyzer for Bengali.
BengaliAnalyzer.DefaultSetHolder	Atomically loads the DEFAULT_STOP_SET in a lazy fashion once the outer class accesses the static final set the first time.;
BengaliNormalizationFilter	A `TokenFilter` that applies `BengaliNormalizer` to normalize the orthography.
BengaliNormalizationFilterFactory	Factory for `BengaliNormalizationFilter`.
BengaliNormalizer	Normalizer for Bengali.
BengaliStemFilter	A `TokenFilter` that applies `BengaliStemmer` to stem Bengali words.
BengaliStemFilterFactory	Factory for `BengaliStemFilter`.
BengaliStemmer	Stemmer for Bengali.
BigIntegerPoint	An indexed 128-bit `BigInteger` field.
BigramDictionary	SmartChineseAnalyzer Bigram dictionary.
BinaryDictionary	Base class for a binary-encoded in-memory dictionary.
BinaryDictionary	Base class for a binary-encoded in-memory dictionary.
BinaryDictionary.ResourceScheme	Deprecated, for removal: This API element is subject to removal in a future version.
BinaryDictionary.ResourceScheme	Deprecated, for removal: This API element is subject to removal in a future version.
BinaryDictionaryWriter
BinaryDictionaryWriter
BinaryDocValues	A per-document numeric value.
BinaryDocValueSelector	Select documents using binary doc values
BinaryDocValuesField	Field that stores a per-document `BytesRef` value.
BinaryDocValuesFieldUpdates	A `DocValuesFieldUpdates` which holds updates of documents, of a single `BinaryDocValuesField`.
BinaryDocValuesFieldUpdates.Iterator
BinaryDocValuesWriter	Buffers up pending byte[] per doc, then flushes when segment flushes.
BinaryDocValuesWriter.BinaryDVs
BinaryDocValuesWriter.BufferedBinaryDocValues
BinaryDocValuesWriter.SortingBinaryDocValues
BinaryPoint	An indexed binary field for fast range filters.
BinaryRangeDocValues	A binary representation of a range that wraps a BinaryDocValues field
BinaryRangeDocValuesField
BinaryRangeFieldRangeQuery
Bindings	Binds variable names in expressions to actual data.
BiSegGraph	Graph representing possible token pairs (bigrams) at each start offset in the sentence.
BitDocIdSet	Implementation of the `DocIdSet` interface on top of a `BitSet`.
BitMixer	Bit mixing utilities.
Bits	Interface for Bitset-like structures.
Bits.MatchAllBits	Bits impl of the specified length with all bits set.
Bits.MatchNoBits	Bits impl of the specified length with no bits set.
BitSet	Base implementation for a bit set.
BitSetIterator	A `DocIdSetIterator` which iterates over set bits in a bit set.
BitSetProducer	A producer of `BitSet`s per segment.
BitsProducer	A producer of `Bits` per segment.
BitsSlice	Exposes a slice of an existing Bits as a new Bits.
BitTableUtil	Static helper methods for `FST.Arc.BitTable`.
BitUtil	A variety of high efficiency bit twiddling routines and encoders for primitives.
BKDConfig	Basic parameters for indexing points on the BKD tree.
BKDRadixSelector	Offline Radix selector for BKD tree.
BKDRadixSelector.PathSlice	Sliced reference to points in an PointWriter.
BKDReader	Handles reading a block KD-tree in byte[] space previously written with `BKDWriter`.
BKDReader.BKDPointTree
BKDReader.BKDReaderDocIDSetIterator	Reusable `DocIdSetIterator` to handle low cardinality leaves.
BKDUtil	Utility functions to build BKD trees.
BKDUtil.ByteArrayPredicate	Predicate for a fixed number of bytes.
BKDWriter	Recursively builds a block KD-tree to assign all incoming points in N-dim space to smaller and smaller N-dim rectangles (cells) until the number of points in a given rectangle is <= `config.maxPointsInLeafNode`.
BKDWriter.BKDMergeQueue
BKDWriter.BKDTreeLeafNodes	flat representation of a kd-tree
BKDWriter.MergeIntersectsVisitor
BKDWriter.MergeReader
BlendedInfixSuggester	Extension of the AnalyzingInfixSuggester which transforms the weight after search to take into account the position of the searched term into the indexed text.
BlendedInfixSuggester.BlenderType	The different types of blender.
BlendedInfixSuggester.LookUpComparator
BlendedTermQuery	A `Query` that blends index statistics across multiple terms.
BlendedTermQuery.Builder	A Builder for `BlendedTermQuery`.
BlendedTermQuery.DisjunctionMaxRewrite	A `BlendedTermQuery.RewriteMethod` that creates a `DisjunctionMaxQuery` out of the sub queries.
BlendedTermQuery.RewriteMethod	A `BlendedTermQuery.RewriteMethod` defines how queries for individual terms should be merged.
BlockDecoder	Decodes the raw bytes of a block when the index is read, according to the `BlockEncoder` used during the writing of the index.
BlockEncoder	Encodes the raw bytes of a block when the index is written.
BlockEncoder.WritableBytes	Writable byte buffer.
BlockGroupingCollector	BlockGroupingCollector performs grouping with a single pass collector, as long as you are grouping by a doc block field, ie all documents sharing a given group value were indexed as a doc block using the atomic `IndexWriter.addDocuments()` or `IndexWriter.updateDocuments()` API.
BlockGroupingCollector.OneGroup
BlockGroupingCollector.ScoreAndDoc
BlockHeader	Block header containing block metadata.
BlockHeader.Serializer	Reads/writes block header.
BlockingFloatHeap	A blocking bounded min heap that stores floats.
BlockIntervalsSource
BlockIntervalsSource.BlockIntervalIterator
BlockJoinSelector	Select a value from a block of documents.
BlockJoinSelector.Type	Type of selection to perform.
BlockLine	One term block line.
BlockLine.Serializer	Reads/writes block lines with terms encoded incrementally inside a block.
BlockMaxConjunctionBulkScorer	BulkScorer implementation of `BlockMaxConjunctionScorer` that focuses on top-level conjunctions over clauses that do not have two-phase iterators.
BlockMaxConjunctionBulkScorer.DocAndScore
BlockMaxConjunctionScorer	Scorer for conjunctions that checks the maximum scores of each clause in order to potentially skip over blocks that can't have competitive matches.
BlockPackedReaderIterator	Reader for sequences of longs written with `BlockPackedWriter`.
BlockPackedWriter	A writer for large sequences of longs.
BlockReader	Seeks the block corresponding to a given term, read the block bytes, and scans the block terms.
BlockTermsReader	Handles a terms dict, but decouples all details of doc/freqs/positions reading to an instance of `PostingsReaderBase`.
BlockTermsReader.FieldAndTerm
BlockTermState	Holds all state required for `PostingsReaderBase` to produce a `PostingsEnum` without re-seeking the terms dict.
BlockTermsWriter	Writes terms dict, block-encoding (column stride) each term's metadata for each set of terms between two index terms.
BlockTermsWriter.FieldMetaData
BlockTermsWriter.TermEntry
BlockTreeOrdsPostingsFormat	Uses `OrdsBlockTreeTermsWriter` with `Lucene99PostingsWriter`.
BlockWriter	Writes blocks in the block file.
BloomFilterFactory	Class used to create index-time `FuzzySet` appropriately configured for each field.
BloomFilteringPostingsFormat	A `PostingsFormat` useful for low doc-frequency fields such as primary keys.
BloomFilteringPostingsFormat.BloomFilteredFieldsProducer
BloomFilteringPostingsFormat.BloomFilteredFieldsProducer.BloomFilteredTerms
BloomFilteringPostingsFormat.BloomFilteredFieldsProducer.BloomFilteredTermsEnum
BM25NBClassifier	A classifier approximating naive bayes classifier by using pure queries on BM25.
BM25Similarity	BM25 Similarity.
BM25Similarity.BM25Scorer	Collection statistics for the BM25 model.
BoolDocValues	Abstract `FunctionValues` implementation which supports retrieving boolean values.
Boolean2ScorerSupplier
BooleanClause	A clause in a BooleanQuery.
BooleanClause.Occur	Specifies how clauses are to occur in matching documents.
BooleanModifierNode	A `BooleanModifierNode` has the same behaviour as `ModifierQueryNode`, it only indicates that this modifier was added by `BooleanQuery2ModifierNodeProcessor` and not by the user.
BooleanModifiersQueryNodeProcessor	This processor is used to apply the correct `ModifierQueryNode` to `BooleanQueryNode`s children.
BooleanPerceptronClassifier	A perceptron (see `http://en.wikipedia.org/wiki/Perceptron`) based `Boolean` `Classifier`.
BooleanQuery	A Query that matches documents matching boolean combinations of other queries, e.g.
BooleanQuery.Builder	A builder for boolean queries.
BooleanQuery.TooManyClauses	Deprecated. use `IndexSearcher.TooManyClauses`
BooleanQuery2ModifierNodeProcessor	This processor is used to apply the correct `ModifierQueryNode` to `BooleanQueryNode`s children.
BooleanQueryBuilder	Builder for `BooleanQuery`
BooleanQueryNode	A `BooleanQueryNode` represents a list of elements which do not have an explicit boolean operator defined between them.
BooleanQueryNodeBuilder	Builds a `BooleanQuery` object from a `BooleanQueryNode` object.
BooleanScorer	`BulkScorer` that is used for pure disjunctions and disjunctions that have low values of `BooleanQuery.Builder.setMinimumNumberShouldMatch(int)` and dense clauses.
BooleanScorer.Bucket
BooleanScorer.HeadPriorityQueue
BooleanScorer.TailPriorityQueue
BooleanSimilarity	Simple similarity that gives terms a score that is equal to their query boost.
BooleanSimilarity.BooleanWeight
BooleanSingleChildOptimizationQueryNodeProcessor	This processor removes every `BooleanQueryNode` that contains only one child and returns this child.
BooleanWeight	Expert: the Weight for BooleanQuery, used to normalize, score and explain these queries.
BooleanWeight.WeightedBooleanClause
BoolFunction	Abstract parent class for those `ValueSource` implementations which apply boolean logic to their values
BoostAttribute	Add this `Attribute` to a `TermsEnum` returned by `MultiTermQuery.getTermsEnum(Terms,AttributeSource)` and update the boost on each returned term.
BoostAttributeImpl	Implementation class for `BoostAttribute`.
BoostingTermBuilder	Builder for `PayloadScoreQuery`
BoostQuery	A `Query` wrapper that allows to give a boost to the wrapped query.
BoostQueryNode	A `BoostQueryNode` boosts the QueryNode tree which is under this node.
BoostQueryNodeBuilder	This builder basically reads the `Query` object set on the `BoostQueryNode` child using `QueryTreeBuilder.QUERY_TREE_BUILDER_TAGID` and applies the boost value defined in the `BoostQueryNode`.
BoostQueryNodeProcessor	This processor iterates the query node tree looking for every `FieldableNode` that has `StandardQueryConfigHandler.ConfigurationKeys.BOOST` in its config.
BoundaryScanner	Finds fragment boundaries: pluggable into `BaseFragmentsBuilder`
Bounded	This interface describes methods that determine what the bounds are for a shape.
Bounds	An interface for accumulating bounds information.
BPIndexReorderer	Implementation of "recursive graph bisection", also called "bipartite graph partitioning" and often abbreviated BP, an approach to doc ID assignment that aims at reducing the sum of the log gap between consecutive postings.
BPIndexReorderer.ForwardIndex	A forward index.
BPIndexReorderer.ForwardIndexSorter	Use a LSB Radix Sorter to sort the (docID, termID) entries.
BPIndexReorderer.ForwardIndexSorter.Bucket
BPIndexReorderer.LongConsumer
BPIndexReorderer.NotEnoughRAMException	Exception that is thrown when not enough RAM is available.
BPIndexReorderer.PerThreadState
BPReorderingMergePolicy	A merge policy that reorders merged segments according to a `BPIndexReorderer`.
BrazilianAnalyzer	`Analyzer` for Brazilian Portuguese language.
BrazilianAnalyzer.DefaultSetHolder
BrazilianStemFilter	A `TokenFilter` that applies `BrazilianStemmer`.
BrazilianStemFilterFactory	Factory for `BrazilianStemFilter`.
BrazilianStemmer	A stemmer for Brazilian Portuguese words.
BreakIteratorBoundaryScanner	A `BoundaryScanner` implementation that uses `BreakIterator` to find boundaries in the text.
BreakIteratorShrinkingAdjuster	A `PassageAdjuster` that adjusts the `Passage` range to word boundaries hinted by the given `BreakIterator`.
BreakIteratorWrapper	Wraps RuleBasedBreakIterator, making object reuse convenient and emitting a rule status for emoji sequences.
BufferAllocationException	BufferAllocationException forked from HPPC.
BufferedChecksum	Wraps another `Checksum` with an internal buffer to speed up checksum calculations.
BufferedChecksumIndexInput	Simple implementation of `ChecksumIndexInput` that wraps another input and delegates calls.
BufferedIndexInput	Base implementation class for buffered `IndexInput`.
BufferedIndexInput.SlicedIndexInput	Implementation of an IndexInput that reads from a portion of a file.
BufferedInputIterator	This wrapper buffers incoming elements.
BufferedUpdates	Holds buffered deletes and updates, by docID, term or query for a single segment.
BufferedUpdates.BytesRefIntMap
BufferedUpdates.DeletedTerms
BufferedUpdates.DeletedTerms.DeletedTermConsumer<E extends java.lang.Exception>
BufferedUpdatesStream	Tracks the stream of `FrozenBufferedUpdates`.
BufferedUpdatesStream.ApplyDeletesResult
BufferedUpdatesStream.FinishedSegments	Tracks the contiguous range of packets that have finished resolving.
BufferedUpdatesStream.SegmentState	Holds all per-segment internal state used while resolving deletions.
BufferingKnnVectorsWriter	Buffers up pending vector value(s) per doc, then flushes when segment flushes.
BufferingKnnVectorsWriter.BufferedByteVectorValues
BufferingKnnVectorsWriter.BufferedFloatVectorValues
BufferingKnnVectorsWriter.FieldWriter<T>
BufferingKnnVectorsWriter.SortingByteVectorValues	Sorting FloatVectorValues that iterate over documents in the order of the provided sortMap
BufferingKnnVectorsWriter.SortingFloatVectorValues	Sorting FloatVectorValues that iterate over documents in the order of the provided sortMap
BugfixDeflater_JDK8252739	This class is a workaround for JDK bug JDK-8252739.
BugfixDeflater_JDK8252739	This class is a workaround for JDK bug JDK-8252739.
BulgarianAnalyzer	`Analyzer` for Bulgarian.
BulgarianAnalyzer.DefaultSetHolder	Atomically loads the DEFAULT_STOP_SET in a lazy fashion once the outer class accesses the static final set the first time.;
BulgarianStemFilter	A `TokenFilter` that applies `BulgarianStemmer` to stem Bulgarian words.
BulgarianStemFilterFactory	Factory for `BulgarianStemFilter`.
BulgarianStemmer	Light Stemmer for Bulgarian.
BulkOperation	Efficient sequential read/write of packed integers.
BulkOperationPacked	Non-specialized `BulkOperation` for `PackedInts.Format.PACKED`.
BulkOperationPacked1	Efficient sequential read/write of packed integers.
BulkOperationPacked10	Efficient sequential read/write of packed integers.
BulkOperationPacked11	Efficient sequential read/write of packed integers.
BulkOperationPacked12	Efficient sequential read/write of packed integers.
BulkOperationPacked13	Efficient sequential read/write of packed integers.
BulkOperationPacked14	Efficient sequential read/write of packed integers.
BulkOperationPacked15	Efficient sequential read/write of packed integers.
BulkOperationPacked16	Efficient sequential read/write of packed integers.
BulkOperationPacked17	Efficient sequential read/write of packed integers.
BulkOperationPacked18	Efficient sequential read/write of packed integers.
BulkOperationPacked19	Efficient sequential read/write of packed integers.
BulkOperationPacked2	Efficient sequential read/write of packed integers.
BulkOperationPacked20	Efficient sequential read/write of packed integers.
BulkOperationPacked21	Efficient sequential read/write of packed integers.
BulkOperationPacked22	Efficient sequential read/write of packed integers.
BulkOperationPacked23	Efficient sequential read/write of packed integers.
BulkOperationPacked24	Efficient sequential read/write of packed integers.
BulkOperationPacked3	Efficient sequential read/write of packed integers.
BulkOperationPacked4	Efficient sequential read/write of packed integers.
BulkOperationPacked5	Efficient sequential read/write of packed integers.
BulkOperationPacked6	Efficient sequential read/write of packed integers.
BulkOperationPacked7	Efficient sequential read/write of packed integers.
BulkOperationPacked8	Efficient sequential read/write of packed integers.
BulkOperationPacked9	Efficient sequential read/write of packed integers.
BulkOperationPackedSingleBlock	Non-specialized `BulkOperation` for `PackedInts.Format.PACKED_SINGLE_BLOCK`.
BulkScorer	This class is used to score a range of documents at once, and is returned by `Weight.bulkScorer(org.apache.lucene.index.LeafReaderContext)`.
ByteArrayDataInput	DataInput backed by a byte array.
ByteArrayDataOutput	DataOutput backed by a byte array.
ByteBlockPool	This class enables the allocation of fixed-size buffers and their management as part of a buffer array.
ByteBlockPool.Allocator	Abstract class for allocating and freeing byte blocks.
ByteBlockPool.DirectAllocator	A simple `ByteBlockPool.Allocator` that never recycles.
ByteBlockPool.DirectTrackingAllocator	A simple `ByteBlockPool.Allocator` that never recycles, but tracks how much total RAM is in use.
ByteBlockPoolReverseBytesReader	Reads in reverse from a ByteBlockPool.
ByteBufferGuard	A guard that is created for every `ByteBufferIndexInput` that tries on best effort to reject any access to the `ByteBuffer` behind, once it is unmapped.
ByteBufferGuard.BufferCleaner	Pass in an implementation of this interface to cleanup ByteBuffers.
ByteBufferIndexInput	Deprecated. This class was made public for internal reasons (`instanceof` checks).
ByteBufferIndexInput.MultiBufferImpl	This class adds offset support to ByteBufferIndexInput, which is needed for slices.
ByteBufferIndexInput.SingleBufferImpl	Optimization of ByteBufferIndexInput for when there is only one buffer
ByteBuffersDataInput	A `DataInput` implementing `RandomAccessInput` and reading data from a list of `ByteBuffer`s.
ByteBuffersDataOutput	A `DataOutput` storing data in a list of `ByteBuffer`s.
ByteBuffersDataOutput.ByteBufferRecycler	An implementation of a `ByteBuffer` allocation and recycling policy.
ByteBuffersDirectory	A `ByteBuffer`-based `Directory` implementation that can be used to store index files on the heap.
ByteBuffersIndexInput	An `IndexInput` implementing `RandomAccessInput` and backed by a `ByteBuffersDataInput`.
ByteBuffersIndexOutput	An `IndexOutput` writing to a `ByteBuffersDataOutput`.
ByteKnnVectorFieldSource	An implementation for retrieving `FunctionValues` instances for byte knn vectors fields.
ByteRunAutomaton	Automaton representation for matching UTF-8 byte[].
ByteSequenceOutputs	An FST `Outputs` implementation where each output is a sequence of bytes.
ByteSlicePool	Class that Posting and PostingVector use to write interleaved byte streams into shared fixed-size byte[] arrays.
ByteSliceReader	IndexInput that knows how to read the byte slices written by Posting and PostingVector.
BytesRef	Represents byte[], as a slice (offset + length) into an existing byte[].
BytesRefArray	A simple append only random-access `BytesRef` array that stores full copies of the appended bytes in a `ByteBlockPool`.
BytesRefArray.IndexedBytesRefIterator	An extension of `BytesRefIterator` that allows retrieving the index of the current element
BytesRefArray.SortState	Used to iterate the elements of an array in a given order.
BytesRefBlockPool	Represents a logical list of ByteRef backed by a `ByteBlockPool`.
BytesRefBuilder	A builder for `BytesRef` instances.
BytesRefComparator	Specialized `BytesRef` comparator that `StringSorter` has optimizations for.
BytesRefFieldSource	An implementation for retrieving `FunctionValues` instances for string based fields.
BytesRefFSTEnum<T>	Enumerates all input (BytesRef) + output pairs in an FST.
BytesRefFSTEnum.InputOutput<T>	Holds a single input (BytesRef) + output pair.
BytesRefHash	`BytesRefHash` is a special purpose hash-map like data-structure optimized for `BytesRef` instances.
BytesRefHash.BytesStartArray	Manages allocation of the per-term addresses.
BytesRefHash.DirectBytesStartArray	A simple `BytesRefHash.BytesStartArray` that tracks memory allocation using a private `Counter` instance.
BytesRefHash.MaxBytesLengthExceededException	Thrown if a `BytesRef` exceeds the `BytesRefHash` limit of `ByteBlockPool.BYTE_BLOCK_SIZE`-2.
BytesRefIterator	A simple iterator interface for `BytesRef` iteration.
BytesRefSorter	Collects `BytesRef` and then allows one to iterate over their sorted order.
BytesTermAttribute	This attribute can be used if you have the raw term bytes to be indexed.
BytesTermAttributeImpl	Implementation class for `BytesTermAttribute`.
ByteTrackingIndexOutput	An `IndexOutput` that wraps another instance and tracks the number of bytes written
ByteVector	This class implements a simple byte vector with access to the underlying array.
ByteVectorSimilarityFunction	`ByteVectorSimilarityFunction` returns a similarity function between two knn vectors with byte elements.
ByteVectorSimilarityQuery	Search for all (approximate) byte vectors above a similarity threshold.
ByteVectorSimilarityValuesSource	A `DoubleValuesSource` which computes the vector similarity scores between the query vector and the `KnnByteVectorField` for documents.
ByteVectorValues	This class provides access to per-document floating point vector values indexed as `KnnByteVectorField`.
ByteWritesTrackingDirectoryWrapper	`FilterDirectory` that tracks write amplification factor
CachingCollector	Caches all docs, and optionally also scores, coming from a search, and is then able to replay them to another collector.
CachingCollector.CachedScorable
CachingCollector.NoScoreCachingCollector
CachingCollector.ScoreCachingCollector
CachingExpressionValueSource	This expression value source shares one value cache when generating `ExpressionFunctionValues` such that only one value along the whole generation tree is corresponding to one name
CachingMatchesIterator
CachingMergeContext	a wrapper of IndexWriter MergeContext.
CachingNaiveBayesClassifier	A simplistic Lucene based NaiveBayes classifier, with caching feature, see `http://en.wikipedia.org/wiki/Naive_Bayes_classifier`
CachingTokenFilter	This class can be used if the token attributes of a TokenStream are intended to be consumed more than once.
CandidateMatcher<T extends QueryMatch>	Class used to match candidate queries selected by a Presearcher from a Monitor query index.
CandidateMatcher.MatchHolder<T>
CapitalizationFilter	A filter to apply normal capitalization rules to Tokens.
CapitalizationFilterFactory	Factory for `CapitalizationFilter`.
CatalanAnalyzer	`Analyzer` for Catalan.
CatalanAnalyzer.DefaultSetHolder	Atomically loads the DEFAULT_STOP_SET in a lazy fashion once the outer class accesses the static final set the first time.;
CatalanStemmer	This class implements the stemming algorithm defined by a snowball script.
Cell	A Cell is a portion of a trie.
CharacterDefinition	Character category data.
CharacterDefinition	Character category data.
CharacterDefinition.CharacterClass
CharacterDefinition.CharacterClass
CharacterDefinition.SingletonHolder
CharacterDefinition.SingletonHolder
CharacterDefinitionWriter
CharacterDefinitionWriter
CharacterRunAutomaton	Automaton representation for matching char[].
CharacterUtils	Utility class to write tokenizers or token filters.
CharacterUtils.CharacterBuffer	A simple IO buffer to use with `CharacterUtils.fill(CharacterBuffer, Reader)`.
CharArrayIterator	Wraps a char[] as CharacterIterator for processing with a BreakIterator
CharArrayIterator	A CharacterIterator used internally for use with `BreakIterator`
CharArrayMap<V>	A simple class that stores key Strings as char[]'s in a hash table.
CharArrayMap.EmptyCharArrayMap<V>	Empty `CharArrayMap.UnmodifiableCharArrayMap` optimized for speed.
CharArrayMap.UnmodifiableCharArrayMap<V>
CharArrayMatcher	Matches a character array
CharArraySet	A simple class that stores Strings as char[]'s in a hash table.
CharCursor	Forked from HPPC, holding int index and char value.
CharFilter	Subclasses of CharFilter can be chained to filter a Reader They can be used as `Reader` with additional offset correction.
CharFilterFactory	Abstract parent class for analysis factories that create `CharFilter` instances.
CharFilterFactory.Holder	This static holder class prevents classloading deadlock by delaying init of factories until needed.
CharHashSet	A hash set of `char`s, implemented using open addressing with linear probing for collision resolution.
CharObjectHashMap<VType>	A hash map of `char` to `Object`, implemented using open addressing with linear probing for collision resolution.
CharObjectHashMap.CharObjectCursor<VType>	Forked from HPPC, holding int index,key and value
CharSequenceIterator	A `CharacterIterator` over a `CharSequence`.
CharSequenceOutputs	An FST `Outputs` implementation where each output is a sequence of characters.
CharSequenceUtils	Utility functions for `JapaneseCompletionFilter`
CharsRef	Represents char[], as a slice (offset + length) into an existing char[].
CharsRef.UTF16SortedAsUTF8Comparator	Deprecated. This comparator is only a transition mechanism
CharsRefBuilder	A builder for `CharsRef` instances.
CharStream	This interface describes a character stream that maintains line and column number positions of the characters.
CharTermAttribute	The term text of a Token.
CharTermAttributeImpl	Default implementation of `CharTermAttribute`.
CharTokenizer	An abstract base class for simple, character-oriented tokenizers.
CharType	Internal SmartChineseAnalyzer character type constants.
CharVector	This class implements a simple char vector with access to the underlying array.
CheckCompoundPattern
CheckedIntConsumer<T extends java.lang.Exception>	Like `IntConsumer`, but may throw checked exceptions.
CheckIndex	Basic tool and API to check the health of an index and write a new segments file that removes reference to problematic segments.
CheckIndex.CheckIndexException	The marker RuntimeException used by CheckIndex APIs when index integrity failure is detected.
CheckIndex.ConstantRelationIntersectVisitor
CheckIndex.DocValuesIteratorSupplier
CheckIndex.Options	Run-time configuration options for CheckIndex commands.
CheckIndex.Status	Returned from `CheckIndex.checkIndex()` detailing the health and status of the index.
CheckIndex.Status.DocValuesStatus	Status from testing DocValues
CheckIndex.Status.FieldInfoStatus	Status from testing field infos.
CheckIndex.Status.FieldNormStatus	Status from testing field norms.
CheckIndex.Status.IndexSortStatus	Status from testing index sort
CheckIndex.Status.LiveDocStatus	Status from testing livedocs
CheckIndex.Status.PointsStatus	Status from testing PointValues
CheckIndex.Status.SegmentInfoStatus	Holds the status of each segment in the index.
CheckIndex.Status.SoftDeletsStatus	Status from testing soft deletes
CheckIndex.Status.StoredFieldStatus	Status from testing stored fields.
CheckIndex.Status.TermIndexStatus	Status from testing term index.
CheckIndex.Status.TermVectorStatus	Status from testing stored fields.
CheckIndex.Status.VectorValuesStatus	Status from testing vector values
CheckIndex.VerifyPointsVisitor	Walks the entire N-dimensional points space, verifying that all points fall within the last cell's boundaries.
CheckJoinIndex	Utility class to check a block join index.
ChecksumIndexInput	Extension of IndexInput, computing checksum as it goes.
Circle	Represents a circle on the earth's surface.
Circle2D	2D circle implementation containing spatial logic.
Circle2D.CartesianDistance
Circle2D.DistanceCalculator
Circle2D.HaversinDistance
CJKAnalyzer	An `Analyzer` that tokenizes text with `StandardTokenizer`, normalizes content with `CJKWidthFilter`, folds case with `LowerCaseFilter`, forms bigrams of CJK with `CJKBigramFilter`, and filters stopwords with `StopFilter`
CJKAnalyzer.DefaultSetHolder
CJKBigramFilter	Forms bigrams of CJK terms that are generated from StandardTokenizer or ICUTokenizer.
CJKBigramFilterFactory	Factory for `CJKBigramFilter`.
CJKWidthCharFilter	A `CharFilter` that normalizes CJK width differences: Folds fullwidth ASCII variants into the equivalent basic latin Folds halfwidth Katakana variants into the equivalent kana
CJKWidthCharFilterFactory	Factory for `CJKWidthCharFilter`.
CJKWidthFilter	A `TokenFilter` that normalizes CJK width differences: Folds fullwidth ASCII variants into the equivalent basic latin Folds halfwidth Katakana variants into the equivalent kana
CJKWidthFilterFactory	Factory for `CJKWidthFilter`.
ClassicAnalyzer	Filters `ClassicTokenizer` with `ClassicFilter`, `LowerCaseFilter` and `StopFilter`, using a list of English stop words.
ClassicFilter	Normalizes tokens extracted with `ClassicTokenizer`.
ClassicFilterFactory	Factory for `ClassicFilter`.
ClassicSimilarity	Expert: Historical scoring implementation.
ClassicTokenizer	A grammar-based tokenizer constructed with JFlex
ClassicTokenizerFactory	Factory for `ClassicTokenizer`.
ClassicTokenizerImpl	This class implements the classic lucene StandardTokenizer up until 3.0
ClassificationResult<T>	The result of a call to `Classifier.assignClass(String)` holding an assigned class of type `T` and a score.
Classifier<T>	A classifier, see `http://en.wikipedia.org/wiki/Classifier_(mathematics)`, which assign classes of type `T`
ClassLoaderUtils	Helper class used by ServiceLoader to investigate parent/child relationships of `ClassLoader`s.
ClasspathResourceLoader	Simple `ResourceLoader` that uses `ClassLoader.getResourceAsStream(String)` and `Class.forName(String,boolean,ClassLoader)` to open resources and classes, respectively.
CloseableRandomVectorScorerSupplier	A supplier that creates `RandomVectorScorer` from an ordinal.
CloseableThreadLocal<T>	Java's builtin ThreadLocal has a serious flaw: it can take an arbitrarily long amount of time to dereference the things you had stored in it, even once the ThreadLocal instance itself is no longer referenced.
Codec	Encodes/decodes an inverted index segment.
Codec.Holder	This static holder class prevents classloading deadlock by delaying init of default codecs and available codecs until needed.
CodecReader	LeafReader implemented by codec APIs.
CodecUtil	Utility class for reading and writing versioned headers.
CodepointCountFilter	Removes words that are too long or too short from the stream.
CodepointCountFilterFactory	Factory for `CodepointCountFilter`.
CollatedTermAttributeImpl	Extension of `CharTermAttributeImpl` that encodes the term text as a binary Unicode collation key instead of as UTF-8 bytes.
CollationAttributeFactory	Converts each token into its `CollationKey`, and then encodes the bytes as an index term.
CollationDocValuesField	Indexes collation keys as a single-valued `SortedDocValuesField`.
CollationKeyAnalyzer	Configures `KeywordTokenizer` with `CollationAttributeFactory`.
CollectedSearchGroup<T>	Expert: representation of a group in `FirstPassGroupingCollector`, tracking the top doc and `FieldComparator` slot.
CollectingMatcher<T extends QueryMatch>
CollectionStatistics	Contains statistics for a collection (field).
CollectionTerminatedException	Throw this exception in `LeafCollector.collect(int)` to prematurely terminate collection of the current leaf.
CollectionUtil	Methods for manipulating (sorting) and creating collections.
CollectionUtil.ListIntroSorter<T>
CollectionUtil.ListTimSorter<T>
Collector	Expert: Collectors are primarily meant to be used to gather raw results from a search, and implement sorting or custom result filtering, collation, etc.
CollectorManager<C extends Collector,T>	A manager of collectors.
CollectorMemoryTracker	Default implementation of `MemoryTracker` that tracks allocations and allows setting a memory limit per collector
CombinedFieldQuery	A `Query` that treats multiple fields as a single stream and scores terms as if you had indexed them as a single term in a single field.
CombinedFieldQuery.Builder	A builder for `CombinedFieldQuery`.
CombinedFieldQuery.CombinedFieldScorer
CombinedFieldQuery.FieldAndWeight
CombinedFieldQuery.WeightedDisiWrapper
CombineSuggestion	A suggestion generated by combining one or more original query terms
CommandLineUtil	Class containing some useful methods used by command line tools
CommonGramsFilter	Construct bigrams for frequently occurring terms while indexing.
CommonGramsFilterFactory	Constructs a `CommonGramsFilter`.
CommonGramsQueryFilter	Wrap a CommonGramsFilter optimizing phrase queries by only returning single words when they are not a member of a bigram.
CommonGramsQueryFilterFactory	Construct `CommonGramsQueryFilter`.
CommonQueryParserConfiguration	Configuration options common across queryparser implementations.
CommonTermsQuery	A query that executes high-frequency terms in a optional sub-query to prevent slow queries due to "common" terms like stopwords.
ComparisonBoolFunction	Base class for comparison operators useful within an "if"/conditional.
CompetitiveImpactAccumulator	This class accumulates the (freq, norm) pairs that may produce competitive scores.
Compile	The Compile class is used to compile a stemmer table.
CompiledAutomaton	Immutable class holding compiled details for a given Automaton.
CompiledAutomaton.AUTOMATON_TYPE	Automata are compiled into different internal forms for the most efficient execution depending upon the language they accept.
Completion50PostingsFormat	`CompletionPostingsFormat` for `org.apache.lucene.backward_codecs.lucene50.Lucene50PostingsFormat`.
Completion84PostingsFormat	`CompletionPostingsFormat` for `org.apache.lucene.backward_codecs.lucene84.Lucene84PostingsFormat`.
Completion90PostingsFormat	`CompletionPostingsFormat` for `org.apache.lucene.backward_codecs.lucene90.Lucene90PostingsFormat`.
Completion99PostingsFormat	`CompletionPostingsFormat` for `Lucene99PostingsFormat`
CompletionAnalyzer	Wraps an `Analyzer` to provide additional completion-only tuning (e.g.
CompletionFieldsConsumer	Weighted FSTs for any indexed `SuggestField` is built on `CompletionFieldsConsumer.write(Fields,NormsProducer)`.
CompletionFieldsConsumer.CompletionMetaData
CompletionFieldsConsumer.CompletionTermWriter
CompletionFieldsProducer	Completion index (.cmp) is opened and read at instantiation to read in `SuggestField` numbers and their FST offsets in the Completion dictionary (.lkp).
CompletionPostingsFormat	A `PostingsFormat` which supports document suggestion based on indexed `SuggestField`s.
CompletionPostingsFormat.FSTLoadMode	An enum that allows to control if suggester FSTs are loaded into memory or read off-heap
CompletionQuery	Abstract `Query` that match documents containing terms with a specified prefix filtered by `BitsProducer`.
CompletionScorer	Expert: Responsible for executing the query against an appropriate suggester and collecting the results via a collector.
CompletionsTermsReader	Holder for suggester and field-level info for a suggest field
CompletionTerms	Wrapped `Terms` used by `SuggestField` and `ContextSuggestField` to access corresponding suggester and their attributes
CompletionTokenStream	A `ConcatenateGraphFilter` but we can set the payload and provide access to config options.
CompletionWeight	Expert: the Weight for CompletionQuery, used to score and explain these queries.
ComplexPhraseQueryParser	QueryParser which permits complex phrase query syntax eg "(john jon jonathan~) peters*".
ComplexPhraseQueryParser.ComplexPhraseQuery
Component2D	2D Geometry object that supports spatial relationships with bounding boxes, triangles and points.
Component2D.WithinRelation	Used by withinTriangle to check the within relationship between a triangle and the query shape (e.g.
ComponentTree	2D multi-component geometry implementation represented as an interval tree of components.
ComposedQuery	Base class for composite queries (such as AND/OR/NOT)
CompositeBreakIterator	An internal BreakIterator for multilingual text, following recommendations from: UAX #29: Unicode Text Segmentation.
CompositeReader	Instances of this reader type can only be used to get stored fields from the underlying LeafReaders, but it is not possible to directly retrieve postings.
CompositeReaderContext	`IndexReaderContext` for `CompositeReader` instance.
CompositeReaderContext.Builder
CompoundDirectory	A read-only `Directory` that consists of a view over a compound file.
CompoundFormat	Encodes/decodes compound files
CompoundRule
CompoundWordTokenFilterBase	Base class for decomposition token filters.
CompressionAlgorithm	Compression algorithm used for suffixes of a block of terms.
CompressionAlgorithm	Compression algorithm used for suffixes of a block of terms.
CompressionMode	A compression mode.
CompressionMode	A compression mode.
CompressionMode.DeflateCompressor
CompressionMode.DeflateCompressor
CompressionMode.DeflateDecompressor
CompressionMode.DeflateDecompressor
CompressionMode.LZ4FastCompressor
CompressionMode.LZ4FastCompressor
CompressionMode.LZ4HighCompressor
CompressionMode.LZ4HighCompressor
Compressor	A data compressor.
Compressor	A data compressor.
ConcatenateGraphFilter	Concatenates/Joins every incoming token with a separator into one output token for every path through the token stream (which is a graph).
ConcatenateGraphFilter.BytesRefBuilderTermAttribute	Attribute providing access to the term builder and UTF-16 conversion
ConcatenateGraphFilter.BytesRefBuilderTermAttributeImpl	Implementation of `ConcatenateGraphFilter.BytesRefBuilderTermAttribute`
ConcatenateGraphFilter.EscapingTokenStreamToAutomaton	Just escapes the `ConcatenateGraphFilter.SEP_LABEL` byte with an extra.
ConcatenateGraphFilterFactory	Factory for `ConcatenateGraphFilter`.
ConcatenatingTokenStream	A TokenStream that takes an array of input TokenStreams as sources, and concatenates them together.
ConcurrentApproximatePriorityQueue<T>	Concurrent version of `ApproximatePriorityQueue`, which trades a bit more of ordering for better concurrency by maintaining multiple sub `ApproximatePriorityQueue`s that are locked independently.
ConcurrentHnswMerger	This merger merges graph in a concurrent manner, by using `HnswConcurrentMergeBuilder`
ConcurrentMergeScheduler	A `MergeScheduler` that runs each merge using a separate thread.
ConcurrentMergeSchedulerAccess	Access to `ConcurrentMergeScheduler` internals exposed to the test framework.
ConcurrentQueryLoader	Utility class for concurrently loading queries into a Monitor.
ConditionalTokenFilter	Allows skipping TokenFilters based on the current set of attributes.
ConditionalTokenFilter.TokenState
ConditionalTokenFilterFactory	Abstract parent class for analysis factories that create `ConditionalTokenFilter` instances
ConfigurationKey<T>	An instance of this class represents a key that is used to retrieve a value from `AbstractQueryConfig`.
ConfusionMatrixGenerator	Utility class to generate the confusion matrix of a `Classifier`
ConfusionMatrixGenerator.ConfusionMatrix	a confusion matrix, backed by a `Map` representing the linearized matrix
ConjunctionBulkScorer	BulkScorer implementation of `ConjunctionScorer`.
ConjunctionDISI	A conjunction of DocIdSetIterators.
ConjunctionDISI.BitSetConjunctionDISI	Conjunction between a `DocIdSetIterator` and one or more `BitSetIterator`s.
ConjunctionDISI.ConjunctionTwoPhaseIterator	`TwoPhaseIterator` implementing a conjunction.
ConjunctionIntervalIterator
ConjunctionIntervalsSource
ConjunctionMatchesIterator
ConjunctionMatchesIterator.SingletonMatchesIterator
ConjunctionScorer	Scorer for conjunctions, sets of queries, all of which are required.
ConjunctionScorer.DocsAndFreqs
ConjunctionSpans	Common super class for multiple sub spans required in a document.
ConjunctionUtils	Helper methods for building conjunction iterators
ConnectionCosts	n-gram connection cost data
ConnectionCosts	n-gram connection cost data
ConnectionCosts.SingletonHolder
ConnectionCosts.SingletonHolder
ConnectionCostsBuilder
ConnectionCostsBuilder
ConnectionCostsWriter
ConnectionCostsWriter
Constants	Some useful constants.
ConstantScoreQuery	A query that wraps another query and simply returns a constant score equal to 1 for every document that matches the query.
ConstantScoreQuery.ConstantBulkScorer	We return this as our `BulkScorer` so that if the CSQ wraps a query with its own optimized top-level scorer (e.g.
ConstantScoreQueryBuilder	Builder for `ConstantScoreQuery`
ConstantScoreScorer	A constant-scoring `Scorer`.
ConstantScoreWeight	A Weight that has a constant score equal to the boost of the wrapped query.
ConstKnnByteVectorValueSource	Function that returns a constant byte vector value for every document.
ConstKnnFloatValueSource	Function that returns a constant float vector value for every document.
ConstNumberSource	`ConstNumberSource` is the base class for all constant numbers
ConstValueSource	`ConstValueSource` returns a constant for all documents
ContainedBy	Node that represents `Intervals.containedBy(IntervalsSource, IntervalsSource)`.
ContainedByIntervalsSource
Containing	Node that represents `Intervals.containing(IntervalsSource, IntervalsSource)`.
ContainingIntervalsSource
ContainSpans
ContextQuery	A `CompletionQuery` that matches documents specified by a wrapped `CompletionQuery` supporting boosting and/or filtering by specified contexts.
ContextQuery.ContextCompletionWeight
ContextQuery.ContextMetaData	Holder for context value meta data
ContextSuggestField	`SuggestField` which additionally takes in a set of contexts.
ContextSuggestField.PrefixTokenFilter	The `ContextSuggestField.PrefixTokenFilter` wraps a `TokenStream` and adds a set prefixes ahead.
ControlledRealTimeReopenThread<T>	Utility class that runs a thread to manage periodicc reopens of a `ReferenceManager`, with methods to wait for a specific index changes to become visible.
ConvTable	ICONV or OCONV replacement table
CoreParser	Assembles a QueryBuilder which uses only core Lucene Query objects
CorePlusExtensionsParser	Assembles a QueryBuilder which uses Query objects from Lucene's `sandbox` and `queries` modules in addition to core queries.
CorePlusQueriesParser	Assembles a QueryBuilder which uses Query objects from Lucene's `queries` module in addition to core queries.
CorruptIndexException	This exception is thrown when Lucene detects an inconsistency in the index.
Counter	Simple counter class
Counter.AtomicCounter
Counter.SerialCounter
CoveringQuery	A `Query` that allows to have a configurable number or required matches per document.
CoveringQuery.CoveringWeight
CoveringScorer	A `Scorer` whose number of matches is per-document.
CSVUtil	Utility class for parsing CSV text
CustomAnalyzer	A general-purpose Analyzer that can be created with a builder-style API.
CustomAnalyzer.Builder	Builder for `CustomAnalyzer`.
CustomAnalyzer.ConditionBuilder	Factory class for a `ConditionalTokenFilter`
CustomQueryHandler	Builds a `QueryTree` for a query that needs custom treatment
CustomSeparatorBreakIterator	A `BreakIterator` that breaks the text whenever a certain separator, provided as a constructor argument, is found.
CzechAnalyzer	`Analyzer` for Czech language.
CzechAnalyzer.DefaultSetHolder
CzechStemFilter	A `TokenFilter` that applies `CzechStemmer` to stem Czech words.
CzechStemFilterFactory	Factory for `CzechStemFilter`.
CzechStemmer	Light Stemmer for Czech.
DaciukMihovAutomatonBuilder	Deprecated. Visibility of this class will be reduced in a future release.
DaciukMihovAutomatonBuilder.State	DFSA state with `char` labels on transitions.
DaitchMokotoffSoundexFilter	Create tokens for phonetic matches based on Daitch–Mokotoff Soundex.
DaitchMokotoffSoundexFilterFactory	Factory for `DaitchMokotoffSoundexFilter`.
DanishAnalyzer	`Analyzer` for Danish.
DanishAnalyzer.DefaultSetHolder	Atomically loads the DEFAULT_STOP_SET in a lazy fashion once the outer class accesses the static final set the first time.;
DanishStemmer	This class implements the stemming algorithm defined by a snowball script.
DataInput	Abstract base class for performing read operations of Lucene's low-level data types.
DataOutput	Abstract base class for performing write operations of Lucene's low-level data types.
DatasetSplitter	Utility class for creating training / test / cross validation indexes from the original index.
DateRecognizerFilter	Filters all tokens that cannot be parsed to a date, using the provided `DateFormat`.
DateRecognizerFilterFactory	Factory for `DateRecognizerFilter`.
DateTools	Provides support for converting dates to strings and vice-versa.
DateTools.Resolution	Specifies the time granularity.
DecimalDigitFilter	Folds all Unicode digits in `[:General_Category=Decimal_Number:]` to Basic Latin digits (`0-9`).
DecimalDigitFilterFactory	Factory for `DecimalDigitFilter`.
DecompoundToken	A token that was generated from a compound.
Decompressor	A decompressor.
Decompressor	A decompressor.
DefaultBloomFilterFactory	Default policy is to allocate a bitset with 10% saturation given a unique term per document.
DefaultEncoder	Simple `Encoder` implementation that does not modify the output
DefaultFlatVectorScorer	Default implementation of `FlatVectorsScorer`.
DefaultFlatVectorScorer.ByteScoringSupplier	RandomVectorScorerSupplier for bytes vector
DefaultFlatVectorScorer.ByteVectorScorer	A `RandomVectorScorer` for byte vectors.
DefaultFlatVectorScorer.FloatScoringSupplier	RandomVectorScorerSupplier for Float vector
DefaultFlatVectorScorer.FloatVectorScorer	A `RandomVectorScorer` for float vectors.
DefaultICUTokenizerConfig	Default `ICUTokenizerConfig` that is generally applicable to many languages.
DefaultPassageFormatter	Creates a formatted snippet from the top passages.
DefaultPhraseSlopQueryNodeProcessor	This processor verifies if `StandardQueryConfigHandler.ConfigurationKeys.PHRASE_SLOP` is defined in the `QueryConfigHandler`.
DefaultVectorizationProvider	Default provider returning scalar implementations.
DefaultVectorUtilSupport
DefFunction	`ValueSource` implementation which only returns the values from the provided ValueSources which are available for a particular docId.
DeflateWithPresetDictCompressionMode	A compression mode that trades speed for compression ratio.
DeflateWithPresetDictCompressionMode	A compression mode that trades speed for compression ratio.
DeflateWithPresetDictCompressionMode.DeflateWithPresetDictCompressor
DeflateWithPresetDictCompressionMode.DeflateWithPresetDictCompressor
DeflateWithPresetDictCompressionMode.DeflateWithPresetDictDecompressor
DeflateWithPresetDictCompressionMode.DeflateWithPresetDictDecompressor
DelegatingAnalyzerWrapper	An analyzer wrapper, that doesn't allow to wrap components or readers.
DelegatingAnalyzerWrapper.DelegatingReuseStrategy
DeletedQueryNode	A `DeletedQueryNode` represents a node that was deleted from the query node tree.
DelimitedBoostTokenFilter	Characters before the delimiter are the "token", those after are the boost.
DelimitedBoostTokenFilterFactory	Factory for `DelimitedBoostTokenFilter`.
DelimitedPayloadTokenFilter	Characters before the delimiter are the "token", those after are the payload.
DelimitedPayloadTokenFilterFactory	Factory for `DelimitedPayloadTokenFilter`.
DelimitedTermFrequencyTokenFilter	Characters before the delimiter are the "token", the textual integer after is the term frequency.
DelimitedTermFrequencyTokenFilterFactory	Factory for `DelimitedTermFrequencyTokenFilter`.
DeltaBaseTermStateSerializer	`TermState` serializer which encodes each file pointer as a delta relative to a base file pointer.
DeltaPackedLongValues
DeltaPackedLongValues.Builder
DFISimilarity	Implements the Divergence from Independence (DFI) model based on Chi-square statistics (i.e., standardized Chi-squared distance from independence in term frequency tf).
DFRSimilarity	Implements the divergence from randomness (DFR) framework introduced in Gianni Amati and Cornelis Joost Van Rijsbergen.
DictEntries	An object representing homonym dictionary entries.
DictEntry	An object representing *.dic file entry with its word, flags and morphological data.
Dictionary	In-memory structure for the dictionary (.dic) and affix (.aff) data of a hunspell dictionary.
Dictionary	Dictionary interface for retrieving morphological data by id.
Dictionary	Dictionary interface for retrieving morphological data by id.
Dictionary	A simple interface representing a Dictionary.
Dictionary.Breaks	Possible word breaks according to BREAK directives
Dictionary.DefaultAsUtf8FlagParsingStrategy	Used to read flags as UTF-8 even if the rest of the file is in the default (8-bit) encoding
Dictionary.DoubleASCIIFlagParsingStrategy	Implementation of `Dictionary.FlagParsingStrategy` that assumes each flag is encoded as two ASCII characters whose codes must be combined into a single character.
Dictionary.FlagParsingStrategy	Abstraction of the process of parsing flags taken from the affix and dic files
Dictionary.Morpheme	A morpheme extracted from a compound token.
Dictionary.NumFlagParsingStrategy	Implementation of `Dictionary.FlagParsingStrategy` that assumes each flag is encoded in its numerical form.
Dictionary.SimpleFlagParsingStrategy	Simple implementation of `Dictionary.FlagParsingStrategy` that treats the chars in each String as a individual flags.
DictionaryBuilder	Tool to build dictionaries.
DictionaryBuilder	Tool to build dictionaries.
DictionaryBuilder.DictionaryFormat	Format of the dictionary.
DictionaryCompoundWordTokenFilter	A `TokenFilter` that decomposes compound words found in many Germanic languages.
DictionaryCompoundWordTokenFilterFactory	Factory for `DictionaryCompoundWordTokenFilter`.
DictionaryToken	A token stored in a `Dictionary`.
Diff	The Diff object generates a patch string.
DifferenceIntervalsSource
DiffIt	The DiffIt class is a means generate patch commands from an already prepared stemmer table.
DirectIODirectory	A `Directory` implementation for all Unixes and Windows that uses DIRECT I/O to bypass OS level IO caching during merging.
DirectIODirectory.DirectIOIndexInput
DirectIODirectory.DirectIOIndexOutput
DirectMonotonicReader	Retrieves an instance previously written by `DirectMonotonicWriter`.
DirectMonotonicReader.Meta	In-memory metadata that needs to be kept around for `DirectMonotonicReader` to read data from disk.
DirectMonotonicWriter	Write monotonically-increasing sequences of integers.
Directory	A `Directory` provides an abstraction layer for storing a list of files.
DirectoryReader	DirectoryReader is an implementation of `CompositeReader` that can read indexes in a `Directory`.
DirectPacked64SingleBlockReader
DirectPackedReader
DirectPostingsFormat	Wraps `Lucene99PostingsFormat` format for on-disk storage, but then at read time loads and stores all terms and postings directly in RAM as byte[], int[].
DirectPostingsFormat.DirectField
DirectPostingsFormat.DirectField.HighFreqTerm
DirectPostingsFormat.DirectField.IntArrayWriter
DirectPostingsFormat.DirectField.LowFreqTerm
DirectPostingsFormat.DirectField.TermAndSkip
DirectPostingsFormat.DirectFields
DirectPostingsFormat.HighFreqDocsEnum
DirectPostingsFormat.HighFreqPostingsEnum
DirectPostingsFormat.LowFreqDocsEnum
DirectPostingsFormat.LowFreqDocsEnumNoPos
DirectPostingsFormat.LowFreqDocsEnumNoTF
DirectPostingsFormat.LowFreqPostingsEnum
DirectReader	Retrieves an instance previously written by `DirectWriter`
DirectReader.DirectPackedReader1
DirectReader.DirectPackedReader12
DirectReader.DirectPackedReader16
DirectReader.DirectPackedReader2
DirectReader.DirectPackedReader20
DirectReader.DirectPackedReader24
DirectReader.DirectPackedReader28
DirectReader.DirectPackedReader32
DirectReader.DirectPackedReader4
DirectReader.DirectPackedReader40
DirectReader.DirectPackedReader48
DirectReader.DirectPackedReader56
DirectReader.DirectPackedReader64
DirectReader.DirectPackedReader8
DirectSpellChecker	Simple automaton-based spellchecker.
DirectSpellChecker.ScoreTerm	Holds a spelling correction for internal usage inside `DirectSpellChecker`.
DirectWriter	Class for writing packed integers to be directly read from Directory.
DisiPriorityQueue	A priority queue of DocIdSetIterators that orders by current doc ID.
DisiPriorityQueue	A priority queue of DocIdSetIterators that orders by current doc ID.
DisiWrapper
DisiWrapper	Wrapper used in `DisiPriorityQueue`.
DisjunctionDISIApproximation	A `DocIdSetIterator` which is a disjunction of the approximations of the provided iterators.
DisjunctionDISIApproximation	A `DocIdSetIterator` which is a disjunction of the approximations of the provided iterators.
DisjunctionIntervalsSource
DisjunctionIntervalsSource.DisjunctionIntervalIterator
DisjunctionIntervalsSource.DisjunctionMatchesIterator
DisjunctionMatchesIterator	A `MatchesIterator` that combines matches from a set of sub-iterators
DisjunctionMatchesIterator.TermsEnumDisjunctionMatchesIterator
DisjunctionMaxQuery	A query that generates the union of documents produced by its subqueries, and that scores each document with the maximum score for that document as produced by any subquery, plus a tie breaking increment for any additional matching subqueries.
DisjunctionMaxQueryBuilder	Builder for `DisjunctionMaxQuery`
DisjunctionMaxScorer	The Scorer for DisjunctionMaxQuery.
Disjunctions
DisjunctionScoreBlockBoundaryPropagator	A helper to propagate block boundaries for disjunctions.
DisjunctionScorer	Base class for Scorers that score disjunctions.
DisjunctionSumScorer	A Scorer for OR like queries, counterpart of `ConjunctionScorer`.
DistanceQuery	Factory for NEAR queries
DistanceRewriteQuery
DistanceStyle	Distance computation styles, supporting various ways of computing distance to shapes.
DistanceSubQuery	Interface for queries that can be nested as subqueries into a span near.
DistinctValuesCollector<T,R>	A second pass grouping collector that keeps track of distinct values for a specified field for the top N group.
DistinctValuesCollector.DistinctValuesReducer<T,R>
DistinctValuesCollector.GroupCount<T,R>	Returned by `DistinctValuesCollector.getGroups()`, representing the value and set of distinct values for the group.
DistinctValuesCollector.ValuesCollector<R>
Distribution	The probabilistic distribution used to model term occurrence in information-based models.
DistributionLL	Log-logistic distribution.
DistributionSPL	The smoothed power-law (SPL) distribution for the information-based framework that is described in the original paper.
DiversifiedTopDocsCollector	A `TopDocsCollector` that controls diversity in results by ensuring no more than maxHitsPerKey results from a common source are collected in the final results.
DiversifiedTopDocsCollector.ScoreDocKey	An extension to ScoreDoc that includes a key used for grouping purposes
DiversifiedTopDocsCollector.ScoreDocKeyQueue
DiversifyingChildrenByteKnnVectorQuery	kNN byte vector query that joins matching children vector documents with their parent doc id.
DiversifyingChildrenFloatKnnVectorQuery	kNN float vector query that joins matching children vector documents with their parent doc id.
DiversifyingChildrenFloatKnnVectorQuery.DiversifyingChildrenVectorScorer
DiversifyingNearestChildrenKnnCollector	This collects the nearest children vectors.
DiversifyingNearestChildrenKnnCollector.NodeIdCachingHeap	This is a minimum binary heap, inspired by `LongHeap`.
DiversifyingNearestChildrenKnnCollector.ParentChildScore	Keeps track of child node, parent node, and the stored score.
DiversifyingNearestChildrenKnnCollectorManager	DiversifyingNearestChildrenKnnCollectorManager responsible for creating `DiversifyingNearestChildrenKnnCollector` instances.
DivFloatFunction	Function to divide "a" by "b"
Dl4jModelReader	Dl4jModelReader reads the file generated by the library Deeplearning4j and provide a Word2VecModel with normalized vectors
DocBaseBitSetIterator	A `DocIdSetIterator` like `BitSetIterator` but has a doc base in onder to avoid storing previous 0s.
DocComparator	Comparator that sorts by asc _doc
DocFreqValueSource	`DocFreqValueSource` returns the number of documents containing the term.
DocFreqValueSource.ConstDoubleDocValues
DocFreqValueSource.ConstIntDocValues
DocIDMerger<T extends DocIDMerger.Sub>	Utility class to help merging documents from sub-readers according to either simple concatenated (unsorted) order, or by a specified index-time sort, skipping deleted documents and remapping non-deleted documents.
DocIDMerger.SequentialDocIDMerger<T extends DocIDMerger.Sub>
DocIDMerger.SortedDocIDMerger<T extends DocIDMerger.Sub>
DocIDMerger.Sub	Represents one sub-reader being merged
DocIdSet	A DocIdSet contains a set of doc ids.
DocIdSetBuilder	A builder of `DocIdSet`s.
DocIdSetBuilder.Buffer
DocIdSetBuilder.BufferAdder
DocIdSetBuilder.BulkAdder	Utility class to efficiently add many docs in one go.
DocIdSetBuilder.FixedBitSetAdder
DocIdSetIterator	This abstract class defines methods to iterate over a set of non-decreasing doc ids.
DocIdStream	A stream of doc IDs.
DocIdsWriter
DocsWithFieldSet	Accumulator for documents that have a value for a field.
DocTermsIndexDocValues	Serves as base class for FunctionValues based on DocTermsIndex.
DocTermsIndexDocValues.DocTermsIndexException	Custom Exception to be thrown when the DocTermsIndex for a field cannot be generated
DocToDoubleVectorUtils	utility class for converting Lucene `Document`s to `Double` vectors.
Document	Documents are the unit of indexing and search.
DocumentBatch
DocumentBatch.MultiDocumentBatch
DocumentBatch.SingletonDocumentBatch
DocumentClassifier<T>	A classifier, see `http://en.wikipedia.org/wiki/Classifier_(mathematics)`, which assign classes of type `T` to a `Document`s
DocumentDictionary	Dictionary with terms, weights, payload (optional) and contexts (optional) information taken from stored/indexed fields in a Lucene index.
DocumentStoredFieldVisitor	A `StoredFieldVisitor` that creates a `Document` from stored fields.
DocumentsWriter	This class accepts multiple added documents and directly writes segment files.
DocumentsWriter.FlushNotifications
DocumentsWriterDeleteQueue	`DocumentsWriterDeleteQueue` is a non-blocking linked pending deletes queue.
DocumentsWriterDeleteQueue.DeleteSlice
DocumentsWriterDeleteQueue.DocValuesUpdatesNode
DocumentsWriterDeleteQueue.Node<T>
DocumentsWriterDeleteQueue.QueryArrayNode
DocumentsWriterDeleteQueue.QueryNode
DocumentsWriterDeleteQueue.TermArrayNode
DocumentsWriterDeleteQueue.TermNode
DocumentsWriterFlushControl	This class controls `DocumentsWriterPerThread` flushing during indexing.
DocumentsWriterFlushQueue
DocumentsWriterFlushQueue.FlushTicket
DocumentsWriterPerThread
DocumentsWriterPerThread.FlushedSegment
DocumentsWriterPerThreadPool	`DocumentsWriterPerThreadPool` controls `DocumentsWriterPerThread` instances and their thread assignments during indexing.
DocumentsWriterStallControl	Controls the health status of a `DocumentsWriter` sessions.
DocumentValueSourceDictionary	Dictionary with terms and optionally payload and optionally contexts information taken from stored fields in a Lucene index.
DocValues	This class contains utility methods and constants for DocValues
DocValuesConsumer	Abstract API that consumes numeric, binary and sorted docvalues.
DocValuesConsumer.BinaryDocValuesSub	Tracks state of one binary sub-reader that we are merging
DocValuesConsumer.BitsFilteredTermsEnum
DocValuesConsumer.MergedTermsEnum	A merged `TermsEnum`.
DocValuesConsumer.NumericDocValuesSub	Tracks state of one numeric sub-reader that we are merging
DocValuesConsumer.SortedDocValuesSub	Tracks state of one sorted sub-reader that we are merging
DocValuesConsumer.SortedNumericDocValuesSub	Tracks state of one sorted numeric sub-reader that we are merging
DocValuesConsumer.SortedSetDocValuesSub	Tracks state of one sorted set sub-reader that we are merging
DocValuesFieldExistsQuery	Deprecated. Use `FieldExistsQuery` instead.
DocValuesFieldUpdates	Holds updates of a single DocValues field, for a set of documents within one segment.
DocValuesFieldUpdates.AbstractIterator
DocValuesFieldUpdates.Iterator	An iterator over documents and their updated values.
DocValuesFieldUpdates.SingleValueDocValuesFieldUpdates
DocValuesFormat	Encodes/decodes per-document values.
DocValuesFormat.Holder	This static holder class prevents classloading deadlock by delaying init of doc values formats until needed.
DocValuesIterator
DocValuesLeafReader
DocValuesLongHashSet	Set of longs, optimized for docvalues usage
DocValuesProducer	Abstract API that produces numeric, binary, sorted, sortedset, and sortednumeric docvalues.
DocValuesRewriteMethod	Rewrites MultiTermQueries into a filter, using DocValues for term enumeration.
DocValuesRewriteMethod.MultiTermQueryDocValuesWrapper
DocValuesStats<T>	Holds statistics for a DocValues field.
DocValuesStats.DoubleDocValuesStats	Holds DocValues statistics for a numeric field storing `double` values.
DocValuesStats.LongDocValuesStats	Holds DocValues statistics for a numeric field storing `long` values.
DocValuesStats.NumericDocValuesStats<T extends java.lang.Number>	Holds statistics for a numeric DocValues field.
DocValuesStats.SortedDocValuesStats	Holds statistics for a sorted DocValues field.
DocValuesStats.SortedDoubleDocValuesStats	Holds DocValues statistics for a sorted-numeric field storing `double` values.
DocValuesStats.SortedLongDocValuesStats	Holds DocValues statistics for a sorted-numeric field storing `long` values.
DocValuesStats.SortedNumericDocValuesStats<T extends java.lang.Number>	Holds statistics for a sorted-numeric DocValues field.
DocValuesStats.SortedSetDocValuesStats	Holds statistics for a sorted-set DocValues field.
DocValuesStatsCollector	A `Collector` which computes statistics for a DocValues field.
DocValuesTermsCollector<DV>
DocValuesTermsCollector.Function<R>
DocValuesType	DocValues types.
DocValuesUpdate	An in-place update to a DocValues field.
DocValuesUpdate.BinaryDocValuesUpdate	An in-place update to a binary DocValues field
DocValuesUpdate.NumericDocValuesUpdate	An in-place update to a numeric DocValues field
DocValuesWriter<T extends DocIdSetIterator>
DOMUtils	Helper methods for parsing XML
DoubleComparator	Comparator based on `Double.compare(double, double)` for `numHits`.
DoubleConstValueSource	Function that returns a constant double value for every document.
DoubleCursor	Forked from HPPC, holding int index and double value.
DoubleDocValues	Abstract `FunctionValues` implementation which supports retrieving double values.
DoubleDocValuesField	Syntactic sugar for encoding doubles as NumericDocValues via `Double.doubleToRawLongBits(double)`.
DoubleField	Field that stores a per-document `double` value for scoring, sorting or value retrieval and index the field for fast range filters.
DoubleFieldSource	Obtains double field values from `LeafReader.getNumericDocValues(java.lang.String)` and makes those values available as other numeric types, casting as needed.
DoubleMetaphoneFilter	Filter for DoubleMetaphone (supporting secondary codes)
DoubleMetaphoneFilterFactory	Factory for `DoubleMetaphoneFilter`.
DoublePoint	An indexed `double` field for fast range filters.
DoublePointMultiRangeBuilder	Builder for multi range queries for DoublePoints
DoubleRange	An indexed Double Range field.
DoubleRange	Represents a contiguous range of double values, with an inclusive minimum and exclusive maximum
DoubleRangeDocValuesField	DocValues field for DoubleRange.
DoubleRangeFactory	Groups double values into ranges
DoubleRangeGroupSelector	A GroupSelector implementation that groups documents by double values
DoubleRangeSlowRangeQuery
DoubleValues	Per-segment, per-document double values, which can be calculated at search-time
DoubleValuesSource	Base class for producing `DoubleValues`
DoubleValuesSource.ConstantValuesSource
DoubleValuesSource.DoubleValuesComparatorSource
DoubleValuesSource.DoubleValuesHolder
DoubleValuesSource.DoubleValuesSortField
DoubleValuesSource.FieldValuesSource
DoubleValuesSource.LongDoubleValuesSource
DoubleValuesSource.QueryDoubleValuesSource
DoubleValuesSource.WeightDoubleValuesSource
DropIfFlaggedFilter	Allows Tokens with a given combination of flags to be dropped.
DropIfFlaggedFilterFactory	Provides a filter that will drop tokens matching a set of flags.
DualFloatFunction	Abstract `ValueSource` implementation which wraps two ValueSources and applies an extendible float function to their values.
DummyQueryNodeBuilder	This builder does nothing.
DutchAnalyzer	`Analyzer` for Dutch language.
DutchAnalyzer.DefaultSetHolder
DutchStemmer	This class implements the stemming algorithm defined by a snowball script.
dXdYdZSolid	3D rectangle, bounded on six sides by X,Y,Z limits, degenerate in all dimensions
dXdYZSolid	3D rectangle, bounded on six sides by X,Y,Z limits, degenerate in X and Y.
dXYdZSolid	3D rectangle, bounded on six sides by X,Y,Z limits, degenerate in X and Z.
dXYZSolid	3D rectangle, bounded on six sides by X,Y,Z limits, degenerate in X.
EdgeNGramFilterFactory	Creates new instances of `EdgeNGramTokenFilter`.
EdgeNGramTokenFilter	Tokenizes the given token into n-grams of given size(s).
EdgeNGramTokenizer	Tokenizes the input from an edge into n-grams of given size(s).
EdgeNGramTokenizerFactory	Creates new instances of `EdgeNGramTokenizer`.
EdgeTree	Internal tree node: represents geometry edge from [x1, y1] to [x2, y2].
ElisionFilter	Removes elisions from a `TokenStream`.
ElisionFilterFactory	Factory for `ElisionFilter`.
EmptyDocValuesProducer	Abstract base class implementing a `DocValuesProducer` that has no doc values.
EmptyTokenStream	An always exhausted token stream.
Encoder	Encodes original text.
EndiannessReverserChecksumIndexInput	A `ChecksumIndexInput` wrapper that changes the endianness of the provided index output.
EndiannessReverserDataInput
EndiannessReverserDataOutput
EndiannessReverserIndexInput	A `IndexInput` wrapper that changes the endianness of the provided index input.
EndiannessReverserIndexInput.EndiannessReverserRandomAccessInput	A `RandomAccessInput` wrapper that changes the endianness of the provided index input.
EndiannessReverserIndexOutput	A `IndexOutput` wrapper that changes the endianness of the provided index output.
EndiannessReverserUtil	Utility class to wrap open files
EnglishAnalyzer	`Analyzer` for English.
EnglishMinimalStemFilter	A `TokenFilter` that applies `EnglishMinimalStemmer` to stem English words.
EnglishMinimalStemFilterFactory	Factory for `EnglishMinimalStemFilter`.
EnglishMinimalStemmer	Minimal plural stemmer for English.
EnglishPossessiveFilter	TokenFilter that removes possessives (trailing 's) from words.
EnglishPossessiveFilterFactory	Factory for `EnglishPossessiveFilter`.
EnglishStemmer	This class implements the stemming algorithm defined by a snowball script.
EntrySuggestion	Suggestion to add/edit dictionary entries to generate a given list of words created by `WordFormGenerator.compress(java.util.List<java.lang.String>, java.util.Set<java.lang.String>, java.lang.Runnable)`.
EnumFieldSource	Obtains int field values from `LeafReader.getNumericDocValues(java.lang.String)` and makes those values available as other numeric types, casting as needed.
EscapeQuerySyntax	A parser needs to implement `EscapeQuerySyntax` to allow the QueryNode to escape the queries, when the toQueryString method is called.
EscapeQuerySyntax.Type	Type of escaping: String for escaping syntax, NORMAL for escaping reserved words (like AND) in terms
EscapeQuerySyntaxImpl	Implementation of `EscapeQuerySyntax` for the standard lucene syntax.
EstonianAnalyzer	`Analyzer` for Estonian.
EstonianAnalyzer.DefaultSetHolder	Atomically loads the DEFAULT_STOP_SET in a lazy fashion once the outer class accesses the static final set the first time.;
EstonianStemmer	This class implements the stemming algorithm defined by a snowball script.
ExactPhraseMatcher	Expert: Find exact phrases
ExactPhraseMatcher.PostingsAndPosition
ExitableDirectoryReader	The `ExitableDirectoryReader` wraps a real index `DirectoryReader` and allows for a `QueryTimeout` implementation object to be checked periodically to see if the thread should exit or not.
ExitableDirectoryReader.ExitableFilterAtomicReader	Wrapper class for another FilterAtomicReader.
ExitableDirectoryReader.ExitableIntersectVisitor
ExitableDirectoryReader.ExitablePointTree
ExitableDirectoryReader.ExitablePointValues	Wrapper class for another PointValues implementation that is used by ExitableFields.
ExitableDirectoryReader.ExitableSubReaderWrapper	Wrapper class for a SubReaderWrapper that is used by the ExitableDirectoryReader.
ExitableDirectoryReader.ExitableTerms	Wrapper class for another Terms implementation that is used by ExitableFields.
ExitableDirectoryReader.ExitableTermsEnum	Wrapper class for TermsEnum that is used by ExitableTerms for implementing an exitable enumeration of terms.
ExitableDirectoryReader.ExitingReaderException	Exception that is thrown to prematurely terminate a term enumeration.
ExplainingMatch	A query match containing the score explanation of the match
Explanation	Expert: Describes the score computation for document and query.
Expression	Base class that computes the value of an expression for a document.
ExpressionFunctionValues	A `DoubleValues` which evaluates an expression
ExpressionMath	Helper class holding static methods for js math functions
ExpressionRescorer	A `Rescorer` that uses an expression to re-score first pass hits.
ExpressionValueSource	A `DoubleValuesSource` which evaluates a `Expression` given the context of an `Bindings`.
Extend	Node that represents `Intervals.extend(IntervalsSource, int, int)`.
ExtendableQueryParser	The `ExtendableQueryParser` enables arbitrary query parser extension based on a customizable field naming scheme.
ExtendedIntervalIterator	Wraps an IntervalIterator and extends the bounds of its intervals
ExtendedIntervalsSource
ExtensionQuery	`ExtensionQuery` holds all query components extracted from the original query string like the query field and the extension query string.
Extensions	The `Extensions` class represents an extension mapping to associate `ParserExtension` instances with extension keys.
Extensions.Pair<Cur,Cud>	This class represents a generic pair.
ExternalRefSorter	An implementation of a `BytesRefSorter` that allows appending `BytesRef`s to an `OfflineSorter` and returns a `Closeable` `ExternalRefSorter.ByteSequenceIterator` that iterates over sequences stored on disk.
ExternalRefSorter.ByteSequenceIterator	Iterates over `BytesRef`s in a file, closes the reader when the iterator is exhausted.
FastCharStream	An efficient implementation of JavaCC's CharStream interface.
FastVectorHighlighter	Another highlighter implementation.
FeatureDoubleValuesSource	A `DoubleValuesSource` instance which can be used to read the values of a feature from a `FeatureField` for documents.
FeatureDoubleValuesSource.FeatureDoubleValues
FeatureField	`Field` that can be used to store static scoring factors into documents.
FeatureField.FeatureFunction
FeatureField.FeatureTokenStream
FeatureField.LinearFunction
FeatureField.LogFunction
FeatureField.SaturationFunction
FeatureField.SigmoidFunction
FeatureQuery
FeatureSortField	Sorts using the value of a specified feature name from a `FeatureField`.
Field	Expert: directly create a field for a document.
Field.BinaryTokenStream
Field.Store	Specifies whether and how a field should be stored.
Field.StringTokenStream
FieldableNode	A query node implements `FieldableNode` interface to indicate that its children and itself are associated to a specific field.
FieldBoostMapFCListener	This listener listens for every field configuration request and assign a `StandardQueryConfigHandler.ConfigurationKeys.BOOST` to the equivalent `FieldConfig` based on a defined map: fieldName -> boostValue stored in `StandardQueryConfigHandler.ConfigurationKeys.FIELD_BOOST_MAP`.
FieldCacheSource	A base class for ValueSource implementations that retrieve values for a single field from DocValues.
FieldComparator<T>	Expert: a FieldComparator compares hits so as to determine their sort order when collecting the top results with `TopFieldCollector`.
FieldComparator.RelevanceComparator	Sorts by descending relevance.
FieldComparator.TermValComparator	Sorts by field's natural Term sort order.
FieldComparatorSource	Provides a `FieldComparator` for custom field sorting.
FieldConfig	This class represents a field configuration.
FieldConfigListener	This interface should be implemented by classes that wants to listen for field configuration requests.
FieldDateResolutionFCListener	This listener listens for every field configuration request and assign a `StandardQueryConfigHandler.ConfigurationKeys.DATE_RESOLUTION` to the equivalent `FieldConfig` based on a defined map: fieldName -> `DateTools.Resolution` stored in `StandardQueryConfigHandler.ConfigurationKeys.FIELD_DATE_RESOLUTION_MAP`.
FieldDoc	Expert: A ScoreDoc which also contains information about how to sort the referenced document.
FieldExistsQuery	A `Query` that matches documents that contain either a `KnnFloatVectorField`, `KnnByteVectorField` or a field that indexes norms or doc values.
FieldFragList	FieldFragList has a list of "frag info" that is used by FragmentsBuilder class to create fragments (snippets).
FieldFragList.WeightedFragInfo	List of term offsets + weight for a frag info
FieldFragList.WeightedFragInfo.SubInfo	Represents the list of term offsets for some text
FieldHighlighter	Internal highlighter abstraction that operates on a per field basis.
FieldInfo	Access to the Field Info file that describes document fields and whether or not they are indexed.
FieldInfos	Collection of `FieldInfo`s (accessible by number or by name).
FieldInfos.Builder
FieldInfos.FieldDimensions
FieldInfos.FieldNumbers
FieldInfos.FieldVectorProperties
FieldInfosFormat	Encodes/decodes `FieldInfos`
FieldInvertState	This class tracks the number and position / offset parameters of terms being added to the index.
FieldMaskingSpanQuery	Wrapper to allow `SpanQuery` objects participate in composite single-field SpanQueries by 'lying' about their search field.
FieldMetadata	Metadata and stats for one field in the index.
FieldMetadata.Serializer	Reads/writes field metadata.
FieldMetadataTermState	Pair of `FieldMetadata` and `BlockTermState` for a specific field.
FieldOffsetStrategy	Ultimately returns an `OffsetsEnum` yielding potentially highlightable words in the text.
FieldPhraseList	FieldPhraseList has a list of WeightedPhraseInfo that is used by FragListBuilder to create a FieldFragList object.
FieldPhraseList.WeightedPhraseInfo	Represents the list of term offsets and boost for some text
FieldPhraseList.WeightedPhraseInfo.Toffs	Term offsets (start + end)
FieldQuery	FieldQuery breaks down query object into terms/phrases and keeps them in a QueryPhraseMap structure.
FieldQuery.QueryPhraseMap	Internal structure of a query for highlighting: represents a nested query structure
FieldQueryNode	A `FieldQueryNode` represents a element that contains field/text tuple
FieldQueryNodeBuilder	Builds a `TermQuery` object from a `FieldQueryNode` object.
FieldReader	BlockTree's implementation of `Terms`.
FieldReader	BlockTree's implementation of `Terms`.
Fields	Provides a `Terms` index for fields that have it, and lists which fields do.
FieldsConsumer	Abstract API that consumes terms, doc, freq, prox, offset and payloads postings.
FieldsIndex
FieldsIndex
FieldsIndexReader
FieldsIndexReader
FieldsIndexWriter	Efficient index format for block-based `Codec`s.
FieldsProducer	Abstract API that produces terms, doc, freq, prox, offset and payloads postings.
FieldsQuery	Forms an OR query of the provided query across multiple fields.
FieldTermIterator	Iterates over terms in across multiple fields.
FieldTermStack	`FieldTermStack` is a stack that keeps query terms in the specified field of the document to be highlighted.
FieldTermStack.TermInfo	Single term with its position/offsets in the document and IDF weight.
FieldType	Describes the properties of a field.
FieldUpdatesBuffer	This class efficiently buffers numeric and binary field updates and stores terms, values and metadata in a memory efficient way without creating large amounts of objects.
FieldUpdatesBuffer.BufferedUpdate	Struct like class that is used to iterate over all updates in this buffer
FieldValueHighlighters	A factory of `MatchHighlighter.FieldValueHighlighter` classes that cover typical use cases (verbatim values, highlights, abbreviations).
FieldValueHighlighters.AbstractFieldValueHighlighter
FieldValueHitQueue<T extends FieldValueHitQueue.Entry>	Expert: A hit queue for sorting by hits by terms in more than one field.
FieldValueHitQueue.Entry	Extension of ScoreDoc to also store the `FieldComparator` slot.
FieldValueHitQueue.MultiComparatorsFieldValueHitQueue<T extends FieldValueHitQueue.Entry>	An implementation of `FieldValueHitQueue` which is optimized in case there is more than one comparator.
FieldValueHitQueue.OneComparatorFieldValueHitQueue<T extends FieldValueHitQueue.Entry>	An implementation of `FieldValueHitQueue` which is optimized in case there is just one comparator.
FieldValuePairQueryNode<T>	This interface should be implemented by `QueryNode` that holds a field and an arbitrary value.
FileDeleter	This class provides ability to track the reference counts of a set of index files and delete them when their counts decreased to 0.
FileDeleter.MsgType	Types of messages this file deleter will broadcast REF: messages about reference FILE: messages about file
FileDeleter.RefCount	Tracks the reference count for a single index file:
FileDictionary	Dictionary represented by a text file.
FileSwitchDirectory	Expert: A Directory instance that switches files between two other Directory instances.
FilesystemResourceLoader	Simple `ResourceLoader` that opens resource files from the local file system, optionally resolving against a base directory.
FilterBinaryDocValues	Delegates all methods to a wrapped `BinaryDocValues`.
FilterCodec	A codec that forwards all its method calls to another codec.
FilterCodecReader	A `FilterCodecReader` contains another CodecReader, which it uses as its basic source of data, possibly transforming the data along the way or providing additional functionality.
FilterCollector	`Collector` delegator.
FilterDirectory	Directory implementation that delegates calls to another directory.
FilterDirectoryReader	A FilterDirectoryReader wraps another DirectoryReader, allowing implementations to transform or extend it.
FilterDirectoryReader.DelegatingCacheHelper	A DelegatingCacheHelper is a CacheHelper specialization for implementing long-lived caching behaviour for FilterDirectoryReader subclasses.
FilterDirectoryReader.SubReaderWrapper	Factory class passed to FilterDirectoryReader constructor that allows subclasses to wrap the filtered DirectoryReader's subreaders.
FilteredDocIdSetIterator	Abstract decorator class of a DocIdSetIterator implementation that provides on-demand filter/validation mechanism on an underlying DocIdSetIterator.
FilteredIntervalsSource	An IntervalsSource that filters the intervals from another IntervalsSource
FilteredIntervalsSource.MaxGaps
FilteredIntervalsSource.MaxWidth
FilteredTermsEnum	Abstract class for enumerating a subset of all terms.
FilteredTermsEnum.AcceptStatus	Return value, if term should be accepted or the iteration should `END`.
FilterIndexInput	IndexInput implementation that delegates calls to another directory.
FilterIndexInputAccess	Access to `FilterIndexInput` internals exposed to the test framework.
FilterIndexOutput	IndexOutput implementation that delegates calls to another directory.
FilteringIntervalIterator
FilteringTokenFilter	Abstract base class for TokenFilters that may remove tokens.
FilterIterator<T,InnerT extends T>	An `Iterator` implementation that filters elements with a boolean predicate.
FilterLeafCollector	`LeafCollector` delegator.
FilterLeafReader	A `FilterLeafReader` contains another LeafReader, which it uses as its basic source of data, possibly transforming the data along the way or providing additional functionality.
FilterLeafReader.FilterFields	Base class for filtering `Fields` implementations.
FilterLeafReader.FilterPostingsEnum	Base class for filtering `PostingsEnum` implementations.
FilterLeafReader.FilterTerms	Base class for filtering `Terms` implementations.
FilterLeafReader.FilterTermsEnum	Base class for filtering `TermsEnum` implementations.
FilterMatchesIterator	A MatchesIterator that delegates all calls to another MatchesIterator
FilterMergePolicy	A wrapper for `MergePolicy` instances.
FilterNumericDocValues	Delegates all methods to a wrapped `NumericDocValues`.
FilterScorable	Filter a `Scorable`, intercepting methods and optionally changing their return values
FilterScorer	A `FilterScorer` contains another `Scorer`, which it uses as its basic source of data, possibly transforming the data along the way or providing additional functionality.
FilterSortedDocValues	Delegates all methods to a wrapped `SortedDocValues`.
FilterSortedNumericDocValues	Delegates all methods to a wrapped `SortedNumericDocValues`.
FilterSortedSetDocValues	Delegates all methods to a wrapped `SortedSetDocValues`.
FilterSpans	A `Spans` implementation wrapping another spans instance, allowing to filter spans matches easily by implementing `FilterSpans.accept(org.apache.lucene.queries.spans.Spans)`
FilterSpans.AcceptStatus	Status returned from `FilterSpans.accept(Spans)` that indicates whether a candidate match should be accepted, rejected, or rejected and move on to the next document.
FilterVectorValues	Delegates all methods to a wrapped `FloatVectorValues`.
FilterWeight	A `FilterWeight` contains another `Weight` and implements all abstract methods by calling the contained weight's method.
FingerprintFilter	Filter outputs a single token which is a concatenation of the sorted and de-duplicated set of input tokens.
FingerprintFilterFactory	Factory for `FingerprintFilter`.
FiniteStringsIterator	Iterates all accepted strings.
FiniteStringsIterator.PathNode	Nodes for path stack.
FinnishAnalyzer	`Analyzer` for Finnish.
FinnishAnalyzer.DefaultSetHolder	Atomically loads the DEFAULT_STOP_SET in a lazy fashion once the outer class accesses the static final set the first time.;
FinnishLightStemFilter	A `TokenFilter` that applies `FinnishLightStemmer` to stem Finnish words.
FinnishLightStemFilterFactory	Factory for `FinnishLightStemFilter`.
FinnishLightStemmer	Light Stemmer for Finnish.
FinnishStemmer	This class implements the stemming algorithm defined by a snowball script.
FirstPassGroupingCollector<T>	FirstPassGroupingCollector is the first of two passes necessary to collect grouped hits.
FixBrokenOffsetsFilter	Deprecated. Fix the token filters that create broken offsets in the first place.
FixBrokenOffsetsFilterFactory	Deprecated.
FixedBits	Immutable twin of FixedBitSet.
FixedBitSet	BitSet of fixed length (numBits), backed by accessible (`FixedBitSet.getBits()`) long[], accessed with an int index, implementing `Bits` and `DocIdSet`.
FixedFieldIntervalsSource
FixedGapTermsIndexReader	TermsIndexReader for simple every Nth terms indexes.
FixedGapTermsIndexWriter	Selects every Nth term as and index term, and hold term bytes (mostly) fully expanded in memory.
FixedLengthBytesRefArray	Just like `BytesRefArray` except all values have the same length.
FixedShingleFilter	A FixedShingleFilter constructs shingles (token n-grams) from a token stream.
FixedShingleFilterFactory	Factory for `FixedShingleFilter`
FlagEnumerator	A structure similar to `BytesRefHash`, but specialized for sorted char sequences used for Hunspell flags.
FlagEnumerator.Lookup
FlagsAttribute	This attribute can be used to pass different flags down the `Tokenizer` chain, e.g.
FlagsAttributeImpl	Default implementation of `FlagsAttribute`.
FlatBitVectorsScorer	A bit vector scorer for scoring byte vectors.
FlatBitVectorsScorer.BitRandomVectorScorer
FlatBitVectorsScorer.BitRandomVectorScorerSupplier
FlatFieldVectorsWriter<T>	Vectors' writer for a field
FlattenGraphFilter	Converts an incoming graph token stream, such as one from `SynonymGraphFilter`, into a flat form so that all nodes form a single linear chain with no side paths.
FlattenGraphFilter.InputNode	Holds all tokens leaving a given input position.
FlattenGraphFilter.OutputNode	Gathers up merged input positions into a single output position, only for the current "frontier" of nodes we've seen but can't yet output because they are not frozen.
FlattenGraphFilterFactory	Factory for `FlattenGraphFilter`.
FlatVectorScorerUtil	Utilities for `FlatVectorsScorer`.
FlatVectorsFormat	Encodes/decodes per-document vectors and provides a scoring interface for the flat stored vectors
FlatVectorsReader	Reads vectors from an index.
FlatVectorsScorer	Provides mechanisms to score vectors that are stored in a flat file The purpose of this class is for providing flexibility to the codec utilizing the vectors
FlatVectorsWriter	Vectors' writer for a field that allows additional indexing logic to be implemented by the caller
FloatArrayList	An array-backed list of `float`.
FloatArrayList.ValueIterator	An iterator implementation for `FloatArrayList.iterator()`.
FloatComparator	Comparator based on `Float.compare(float, float)` for `numHits`.
FloatCursor	Forked from HPPC, holding int index and float value.
FloatDocValues	Abstract `FunctionValues` implementation which supports retrieving float values.
FloatDocValuesField	Syntactic sugar for encoding floats as NumericDocValues via `Float.floatToRawIntBits(float)`.
FloatEncoder	Encode a character array Float as a `BytesRef`.
FloatField	Field that stores a per-document `float` value for scoring, sorting or value retrieval and index the field for fast range filters.
FloatFieldSource	Obtains float field values from `LeafReader.getNumericDocValues(java.lang.String)` and makes those values available as other numeric types, casting as needed.
FloatHeap	A bounded min heap that stores floats.
FloatKnnVectorFieldSource	An implementation for retrieving `FunctionValues` instances for float knn vectors fields.
FloatPoint	An indexed `float` field for fast range filters.
FloatPointMultiRangeBuilder	Builder for multi range queries for FloatPoints
FloatPointNearestNeighbor	KNN search on top of N dimensional indexed float points.
FloatPointNearestNeighbor.Cell
FloatPointNearestNeighbor.NearestHit	Holds one hit from `FloatPointNearestNeighbor.nearest(java.util.List<org.apache.lucene.index.PointValues>, java.util.List<org.apache.lucene.util.Bits>, org.apache.lucene.internal.hppc.IntArrayList, int, float[])`
FloatPointNearestNeighbor.NearestVisitor
FloatRange	An indexed Float Range field.
FloatRangeDocValuesField	DocValues field for FloatRange.
FloatRangeSlowRangeQuery
FloatVectorSimilarityFunction	`FloatVectorSimilarityFunction` returns a similarity function between two knn vectors with float elements.
FloatVectorSimilarityQuery	Search for all (approximate) float vectors above a similarity threshold.
FloatVectorSimilarityValuesSource	A `DoubleValuesSource` which computes the vector similarity scores between the query vector and the `KnnFloatVectorField` for documents.
FloatVectorValues	This class provides access to per-document floating point vector values indexed as `KnnFloatVectorField`.
FlushByRamOrCountsPolicy	Default `FlushPolicy` implementation that flushes new segments based on RAM used and document count depending on the IndexWriter's `IndexWriterConfig`.
FlushInfo	A FlushInfo provides information required for a FLUSH context.
FlushPolicy	`FlushPolicy` controls when segments are flushed from a RAM resident internal data-structure to the `IndexWriter`s `Directory`.
ForceNoBulkScoringQuery	Query wrapper that forces its wrapped Query to use the default doc-by-doc BulkScorer.
ForDeltaUtil	Utility class to encode/decode increasing sequences of 128 integers.
ForDeltaUtil	Utility class to encode/decode increasing sequences of 128 integers.
Formatter	Processes terms found in the original text, typically by applying some form of mark-up to highlight terms in HTML search results pages.
ForUtil	Encode all values in normal area with fixed bit width, which is determined by the max value in this block.
ForUtil
ForUtil
ForUtil
ForwardBytesReader	Reads from a single byte[].
FragListBuilder	FragListBuilder is an interface for FieldFragList builder classes.
FragmentChecker	An oracle for quickly checking that a specific part of a word can never be a valid word.
Fragmenter	Implements the policy for breaking text into multiple fragments for consideration by the `Highlighter` class.
FragmentsBuilder	`FragmentsBuilder` is an interface for fragments (snippets) builder classes.
FreeTextSuggester	Builds an ngram model from the text sent to `FreeTextSuggester.build(org.apache.lucene.search.suggest.InputIterator)` and predicts based on the last grams-1 tokens in the request sent to `FreeTextSuggester.lookup(java.lang.CharSequence, boolean, int)`.
FrenchAnalyzer	`Analyzer` for French language.
FrenchAnalyzer.DefaultSetHolder
FrenchLightStemFilter	A `TokenFilter` that applies `FrenchLightStemmer` to stem French words.
FrenchLightStemFilterFactory	Factory for `FrenchLightStemFilter`.
FrenchLightStemmer	Light Stemmer for French.
FrenchMinimalStemFilter	A `TokenFilter` that applies `FrenchMinimalStemmer` to stem French words.
FrenchMinimalStemFilterFactory	Factory for `FrenchMinimalStemFilter`.
FrenchMinimalStemmer	Light Stemmer for French.
FrenchStemmer	This class implements the stemming algorithm defined by a snowball script.
FreqProxFields	Implements limited (iterators only, no stats) `Fields` interface over the in-RAM buffered fields/terms/postings, to flush postings through the PostingsFormat.
FreqProxFields.FreqProxDocsEnum
FreqProxFields.FreqProxPostingsEnum
FreqProxFields.FreqProxTerms
FreqProxFields.FreqProxTermsEnum
FreqProxTermsWriter
FreqProxTermsWriter.SortingDocsEnum
FreqProxTermsWriter.SortingPostingsEnum
FreqProxTermsWriter.SortingPostingsEnum.DocOffsetSorter	A `TimSorter` which sorts two parallel arrays of doc IDs and offsets in one go.
FreqProxTermsWriter.SortingTerms
FreqProxTermsWriter.SortingTermsEnum
FreqProxTermsWriterPerField
FreqProxTermsWriterPerField.FreqProxPostingsArray
FrequencyTrackingRingBuffer	A ring buffer that tracks the frequency of the integers that it contains.
FrequencyTrackingRingBuffer.IntBag	A bag of integers.
FrozenBufferedUpdates	Holds buffered deletes and updates by term or query, once pushed.
FrozenBufferedUpdates.TermDocsIterator	This class helps iterating a term dictionary and consuming all the docs for each terms.
FrozenBufferedUpdates.TermDocsIterator.TermsProvider
FrozenIntSet
FSDirectory	Base class for Directory implementations that store index files in the file system.
FSLockFactory	Base class for file system based locking implementation.
FST<T>	Represents an finite state machine (FST), using a compact byte[] format.
FST.Arc<T>	Represents a single arc.
FST.Arc.BitTable	Helper methods to read the bit-table of a direct addressing node.
FST.BytesReader	Reads bytes stored in an FST.
FST.FSTMetadata<T>	Represents the FST metadata.
FST.INPUT_TYPE	Specifies allowed range of each int input label for this FST.
FSTCompiler<T>	Builds a minimal FST (maps an IntsRef term to an arbitrary output) from pre-sorted terms with outputs.
FSTCompiler.Arc<T>	Expert: holds a pending (seen but not yet serialized) arc.
FSTCompiler.Builder<T>	Fluent-style constructor for FST `FSTCompiler`.
FSTCompiler.CompiledNode
FSTCompiler.FixedLengthArcsBuffer	Reusable buffer for building nodes with fixed length arcs (binary search or direct addressing).
FSTCompiler.Node
FSTCompiler.NullFSTReader	This class is used for FST backed by non-FSTReader DataOutput.
FSTCompiler.UnCompiledNode<T>	Expert: holds a pending (seen but not yet serialized) Node.
FSTCompletion	Finite state automata based implementation of "autocomplete" functionality.
FSTCompletion.Completion	A single completion for a given key.
FSTCompletionBuilder	Finite state automata based implementation of "autocomplete" functionality.
FSTCompletionLookup	An adapter from `Lookup` API to `FSTCompletion`.
FSTDictionary	Immutable stateless `FST`-based index dictionary kept in memory.
FSTDictionary.BrowserSupplier	Provides stateful `FSTDictionary.Browser` to seek in the `FSTDictionary`.
FSTDictionary.Builder	Builds an immutable `FSTDictionary`.
FSTEnum<T>	Can next() and advance() through the terms in an FST
FSTOrdsOutputs	A custom FST outputs implementation that stores block data (BytesRef), long ordStart, long numTerms.
FSTOrdsOutputs.Output
FSTPostingsFormat	FST term dict + Lucene50PBF
FSTReader	Abstraction for reading bytes necessary for FST.
FSTStore	A type of `FSTReader` which needs data to be initialized before use
FSTTermOutputs	An FST `Outputs` implementation for `FSTTermsWriter`.
FSTTermOutputs.TermData	Represents the metadata for one term.
FSTTermsReader	FST-based terms dictionary reader.
FSTTermsWriter	FST-based term dict, using metadata as FST output.
FSTTermsWriter.FieldMetaData
FSTUtil	Exposes a utility method to enumerate all paths intersecting an `Automaton` with an `FST`.
FSTUtil.Path<T>	Holds a pair (automaton, fst) of states and accumulated output in the intersected machine.
FunctionMatchQuery	A query that retrieves all documents with a `DoubleValues` value matching a predicate
FunctionQuery	Returns a score for each document based on a ValueSource, often some function of the value of a field.
FunctionRangeQuery	A Query wrapping a `ValueSource` that matches docs in which the values in the value source match a configured range.
FunctionScoreQuery	A query that wraps another query, and uses a DoubleValuesSource to replace or modify the wrapped query's score
FunctionScoreQuery.FunctionScoreWeight
FunctionScoreQuery.MultiplicativeBoostValuesSource
FunctionScoreQuery.QueryBoostValuesSource
FunctionValues	Represents field values as different types.
FunctionValues.ValueFiller	Abstraction of the logic required to fill the value of a specified doc into a reusable `MutableValue`.
FuzzyAutomatonBuilder	Builds a set of CompiledAutomaton for fuzzy matching on a given term, with specified maximum edit distance, fixed prefix and whether or not to allow transpositions.
FuzzyCompletionQuery	A `CompletionQuery` that match documents containing terms within an edit distance of the specified prefix.
FuzzyCompletionQuery.FuzzyCompletionWeight
FuzzyConfig	Configuration parameters for `FuzzyQuery`s
FuzzyLikeThisQuery	Fuzzifies ALL terms provided as strings and then picks the best n differentiating terms.
FuzzyLikeThisQuery.FieldVals
FuzzyLikeThisQuery.ScoreTerm
FuzzyLikeThisQuery.ScoreTermQueue
FuzzyLikeThisQueryBuilder	Builder for `FuzzyLikeThisQuery`
FuzzyQuery	Implements the fuzzy search query.
FuzzyQueryNode	A `FuzzyQueryNode` represents a element that contains field/text/similarity tuple
FuzzyQueryNodeBuilder	Builds a `FuzzyQuery` object from a `FuzzyQueryNode` object.
FuzzyQueryNodeProcessor	This processor iterates the query node tree looking for every `FuzzyQueryNode`, when this kind of node is found, it checks on the query configuration for `StandardQueryConfigHandler.ConfigurationKeys.FUZZY_CONFIG`, gets the fuzzy prefix length and default similarity from it and set to the fuzzy node.
FuzzySet	A class used to represent a set of many, potentially large, values (e.g.
FuzzySet.ContainsResult	Result from `FuzzySet.contains(BytesRef)`: can never return definitively YES (always MAYBE), but can sometimes definitely return NO.
FuzzySuggester	Implements a fuzzy `AnalyzingSuggester`.
FuzzyTerm	An interval function equivalent to `FuzzyQuery`.
FuzzyTermsEnum	Subclass of TermsEnum for enumerating all terms that are similar to the specified filter term.
FuzzyTermsEnum.AutomatonAttribute	Used for sharing automata between segments
FuzzyTermsEnum.AutomatonAttributeImpl
FuzzyTermsEnum.FuzzyTermsException	Thrown to indicate that there was an issue creating a fuzzy query for a given term.
GalicianAnalyzer	`Analyzer` for Galician.
GalicianAnalyzer.DefaultSetHolder	Atomically loads the DEFAULT_STOP_SET in a lazy fashion once the outer class accesses the static final set the first time.;
GalicianMinimalStemFilter	A `TokenFilter` that applies `GalicianMinimalStemmer` to stem Galician words.
GalicianMinimalStemFilterFactory	Factory for `GalicianMinimalStemFilter`.
GalicianMinimalStemmer	Minimal Stemmer for Galician
GalicianStemFilter	A `TokenFilter` that applies `GalicianStemmer` to stem Galician words.
GalicianStemFilterFactory	Factory for `GalicianStemFilter`.
GalicianStemmer	Galician stemmer implementing "Regras do lematizador para o galego".
Gener	The Gener object helps in the discarding of nodes which break the reduction effort and defend the structure against large reductions.
GeneratingSuggester	A class that traverses the entire dictionary and applies affix rules to check if those yield correct suggestions similar enough to the given misspelled word
GeneratingSuggester.AffixProcessor
GeneratingSuggester.Weighted<T extends java.lang.Comparable<T>>
GenericTermsCollector
Geo3DDocValuesField	An per-document 3D location field.
Geo3DPoint	Add this to a document to index lat/lon or x/y/z point, indexed as a 3D point.
Geo3DPointDistanceComparator	Compares documents by distance from an origin point, using a GeoDistanceShape to compute the distance
Geo3DPointOutsideDistanceComparator	Compares documents by outside distance, using a GeoOutsideDistance to compute the distance
Geo3DPointOutsideSortField	Sorts by outside distance from an origin location.
Geo3DPointSortField	Sorts by distance from an origin location.
Geo3DUtil
GeoArea	A GeoArea represents a standard 2-D breakdown of a part of sphere.
GeoAreaFactory	Factory for `GeoArea`.
GeoAreaShape	Shape that implements GeoArea.
GeoBaseAreaShape	Base extended areaShape object.
GeoBaseBBox	All bounding box shapes can derive from this base class, which furnishes some common code
GeoBaseBounds	Base object that supports bounds operations.
GeoBaseCircle	GeoCircles have all the characteristics of GeoBaseDistanceShapes, plus GeoSizeable.
GeoBaseCompositeAreaShape<T extends GeoAreaShape>	Base class to create a composite of GeoAreaShapes
GeoBaseCompositeMembershipShape<T extends GeoMembershipShape>	Base class to create a composite of GeoMembershipShapes
GeoBaseCompositeShape<T extends GeoShape>	Base class to create a composite of GeoShapes.
GeoBaseDistanceShape	Distance shapes have capabilities of both geohashing and distance computation (which also includes point membership determination).
GeoBaseMembershipShape	Membership shapes have capabilities of both geohashing and membership determination.
GeoBasePath	GeoPaths have all the characteristics of GeoBaseDistanceShapes.
GeoBasePolygon	GeoBasePolygon objects are the base class of most GeoPolygon objects.
GeoBaseShape	Base extended shape object.
GeoBBox	All bounding box shapes have this interface in common.
GeoBBoxFactory	Factory for `GeoBBox`.
GeoBounds	Generic shape that supports bounds.
GeoCircle	Interface describing circular area with a center and radius.
GeoCircleFactory	Class which constructs a GeoCircle representing an arbitrary circle.
GeoComplexPolygon	GeoComplexPolygon objects are structures designed to handle very large numbers of edges.
GeoComplexPolygon.CountingEdgeIterator	Iterator execution interface, for tree traversal, plus count retrieval.
GeoComplexPolygon.Edge	An instance of this class describes a single edge, and includes what is necessary to reliably determine intersection in the context of the even/odd algorithm used.
GeoComplexPolygon.EdgeIterator	Iterator execution interface, for tree traversal.
GeoComplexPolygon.Node	An instance of this class represents a node in a tree.
GeoComplexPolygon.Tree	An interface describing a tree.
GeoComplexPolygon.XTree	This is the x-tree.
GeoComplexPolygon.YTree	This is the y-tree.
GeoComplexPolygon.ZTree	This is the z-tree.
GeoCompositeAreaShape	GeoCompositeAreaShape is a set of GeoAreaShape's, treated as a unit.
GeoCompositeMembershipShape	GeoCompositeMembershipShape is a set of GeoMembershipShape's, treated as a unit.
GeoCompositePolygon	GeoCompositePolygon is a specific implementation of GeoCompositeAreaShape, which implements GeoPolygon explicitly.
GeoConcavePolygon	GeoConcavePolygon objects are generic building blocks of more complex structures.
GeoConvexPolygon	GeoConvexPolygon objects are generic building blocks of more complex structures.
GeoDegenerateHorizontalLine	Degenerate bounding box limited on two sides (left lon, right lon).
GeoDegenerateLatitudeZone	This GeoBBox represents an area rectangle of one specific latitude with no longitude bounds.
GeoDegenerateLongitudeSlice	Degenerate longitude slice.
GeoDegeneratePath	GeoShape representing a path across the surface of the globe, with a specified half-width.
GeoDegeneratePath.PathSegment	This is the pre-calculated data for a path segment.
GeoDegeneratePath.SegmentEndpoint	This is precalculated data for segment endpoint.
GeoDegeneratePoint	This class represents a degenerate point bounding box.
GeoDegenerateVerticalLine	Degenerate bounding box limited on two sides (top lat, bottom lat).
GeoDistance	An implementer of this interface is capable of computing the described "distance" values, which are meant to provide both actual distance values, as well as distance estimates that can be computed more cheaply.
GeoDistanceShape	Distance shapes have capabilities of both geohashing and distance computation (which also includes point membership determination).
GeoEncodingUtils	reusable geopoint encoding methods
GeoEncodingUtils.Component2DPredicate	A predicate that checks whether a given point is within a component2D geometry.
GeoEncodingUtils.DistancePredicate	A predicate that checks whether a given point is within a distance of another point.
GeoEncodingUtils.Grid
GeoExactCircle	Circular area with a center and a radius that represents the surface distance to the center.
GeoExactCircle.ApproximationSlice	A temporary description of a section of circle.
GeoExactCircle.CircleSlice	A description of a section of circle.
GeoLatitudeZone	This GeoBBox represents an area rectangle limited only in latitude.
GeoLongitudeSlice	Bounding box limited on left and right.
GeoMembershipShape	Membership shapes have capabilities of both geohashing and membership determination.
Geometry	Base class for `LatLonGeometry` and `XYGeometry`
GeoNorthLatitudeZone	This GeoBBox represents an area rectangle limited only in south latitude.
GeoNorthRectangle	Bounding box limited on three sides (bottom lat, left lon, right lon), including the north pole.
GeoOutsideDistance	Implemented by Geo3D shapes that can compute the distance from a point to the closest outside edge.
GeoPath	Interface describing a path.
GeoPathFactory	Class which constructs a GeoPath representing an arbitrary path.
GeoPoint	This class represents a point on the surface of a sphere or ellipsoid.
GeoPointShape	Interface describing a GeoPointShape shape.It may represents a degenerated bounding box or a degenerated circle, hence it extends such interfaces.
GeoPointShapeFactory	Class which constructs a GeoPointShape.
GeoPolygon	GeoPolygon interface description.
GeoPolygonFactory	Class which constructs a GeoMembershipShape representing an arbitrary polygon.
GeoPolygonFactory.BestShape	Class for tracking the best shape for finding a pole, and whether or not the pole must be inside or outside of the shape.
GeoPolygonFactory.Edge	Class representing a single (unused) edge.
GeoPolygonFactory.EdgeBuffer	Class representing a pool of unused edges, all linked together by vertices.
GeoPolygonFactory.EdgeBufferIterator	Class representing an iterator over an EdgeBuffer.
GeoPolygonFactory.MutableBoolean
GeoPolygonFactory.PolygonDescription	Use this class to specify a polygon with associated holes.
GeoPolygonFactory.SafePath	An instance of this class represents a known-good path of nodes that contains no coplanar points , no matter how assessed.
GeoPolygonFactory.TileException	Exception we throw when we can't tile a polygon due to numerical precision issues.
GeoRectangle	Bounding box limited on four sides (top lat, bottom lat, left lon, right lon).
GeoS2Shape	Fast implementation of a polygon representing S2 geometry cell.
GeoS2ShapeFactory	Class which constructs a GeoPolygon representing S2 google pixel.
GeoShape	Generic shape.
GeoSizeable	Some shapes can compute radii of a geocircle in which they are inscribed.
GeoSouthLatitudeZone	This GeoBBox represents an area rectangle limited only in north latitude.
GeoSouthRectangle	Bounding box limited on three sides (top lat, left lon, right lon).
GeoStandardCircle	Circular area with a center and cutoff angle that represents the latitude and longitude distance from the center where the planet will be cut.
GeoStandardPath	GeoShape representing a path across the surface of the globe, with a specified half-width.
GeoStandardPath.BaseSegmentEndpoint	Base implementation of SegmentEndpoint
GeoStandardPath.CircleSegmentEndpoint	Endpoint that's a simple circle.
GeoStandardPath.CutoffDualCircleSegmentEndpoint	Endpoint that's a dual circle with cutoff(s).
GeoStandardPath.CutoffSingleCircleSegmentEndpoint	Endpoint that's a single circle with cutoff(s).
GeoStandardPath.DistancePair
GeoStandardPath.PathComponent	Path components consist of both path segments and segment endpoints.
GeoStandardPath.PathNode
GeoStandardPath.PathSegment	This is the pre-calculated data for a path segment.
GeoStandardPath.SegmentEndpoint	Internal interface describing segment endpoint implementations.
GeoStandardPath.TreeBuilder
GeoUtils	Basic reusable geo-spatial utility methods
GeoUtils.WindingOrder	used to define the orientation of 3 points -1 = Clockwise 0 = Colinear 1 = Counter-clockwise
GeoWideDegenerateHorizontalLine	Degenerate bounding box wider than PI and limited on two sides (left lon, right lon).
GeoWideLongitudeSlice	Bounding box wider than PI but limited on left and right sides ( left lon, right lon).
GeoWideNorthRectangle	Bounding box wider than PI but limited on three sides ( bottom lat, left lon, right lon).
GeoWideRectangle	Bounding box wider than PI but limited on four sides (top lat, bottom lat, left lon, right lon).
GeoWideSouthRectangle	Bounding box wider than PI but limited on three sides (top lat, left lon, right lon).
GeoWorld	Bounding box including the entire world.
German2Stemmer	This class implements the stemming algorithm defined by a snowball script.
GermanAnalyzer	`Analyzer` for German language.
GermanAnalyzer.DefaultSetHolder
GermanLightStemFilter	A `TokenFilter` that applies `GermanLightStemmer` to stem German words.
GermanLightStemFilterFactory	Factory for `GermanLightStemFilter`.
GermanLightStemmer	Light Stemmer for German.
GermanMinimalStemFilter	A `TokenFilter` that applies `GermanMinimalStemmer` to stem German words.
GermanMinimalStemFilterFactory	Factory for `GermanMinimalStemFilter`.
GermanMinimalStemmer	Minimal Stemmer for German.
GermanNormalizationFilter	Normalizes German characters according to the heuristics of the German2 snowball algorithm.
GermanNormalizationFilterFactory	Factory for `GermanNormalizationFilter`.
GermanStemFilter	A `TokenFilter` that stems German words.
GermanStemFilterFactory	Factory for `GermanStemFilter`.
GermanStemmer	A stemmer for German words.
GermanStemmer	This class implements the stemming algorithm defined by a snowball script.
GetTermInfo	Utility to get document frequency and total number of occurrences (sum of the tf for each doc) of a term.
GlobalOrdinalsCollector	A collector that collects all ordinals from a specified field matching the query.
GlobalOrdinalsQuery
GlobalOrdinalsQuery.OrdinalMapScorer
GlobalOrdinalsQuery.SegmentOrdinalScorer
GlobalOrdinalsWithScoreCollector
GlobalOrdinalsWithScoreCollector.Avg
GlobalOrdinalsWithScoreCollector.Max
GlobalOrdinalsWithScoreCollector.Min
GlobalOrdinalsWithScoreCollector.NoScore
GlobalOrdinalsWithScoreCollector.Occurrences
GlobalOrdinalsWithScoreCollector.Scores
GlobalOrdinalsWithScoreCollector.Sum
GlobalOrdinalsWithScoreQuery
GlobalOrdinalsWithScoreQuery.OrdinalMapScorer
GlobalOrdinalsWithScoreQuery.SegmentOrdinalScorer
GradientFormatter	Formats text with different color intensity depending on the score of the term.
GraphTokenFilter	An abstract TokenFilter that exposes its input stream as a graph
GraphTokenFilter.Token
GraphTokenStreamFiniteStrings	Consumes a TokenStream and creates an `Automaton` where the transition labels are terms from the `TermToBytesRefAttribute`.
GraphvizFormatter	Outputs the dot (graphviz) string for the viterbi lattice.
GraphvizFormatter	Outputs the dot (graphviz) string for the viterbi lattice.
GreekAnalyzer	`Analyzer` for the Greek language.
GreekAnalyzer.DefaultSetHolder
GreekLowerCaseFilter	Normalizes token text to lower case, removes some Greek diacritics, and standardizes final sigma to sigma.
GreekLowerCaseFilterFactory	Factory for `GreekLowerCaseFilter`.
GreekStemFilter	A `TokenFilter` that applies `GreekStemmer` to stem Greek words.
GreekStemFilterFactory	Factory for `GreekStemFilter`.
GreekStemmer	A stemmer for Greek words, according to: Development of a Stemmer for the Greek Language. Georgios Ntais
GreekStemmer	This class implements the stemming algorithm defined by a snowball script.
GroupDocs<T>	Represents one group in the results.
GroupFacetCollector	Base class for computing grouped facets.
GroupFacetCollector.FacetEntry	Represents a facet entry with a value and a count.
GroupFacetCollector.GroupedFacetResult	The grouped facet result.
GroupFacetCollector.SegmentResult	Contains the local grouped segment counts for a particular segment.
GroupFacetCollector.SegmentResultPriorityQueue
GroupingSearch	Convenience class to perform grouping in a non distributed environment.
GroupQueryNode	A `GroupQueryNode` represents a location where the original user typed real parenthesis on the query string.
GroupQueryNodeBuilder	Builds no object, it only returns the `Query` object set on the `GroupQueryNode` object using a `QueryTreeBuilder.QUERY_TREE_BUILDER_TAGID` tag.
GroupReducer<T,C extends Collector>	Concrete implementations of this class define what to collect for individual groups during the second-pass of a grouping search.
GroupReducer.GroupCollector<C extends Collector>
GroupSelector<T>	Defines a group, for use by grouping collectors
GroupSelector.State	What to do with the current value
GroupVIntUtil	This class contains utility methods and constants for group varint
GroupVIntUtil.IntReader	Provides an abstraction for read int values, so that decoding logic can be reused in different DataInput.
GrowableByteArrayDataOutput
GrowableWriter	Implements `PackedInts.Mutable`, but grows the bit count of the underlying packed ints on-demand.
HalfFloatPoint	An indexed `half-float` field for fast range filters.
HardlinkCopyDirectoryWrapper	This directory wrapper overrides `Directory.copyFrom(Directory, String, String, IOContext)` in order to optionally use a hard-link instead of a full byte by byte file copy if applicable.
HashContainers	Constants for primitive maps.
HashFunction	Base class for hashing functions that can be referred to by name.
HeapPointReader	Utility class to read buffered points from in-heap arrays.
HeapPointWriter	Utility class to write new points into in-heap arrays.
HeapPointWriter.HeapPointValue	Reusable implementation for a point value on-heap
HHMMSegmenter	Finds the optimal segmentation of a sentence into Chinese words
HighFreqTerms	`HighFreqTerms` class extracts the top n most frequent terms (by document frequency) from an existing Lucene index and reports their document frequency.
HighFreqTerms.DocFreqComparator	Compares terms by docTermFreq
HighFreqTerms.TermStatsQueue	Priority queue for TermStats objects
HighFreqTerms.TotalTermFreqComparator	Compares terms by totalTermFreq
HighFrequencyDictionary	HighFrequencyDictionary: terms taken from the given field of a Lucene index, which appear in a number of documents above a given threshold.
Highlighter	Marks up highlighted terms found in the best sections of text, using configurable `Fragmenter`, `Scorer`, `Formatter`, `Encoder` and tokenizers.
Highlighter.FragmentQueue
HighlightsMatch	QueryMatch object that contains the hit positions of a matching Query
HighlightsMatch.Hit	Represents an individual hit
HindiAnalyzer	Analyzer for Hindi.
HindiAnalyzer.DefaultSetHolder	Atomically loads the DEFAULT_STOP_SET in a lazy fashion once the outer class accesses the static final set the first time.;
HindiNormalizationFilter	A `TokenFilter` that applies `HindiNormalizer` to normalize the orthography.
HindiNormalizationFilterFactory	Factory for `HindiNormalizationFilter`.
HindiNormalizer	Normalizer for Hindi.
HindiStemFilter	A `TokenFilter` that applies `HindiStemmer` to stem Hindi words.
HindiStemFilterFactory	Factory for `HindiStemFilter`.
HindiStemmer	Light Stemmer for Hindi.
HindiStemmer	This class implements the stemming algorithm defined by a snowball script.
HitQueue	Expert: Priority queue containing hit docs
HitsThresholdChecker	Used for defining custom algorithms to allow searches to early terminate
HitsThresholdChecker.GlobalHitsThresholdChecker	Implementation of HitsThresholdChecker which allows global hit counting
HitsThresholdChecker.LocalHitsThresholdChecker	Default implementation of HitsThresholdChecker to be used for single threaded execution
HMMChineseTokenizer	Tokenizer for Chinese or mixed Chinese-English text.
HMMChineseTokenizerFactory	Factory for `HMMChineseTokenizer`
HnswBitVectorsFormat	Encodes bit vector values into an associated graph connecting the documents having values.
HnswBitVectorsFormat.FlatBitVectorsWriter
HnswBuilder	Interface for builder building the `OnHeapHnswGraph`
HnswConcurrentMergeBuilder	A graph builder that manages multiple workers, it only supports adding the whole graph all at once.
HnswConcurrentMergeBuilder.ConcurrentMergeWorker
HnswConcurrentMergeBuilder.MergeSearcher	This searcher will obtain the lock and make a copy of neighborArray when seeking the graph such that concurrent modification of the graph will not impact the search
HnswGraph	Hierarchical Navigable Small World graph.
HnswGraph.ArrayNodesIterator	NodesIterator that accepts nodes as an integer array.
HnswGraph.CollectionNodesIterator	Nodes iterator based on set representation of nodes.
HnswGraph.NodesIterator	Iterator over the graph nodes on a certain level, Iterator also provides the size – the total number of nodes to be iterated over.
HnswGraphBuilder	Builder for HNSW graph.
HnswGraphBuilder.GraphBuilderKnnCollector	A restricted, specialized knnCollector that can be used when building a graph.
HnswGraphMerger	Abstraction of merging multiple graphs into one on-heap graph
HnswGraphProvider	An interface that provides an HNSW graph.
HnswGraphSearcher	Searches an HNSW graph to find nearest neighbors to a query vector.
HnswGraphSearcher.OnHeapHnswGraphSearcher	This class allows `OnHeapHnswGraph` to be searched in a thread-safe manner by avoiding the unsafe methods (seek and nextNeighbor, which maintain state in the graph object) and instead maintaining the state in the searcher object.
HotspotVMOptions	Accessor to get Hotspot VM Options (if available).
HTMLStripCharFilter	A CharFilter that wraps another Reader and attempts to strip out HTML constructs.
HTMLStripCharFilter.TextSegment
HTMLStripCharFilterFactory	Factory for `HTMLStripCharFilter`.
HumanReadableQuery	A simple query wrapper for debug purposes.
HungarianAnalyzer	`Analyzer` for Hungarian.
HungarianAnalyzer.DefaultSetHolder	Atomically loads the DEFAULT_STOP_SET in a lazy fashion once the outer class accesses the static final set the first time.;
HungarianLightStemFilter	A `TokenFilter` that applies `HungarianLightStemmer` to stem Hungarian words.
HungarianLightStemFilterFactory	Factory for `HungarianLightStemFilter`.
HungarianLightStemmer	Light Stemmer for Hungarian.
HungarianStemmer	This class implements the stemming algorithm defined by a snowball script.
Hunspell	A spell checker based on Hunspell dictionaries.
HunspellStemFilter	TokenFilter that uses hunspell affix rules and words to stem tokens.
HunspellStemFilterFactory	TokenFilterFactory that creates instances of `HunspellStemFilter`.
Hyphen	This class represents a hyphen.
HyphenatedWordsFilter	When the plain text is extracted from documents, we will often have many words hyphenated and broken into two lines.
HyphenatedWordsFilterFactory	Factory for `HyphenatedWordsFilter`.
Hyphenation	This class represents a hyphenated word.
HyphenationCompoundWordTokenFilter	A `TokenFilter` that decomposes compound words found in many Germanic languages.
HyphenationCompoundWordTokenFilterFactory	Factory for `HyphenationCompoundWordTokenFilter`.
HyphenationTree	This tree structure stores the hyphenation patterns in an efficient way for fast lookup.
IBSimilarity	Provides a framework for the family of information-based models, as described in Stéphane Clinchant and Eric Gaussier.
ICUCollatedTermAttributeImpl	Extension of `CharTermAttributeImpl` that encodes the term text as a binary Unicode collation key instead of as UTF-8 bytes.
ICUCollationAttributeFactory	Converts each token into its `CollationKey`, and then encodes bytes as an index term.
ICUCollationDocValuesField	Indexes collation keys as a single-valued `SortedDocValuesField`.
ICUCollationKeyAnalyzer	Configures `KeywordTokenizer` with `ICUCollationAttributeFactory`.
ICUFoldingFilter	A TokenFilter that applies search term folding to Unicode text, applying foldings from UTR#30 Character Foldings.
ICUFoldingFilterFactory	Factory for `ICUFoldingFilter`.
ICUNormalizer2CharFilter	Normalize token text with ICU's `Normalizer2`.
ICUNormalizer2CharFilterFactory	Factory for `ICUNormalizer2CharFilter`
ICUNormalizer2Filter	Normalize token text with ICU's `Normalizer2`
ICUNormalizer2FilterFactory	Factory for `ICUNormalizer2Filter`
ICUTokenizer	Breaks text into words according to UAX #29: Unicode Text Segmentation (http://www.unicode.org/reports/tr29/)
ICUTokenizerConfig	Class that allows for tailored Unicode Text Segmentation on a per-writing system basis.
ICUTokenizerFactory	Factory for `ICUTokenizer`.
ICUTransformFilter	A `TokenFilter` that transforms text with ICU.
ICUTransformFilter.ReplaceableTermAttribute	Wrap a `CharTermAttribute` with the Replaceable API.
ICUTransformFilterFactory	Factory for `ICUTransformFilter`.
IdentityEncoder	Does nothing other than convert the char array to a byte array using the specified encoding.
IDFValueSource	Function that returns `#idf(long, long)` for every document.
IDVersionPostingsFormat	A PostingsFormat optimized for primary-key (ID) fields that also record a version (long) for each ID, delivered as a payload created by `IDVersionPostingsFormat.longToBytes(long, org.apache.lucene.util.BytesRef)` during indexing.
IDVersionPostingsReader
IDVersionPostingsWriter
IDVersionSegmentTermsEnum	Iterates through terms in this field; this class is public so users can cast it to call `IDVersionSegmentTermsEnum.seekExact(BytesRef, long)` for optimistic-concurrency, and also `IDVersionSegmentTermsEnum.getVersion()` to get the version of the currently seek'd term.
IDVersionSegmentTermsEnumFrame
IDVersionTermState
IfFunction	Depending on the boolean value of the `ifSource` function, returns the value of the `trueSource` or `falseSource` function.
IgnoreRandomChains	Annotation to not test a class or constructor with `TestRandomChains` integration test.
Impact	Per-document scoring factors.
Impacts	Information about upcoming impacts, ie.
ImpactsDISI	`DocIdSetIterator` that skips non-competitive docs thanks to the indexed impacts.
ImpactsEnum	Extension of `PostingsEnum` which also provides information about upcoming impacts.
ImpactsSource	Source of `Impacts`.
IncrementalHnswGraphMerger	This selects the biggest Hnsw graph from the provided merge state and initializes a new HnswGraphBuilder with that graph as a starting point.
Independence	Computes the measure of divergence from independence for DFI scoring functions.
IndependenceChiSquared	Normalized chi-squared measure of distance from independence
IndependenceSaturated	Saturated measure of distance from independence
IndependenceStandardized	Standardized measure of distance from independence
IndexableField	Represents a single field for indexing.
IndexableFieldType	Describes the properties of a field.
IndexCommit	Expert: represents a single commit into an index as seen by the `IndexDeletionPolicy` or `IndexReader`.
IndexDeletionPolicy	Expert: policy for deletion of stale `index commits`.
IndexDictionary	Immutable stateless index dictionary kept in RAM.
IndexDictionary.Browser	Stateful `IndexDictionary.Browser` to seek a term in this `IndexDictionary` and get its corresponding block file pointer in the block file.
IndexDictionary.BrowserSupplier	Supplier for a new stateful `IndexDictionary.Browser` created on the immutable `IndexDictionary`.
IndexDictionary.Builder	Builds an immutable `IndexDictionary`.
IndexedDISI	Disk-based implementation of a `DocIdSetIterator` which can return the index of the current document, i.e.
IndexedDISI	Disk-based implementation of a `DocIdSetIterator` which can return the index of the current document, i.e.
IndexedDISI	Disk-based implementation of a `DocIdSetIterator` which can return the index of the current document, i.e.
IndexedDISI.Method
IndexedDISI.Method
IndexedDISI.Method
IndexFileDeleter	This class keeps track of each SegmentInfos instance that is still "live", either because it corresponds to a segments_N file in the Directory (a "commit", i.e.
IndexFileDeleter.CommitPoint	Holds details for each commit point.
IndexFileNames	This class contains useful constants representing filenames and extensions used by lucene, as well as convenience methods for querying whether a file name matches an extension (`matchesExtension`), as well as generating file names from a segment name, generation and extension ( `fileNameFromGeneration`, `segmentFileName`).
IndexFormatTooNewException	This exception is thrown when Lucene detects an index that is newer than this Lucene version.
IndexFormatTooOldException	This exception is thrown when Lucene detects an index that is too old for this Lucene version
IndexingChain	Default general purpose indexing chain, which handles indexing all types of fields.
IndexingChain.FieldSchema	A schema of the field in the current document.
IndexingChain.IntBlockAllocator
IndexingChain.ReservedField<T extends IndexableField>
IndexInput	Abstract base class for input from a file in a `Directory`.
IndexMergeTool	Merges indices specified on the command line into the index specified as the first command line argument.
IndexMergeTool.Options
IndexNotFoundException	Signals that no index was found in the Directory.
IndexOptions	Controls how much information is stored in the postings lists.
IndexOrDocValuesQuery	A query that uses either an index structure (points or terms) or doc values in order to run a query, depending which one is more efficient.
IndexOutput	A `DataOutput` for appending data to a file in a `Directory`.
IndexPackageAccess	Access to `org.apache.lucene.index` package internals exposed to the test framework.
IndexPackageAccess.FieldInfosBuilder	Public type exposing `FieldInfo` internal builders.
IndexReader	IndexReader is an abstract class, providing an interface for accessing a point-in-time view of an index.
IndexReader.CacheHelper	A utility class that gives hooks in order to help build a cache based on the data that is contained in this index.
IndexReader.CacheKey	A cache key identifying a resource that is being cached on.
IndexReader.ClosedListener	A listener that is called when a resource gets closed.
IndexReaderContext	A struct like class that represents a hierarchical relationship between `IndexReader` instances.
IndexReaderFunctions	Class exposing static helper methods for generating DoubleValuesSource instances over some IndexReader statistics
IndexReaderFunctions.IndexReaderDoubleValuesSource
IndexReaderFunctions.NoCacheConstantDoubleValuesSource
IndexReaderFunctions.NoCacheConstantLongValuesSource
IndexReaderFunctions.ReaderFunction
IndexReaderFunctions.SumTotalTermFreqValuesSource
IndexReaderFunctions.TermFreqDoubleValuesSource
IndexRearranger	Copy and rearrange index according to document selectors, from input dir to output dir.
IndexRearranger.DocSelectorFilteredCodecReader
IndexRearranger.DocumentSelector	Select document within a CodecReader
IndexSearcher	Implements search over a single IndexReader.
IndexSearcher.CachingLeafSlicesSupplier	Supplier for `IndexSearcher.LeafSlice` slices which computes and caches the value on first invocation and returns cached value on subsequent invocation.
IndexSearcher.LeafSlice	A class holding a subset of the `IndexSearcher`s leaf contexts to be executed within a single thread.
IndexSearcher.TooManyClauses	Thrown when an attempt is made to add more than `IndexSearcher.TooManyClauses.getMaxClauseCount()` clauses.
IndexSearcher.TooManyNestedClauses	Thrown when a client attempts to execute a Query that has more than `IndexSearcher.TooManyClauses.getMaxClauseCount()` total clauses cumulatively in all of its children.
IndexSorter	Handles how documents should be sorted in an index, both within a segment and between segments.
IndexSorter.ComparableProvider	Used for sorting documents across segments
IndexSorter.DocComparator	A comparator of doc IDs, used for sorting documents within a segment
IndexSorter.DoubleSorter	Sorts documents based on double values from a NumericDocValues instance
IndexSorter.FloatSorter	Sorts documents based on float values from a NumericDocValues instance
IndexSorter.IntSorter	Sorts documents based on integer values from a NumericDocValues instance
IndexSorter.LongSorter	Sorts documents based on long values from a NumericDocValues instance
IndexSorter.NumericDocValuesProvider	Provide a NumericDocValues instance for a LeafReader
IndexSorter.SortedDocValuesProvider	Provide a SortedDocValues instance for a LeafReader
IndexSorter.StringSorter	Sorts documents based on terms from a SortedDocValues instance
IndexSortSortedNumericDocValuesRangeQuery	A range query that can take advantage of the fact that the index is sorted to speed up execution.
IndexSortSortedNumericDocValuesRangeQuery.BoundedDocIdSetIterator	A doc ID set iterator that wraps a delegate iterator and only returns doc IDs in the range [firstDocInclusive, lastDoc).
IndexSortSortedNumericDocValuesRangeQuery.IteratorAndCount	Provides a `DocIdSetIterator` along with an accurate count of documents provided by the iterator (or `-1` if an accurate count is unknown).
IndexSortSortedNumericDocValuesRangeQuery.ValueAndDoc
IndexSortSortedNumericDocValuesRangeQuery.ValueComparator	Compares the given document's value with a stored reference value.
IndexSplitter	Command-line tool that enables listing segments in an index, copying specific segments to another index, and deleting segments from an index.
IndexUpgrader	This is an easy-to-use tool that upgrades all segments of an index from previous Lucene versions to the current segment file format.
IndexWriter	An `IndexWriter` creates and maintains an index.
IndexWriter.DocModifier
IndexWriter.DocStats	DocStats for this index
IndexWriter.Event	Interface for internal atomic events.
IndexWriter.EventQueue
IndexWriter.IndexReaderWarmer	If `DirectoryReader.open(IndexWriter)` has been called (ie, this writer is in near real-time mode), then after a merge completes, this class can be invoked to warm the reader on the newly merged segment, before the merge commits.
IndexWriter.IndexWriterMergeSource
IndexWriterAccess	Access to `IndexWriter` internals exposed to the test framework.
IndexWriterConfig	Holds all the configuration that is used to create an `IndexWriter`.
IndexWriterConfig.OpenMode	Specifies the open mode for `IndexWriter`.
IndexWriterEventListener	A callback event listener for recording key events happened inside IndexWriter
IndicNormalizationFilter	A `TokenFilter` that applies `IndicNormalizer` to normalize text in Indian Languages.
IndicNormalizationFilterFactory	Factory for `IndicNormalizationFilter`.
IndicNormalizer	Normalizes the Unicode representation of text in Indian languages.
IndicNormalizer.ScriptData
IndonesianAnalyzer	Analyzer for Indonesian (Bahasa)
IndonesianAnalyzer.DefaultSetHolder	Atomically loads the DEFAULT_STOP_SET in a lazy fashion once the outer class accesses the static final set the first time.;
IndonesianStemFilter	A `TokenFilter` that applies `IndonesianStemmer` to stem Indonesian words.
IndonesianStemFilterFactory	Factory for `IndonesianStemFilter`.
IndonesianStemmer	Stemmer for Indonesian.
IndonesianStemmer	This class implements the stemming algorithm defined by a snowball script.
IndriAndQuery	A Query that matches documents matching combinations of subqueries.
IndriAndScorer	Combines scores of subscorers.
IndriAndWeight	The Weight for IndriAndQuery, used to normalize, score and explain these queries.
IndriDirichletSimilarity	Bayesian smoothing using Dirichlet priors as implemented in the Indri Search engine (http://www.lemurproject.org/indri.php).
IndriDirichletSimilarity.IndriCollectionModel	Models `p(w\|C)` as the number of occurrences of the term in the collection, divided by the total number of tokens `+ 1`.
IndriDisjunctionScorer	The Indri implemenation of a disjunction scorer which stores the subscorers for the child queries.
IndriQuery	A Basic abstract query that all IndriQueries can extend to implement toString, equals, getClauses, and iterator.
IndriScorer	The Indri parent scorer that stores the boost so that IndriScorers can use the boost outside of the term.
InetAddressPoint	An indexed 128-bit `InetAddress` field.
InetAddressRange	An indexed InetAddress Range Field
InflectionAttribute	Attribute for Kuromoji inflection data.
InflectionAttributeImpl	Attribute for Kuromoji inflection data.
InfoStream	Debugging API for Lucene classes such as `IndexWriter` and `SegmentInfos`.
InfoStream.NoOutput
InitializedHnswGraphBuilder	This creates a graph builder that is initialized with the provided HnswGraph.
InMemorySorter	An `BytesRefSorter` that keeps all the entries in memory.
InPlaceMergeSorter	`Sorter` implementation based on the merge-sort algorithm that merges in place (no extra memory will be allocated).
InputIterator	Interface for enumerating term,weight,payload triples for suggester consumption; currently only `AnalyzingSuggester`, `FuzzySuggester` and `AnalyzingInfixSuggester` support payloads.
InputIterator.InputIteratorWrapper	Wraps a BytesRefIterator as a suggester InputIterator, with all weights set to `1` and carries no payload
InputStreamDataInput	A `DataInput` wrapping a plain `InputStream`.
IntArrayDocIdSet
IntArrayDocIdSet.IntArrayDocIdSetIterator
IntArrayList	An array-backed list of `int`.
IntArrayList.ValueIterator	An iterator implementation for `IntArrayList.iterator()`.
IntBlockPool	A pool for int blocks similar to `ByteBlockPool`
IntBlockPool.Allocator	Abstract class for allocating and freeing int blocks.
IntBlockPool.DirectAllocator	A simple `IntBlockPool.Allocator` that never recycles.
IntComparator	Comparator based on `Integer.compare(int, int)` for `numHits`.
IntCursor	Forked from HPPC, holding int index and int value.
IntDocValues	Abstract `FunctionValues` implementation which supports retrieving int values.
IntDoubleHashMap	A hash map of `int` to `double`, implemented using open addressing with linear probing for collision resolution.
IntDoubleHashMap.IntDoubleCursor	Forked from HPPC, holding int index,key and value
IntegerEncoder	Encode a character array Integer as a `BytesRef`.
IntersectBlockReader	The "intersect" `TermsEnum` response to `UniformSplitTerms.intersect(CompiledAutomaton, BytesRef)`, intersecting the terms with an automaton.
IntersectBlockReader.BlockIteration	Block iteration order.
IntersectTermsEnum	This is used to implement efficient `Terms.intersect(org.apache.lucene.util.automaton.CompiledAutomaton, org.apache.lucene.util.BytesRef)` for block-tree.
IntersectTermsEnum	This is used to implement efficient `Terms.intersect(org.apache.lucene.util.automaton.CompiledAutomaton, org.apache.lucene.util.BytesRef)` for block-tree.
IntersectTermsEnum.NoMoreTermsException
IntersectTermsEnum.NoMoreTermsException
IntersectTermsEnumFrame
IntersectTermsEnumFrame
IntervalBuilder	Constructs an `IntervalsSource` based on analyzed text.
IntervalFilter	Wraps an `IntervalIterator` and passes through those intervals that match the `IntervalFilter.accept()` function
IntervalFunction	Representation of an interval function that can be converted to `IntervalsSource`.
IntervalIterator	A `DocIdSetIterator` that also allows iteration over matching intervals in a document.
IntervalMatches
IntervalMatches.State
IntervalMatchesIterator	An extension of MatchesIterator that allows it to be treated as an IntervalIterator
IntervalQuery	A query that retrieves documents containing intervals returned from an `IntervalsSource`
IntervalQueryNode	Node that represents an interval function.
IntervalQueryNodeBuilder	Builds a `Query` from an `IntervalQueryNode`.
IntervalQueryNodeProcessor	This processor makes sure that `StandardQueryConfigHandler.ConfigurationKeys.ANALYZER` is defined in the `QueryConfigHandler` and injects this analyzer into `IntervalQueryNode`s.
Intervals	Factory functions for creating `interval sources`.
IntervalScoreFunction
IntervalScoreFunction.SaturationFunction
IntervalScoreFunction.SigmoidFunction
IntervalScorer
IntervalsSource	A helper class for `IntervalQuery` that provides an `IntervalIterator` for a given field and segment
IntField	Field that stores a per-document `int` value for scoring, sorting or value retrieval and index the field for fast range filters.
IntFieldSource	Obtains int field values from `LeafReader.getNumericDocValues(java.lang.String)` and makes those values available as other numeric types, casting as needed.
IntFloatHashMap	A hash map of `int` to `float`, implemented using open addressing with linear probing for collision resolution.
IntFloatHashMap.IntFloatCursor	Forked from HPPC, holding int index,key and value
IntHashSet	A hash set of `int`s, implemented using open addressing with linear probing for collision resolution.
IntIntHashMap	A hash map of `int` to `int`, implemented using open addressing with linear probing for collision resolution.
IntIntHashMap.IntIntCursor	Forked from HPPC, holding int index,key and value
IntObjectHashMap<VType>	A hash map of `int` to `Object`, implemented using open addressing with linear probing for collision resolution.
IntObjectHashMap.IntObjectCursor<VType>	Forked from HPPC, holding int index,key and value
IntPoint	An indexed `int` field for fast range filters.
IntPointMultiRangeBuilder	Builder for multi range queries for IntPoints
IntRange	An indexed Integer Range field.
IntRangeDocValuesField	DocValues field for IntRange.
IntRangeSlowRangeQuery
IntroSelector	Adaptive selection algorithm based on the introspective quick select algorithm.
IntroSorter	`Sorter` implementation based on a variant of the quicksort algorithm called introsort: when the recursion level exceeds the log of the length of the array to sort, it falls back to heapsort.
IntSequenceOutputs	An FST `Outputs` implementation where each output is a sequence of ints.
IntSet
IntsRef	Represents int[], as a slice (offset + length) into an existing int[].
IntsRefBuilder	A builder for `IntsRef` instances.
IntsRefFSTEnum<T>	Enumerates all input (IntsRef) + output pairs in an FST.
IntsRefFSTEnum.InputOutput<T>	Holds a single input (IntsRef) + output pair.
IntToIntFunction	Native int to int function
InvalidTokenOffsetsException	Exception thrown if TokenStream Tokens are incompatible with provided text
InvertableType	Describes how an `IndexableField` should be inverted for indexing terms and postings.
IOConsumer<T>	An IO operation with a single input that may throw an IOException.
IOContext	IOContext holds additional details on the merge/search context.
IOContext.Context	Context is a enumerator which specifies the context in which the Directory is being used for.
IOFunction<T,R>	A Function that may throw an IOException
IORunnable	A Runnable that may throw an IOException
IOSupplier<T>	This is a result supplier that is allowed to throw an IOException.
IOUtils	Utilities for dealing with `Closeable`s.
IOUtils.IOConsumer<T>	Deprecated, for removal: This API element is subject to removal in a future version. was replaced by `IOConsumer`.
IOUtils.IOFunction<T,R>	Deprecated, for removal: This API element is subject to removal in a future version. was replaced by `IOFunction`.
IrishAnalyzer	`Analyzer` for Irish.
IrishAnalyzer.DefaultSetHolder	Atomically loads the DEFAULT_STOP_SET in a lazy fashion once the outer class accesses the static final set the first time.;
IrishLowerCaseFilter	Normalises token text to lower case, handling t-prothesis and n-eclipsis (i.e., that 'nAthair' should become 'n-athair')
IrishLowerCaseFilterFactory	Factory for `IrishLowerCaseFilter`.
IrishStemmer	This class implements the stemming algorithm defined by a snowball script.
ISO8859_14Decoder
ItalianAnalyzer	`Analyzer` for Italian.
ItalianAnalyzer.DefaultSetHolder	Atomically loads the DEFAULT_STOP_SET in a lazy fashion once the outer class accesses the static final set the first time.;
ItalianLightStemFilter	A `TokenFilter` that applies `ItalianLightStemmer` to stem Italian words.
ItalianLightStemFilterFactory	Factory for `ItalianLightStemFilter`.
ItalianLightStemmer	Light Stemmer for Italian.
ItalianStemmer	This class implements the stemming algorithm defined by a snowball script.
JapaneseAnalyzer	Analyzer for Japanese that uses morphological analysis.
JapaneseAnalyzer.DefaultSetHolder	Atomically loads DEFAULT_STOP_SET, DEFAULT_STOP_TAGS in a lazy fashion once the outer class accesses the static final set the first time.
JapaneseBaseFormFilter	Replaces term text with the `BaseFormAttribute`.
JapaneseBaseFormFilterFactory	Factory for `JapaneseBaseFormFilter`.
JapaneseCompletionAnalyzer	Analyzer for Japanese completion suggester.
JapaneseCompletionFilter	A `TokenFilter` that adds Japanese romanized tokens to the term attribute.
JapaneseCompletionFilter.CompletionToken
JapaneseCompletionFilter.CompletionTokenGenerator
JapaneseCompletionFilter.Mode	Completion mode
JapaneseCompletionFilterFactory	Factory for `JapaneseCompletionFilter`.
JapaneseFilterUtil	Utility methods for Japanese filters.
JapaneseHiraganaUppercaseFilter	A `TokenFilter` that normalizes small letters (捨て仮名) in hiragana into normal letters.
JapaneseHiraganaUppercaseFilterFactory	Factory for `JapaneseHiraganaUppercaseFilter`.
JapaneseIterationMarkCharFilter	Normalizes Japanese horizontal iteration marks (odoriji) to their expanded form.
JapaneseIterationMarkCharFilterFactory	Factory for `JapaneseIterationMarkCharFilter`.
JapaneseKatakanaStemFilter	A `TokenFilter` that normalizes common katakana spelling variations ending in a long sound character by removing this character (U+30FC).
JapaneseKatakanaStemFilterFactory	Factory for `JapaneseKatakanaStemFilter`.
JapaneseKatakanaUppercaseFilter	A `TokenFilter` that normalizes small letters (捨て仮名) in katakana into normal letters.
JapaneseKatakanaUppercaseFilterFactory	Factory for `JapaneseKatakanaUppercaseFilter`.
JapaneseNumberFilter	A `TokenFilter` that normalizes Japanese numbers (kansūji) to regular Arabic decimal numbers in half-width characters.
JapaneseNumberFilter.NumberBuffer	Buffer that holds a Japanese number string and a position index used as a parsed-to marker
JapaneseNumberFilterFactory	Factory for `JapaneseNumberFilter`.
JapanesePartOfSpeechStopFilter	Removes tokens that match a set of part-of-speech tags.
JapanesePartOfSpeechStopFilterFactory	Factory for `JapanesePartOfSpeechStopFilter`.
JapaneseReadingFormFilter	A `TokenFilter` that replaces the term attribute with the reading of a token in either katakana or romaji form.
JapaneseReadingFormFilterFactory	Factory for `JapaneseReadingFormFilter`.
JapaneseTokenizer	Tokenizer for Japanese that uses morphological analysis.
JapaneseTokenizer.Lattice
JapaneseTokenizer.Mode	Tokenization mode: this determines how the tokenizer handles compound and unknown words.
JapaneseTokenizer.Position
JapaneseTokenizer.Type	Token type reflecting the original source of this token
JapaneseTokenizer.WrappedPositionArray
JapaneseTokenizerFactory	Factory for `JapaneseTokenizer`.
JaroWinklerDistance	Similarity measure for short strings such as person names.
JavaLoggingInfoStream	InfoStream implementation that logs every message using Java Utils Logging (JUL) with the supplied log level.
JavascriptBaseVisitor<T>	This class provides an empty implementation of `JavascriptVisitor`, which can be extended to create a visitor which only needs to handle a subset of the available methods.
JavascriptCompiler	An expression compiler for javascript expressions.
JavascriptCompiler.Loader
JavascriptErrorHandlingLexer	Overrides the ANTLR 4 generated JavascriptLexer to allow for proper error handling
JavascriptLexer
JavascriptParser
JavascriptParser.AddsubContext
JavascriptParser.BoolandContext
JavascriptParser.BoolcompContext
JavascriptParser.BooleqneContext
JavascriptParser.BoolorContext
JavascriptParser.BwandContext
JavascriptParser.BworContext
JavascriptParser.BwshiftContext
JavascriptParser.BwxorContext
JavascriptParser.CompileContext
JavascriptParser.ConditionalContext
JavascriptParser.ExpressionContext
JavascriptParser.ExternalContext
JavascriptParser.MuldivContext
JavascriptParser.NumericContext
JavascriptParser.PrecedenceContext
JavascriptParser.UnaryContext
JavascriptParserErrorStrategy	Allows for proper error handling in the ANTLR 4 parser
JavascriptVisitor<T>	This interface defines a complete generic visitor for a parse tree produced by `JavascriptParser`.
JoinDocFreqValueSource	Use a field value and find the Document Frequency within another field.
JoinUtil	Utility for query time joining.
JoinUtil.LongFloatFunction	Similar to `LongFunction` for primitive argument and result.
JoinUtil.LongFloatProcedure	Similar to `BiConsumer` for primitive arguments.
KatakanaRomanizer	Converts a Katakana string to Romaji using the pre-defined Katakana-Romaji mapping rules.
KatakanaRomanizer.MatchedKeystroke
KeepOnlyLastCommitDeletionPolicy	This `IndexDeletionPolicy` implementation that keeps only the most recent commit and immediately removes all prior commits after a new commit is done.
KeepWordFilter	A TokenFilter that only keeps tokens with text contained in the required words.
KeepWordFilterFactory	Factory for `KeepWordFilter`.
KeywordAnalyzer	"Tokenizes" the entire stream as a single token.
KeywordAttribute	This attribute can be used to mark a token as a keyword.
KeywordAttributeImpl	Default implementation of `KeywordAttribute`.
KeywordField	Field that indexes a per-document String or `BytesRef` into an inverted index for fast filtering, stores values in a columnar fashion using `DocValuesType.SORTED_SET` doc values for sorting and faceting, and optionally stores values as stored fields for top-hits retrieval.
KeywordMarkerFilter	Marks terms as keywords via the `KeywordAttribute`.
KeywordMarkerFilterFactory	Factory for `KeywordMarkerFilter`.
KeywordRepeatFilter	This TokenFilter emits each incoming token twice once as keyword and once non-keyword, in other words once with `KeywordAttribute.setKeyword(boolean)` set to `true` and once set to `false`.
KeywordRepeatFilterFactory	Factory for `KeywordRepeatFilter`.
KeywordTokenizer	Emits the entire input as a single token.
KeywordTokenizerFactory	Factory for `KeywordTokenizer`.
KNearestFuzzyClassifier	A k-Nearest Neighbor classifier based on `NearestFuzzyQuery`.
KNearestNeighborClassifier	A k-Nearest Neighbor classifier (see `http://en.wikipedia.org/wiki/K-nearest_neighbors`) based on `MoreLikeThis`
KNearestNeighborDocumentClassifier	A k-Nearest Neighbor Document classifier (see `http://en.wikipedia.org/wiki/K-nearest_neighbors`) based on `MoreLikeThis` .
KnnByteVectorField	A field that contains a single byte numeric vector (or none) for each document.
KnnByteVectorQuery	Uses `KnnVectorsReader.search(String, byte[], KnnCollector, Bits)` to perform nearest neighbour search.
KnnCollector	KnnCollector is a knn collector used for gathering kNN results and providing topDocs from the gathered neighbors
KnnCollectorManager	KnnCollectorManager responsible for creating `KnnCollector` instances.
KnnFieldVectorsWriter<T>	Vectors' writer for a field
KnnFloatVectorField	A field that contains a single floating-point numeric vector (or none) for each document.
KnnFloatVectorQuery	Uses `KnnVectorsReader.search(String, float[], KnnCollector, Bits)` to perform nearest neighbour search.
KnnVectorField	Deprecated. use `KnnFloatVectorField` instead
KnnVectorFieldExistsQuery	Deprecated. Use `FieldExistsQuery` instead.
KnnVectorQuery	Deprecated. use `KnnFloatVectorQuery` instead
KnnVectorsFormat	Encodes/decodes per-document vector and any associated indexing structures required to support nearest-neighbor search
KnnVectorsFormat.Holder	This static holder class prevents classloading deadlock by delaying init of doc values formats until needed.
KnnVectorsReader	Reads vectors from an index.
KnnVectorsWriter	Writes vectors to an index.
KnnVectorsWriter.ByteVectorValuesSub
KnnVectorsWriter.MergedVectorValues	View over multiple vector values supporting iterator-style access via DocIdMerger.
KnnVectorsWriter.MergedVectorValues.MergedByteVectorValues
KnnVectorsWriter.MergedVectorValues.MergedFloat32VectorValues
KnnVectorsWriter.VectorValuesSub	Tracks state of one sub-reader that we are merging
KoreanAnalyzer	Analyzer for Korean that uses morphological analysis.
KoreanNumberFilter	A `TokenFilter` that normalizes Korean numbers to regular Arabic decimal numbers in half-width characters.
KoreanNumberFilter.NumberBuffer	Buffer that holds a Korean number string and a position index used as a parsed-to marker
KoreanNumberFilterFactory	Factory for `KoreanNumberFilter`.
KoreanPartOfSpeechStopFilter	Removes tokens that match a set of part-of-speech tags.
KoreanPartOfSpeechStopFilterFactory	Factory for `KoreanPartOfSpeechStopFilter`.
KoreanReadingFormFilter	Replaces term text with the `ReadingAttribute` which is the Hangul transcription of Hanja characters.
KoreanReadingFormFilterFactory	Factory for `KoreanReadingFormFilter`.
KoreanTokenizer	Tokenizer for Korean that uses morphological analysis.
KoreanTokenizer.DecompoundMode	Decompound mode: this determines how the tokenizer handles `POS.Type.COMPOUND`, `POS.Type.INFLECT` and `POS.Type.PREANALYSIS` tokens.
KoreanTokenizer.Position
KoreanTokenizer.Type	Token type reflecting the original source of this token
KoreanTokenizer.WrappedPositionArray
KoreanTokenizerFactory	Factory for `KoreanTokenizer`.
KpStemmer	This class implements the stemming algorithm defined by a snowball script.
KStemData1	A list of words used by Kstem
KStemData2	A list of words used by Kstem
KStemData3	A list of words used by Kstem
KStemData4	A list of words used by Kstem
KStemData5	A list of words used by Kstem
KStemData6	A list of words used by Kstem
KStemData7	A list of words used by Kstem
KStemData8	A list of words used by Kstem
KStemFilter	A high-performance kstem filter for english.
KStemFilterFactory	Factory for `KStemFilter`.
KStemmer	This class implements the Kstem algorithm
KStemmer.DictEntry
LabelledCharArrayMatcher	Associates a label with a CharArrayMatcher to distinguish different sources for terms in highlighting
Lambda	The lambda (λ_w) parameter in information-based models.
LambdaDF	Computes lambda as `docFreq+1 / numberOfDocuments+1`.
LambdaTTF	Computes lambda as `totalTermFreq+1 / numberOfDocuments+1`.
LargeNumHitsTopDocsCollector	Optimized collector for large number of hits.
LatLonBoundingBox	An indexed 2-Dimension Bounding Box field for the Geospatial Lat/Lon Coordinate system
LatLonBounds	An object for accumulating latitude/longitude bounds information.
LatLonDocValuesBoxQuery	Distance query for `LatLonDocValuesField`.
LatLonDocValuesField	An per-document location field.
LatLonDocValuesQuery	Finds all previously indexed geo points that comply the given `ShapeField.QueryRelation` with the specified array of `LatLonGeometry`.
LatLonGeometry	Lat/Lon Geometry object.
LatLonPoint	An indexed location field.
LatLonPointDistanceComparator	Compares documents by distance from an origin point
LatLonPointDistanceFeatureQuery
LatLonPointDistanceQuery	Distance query for `LatLonPoint`.
LatLonPointPrototypeQueries	Holder class for prototype sandboxed queries
LatLonPointQuery	Finds all previously indexed geo points that comply the given `ShapeField.QueryRelation` with the specified array of `LatLonGeometry`.
LatLonPointSortField	Sorts by distance from an origin location.
LatLonShape	An geo shape utility class for indexing and searching gis geometries whose vertices are latitude, longitude values (in decimal degrees).
LatLonShapeBoundingBoxQuery	Finds all previously indexed geo shapes that intersect the specified bounding box.
LatLonShapeBoundingBoxQuery.EncodedLatLonRectangle	Holds spatial logic for a bounding box that works in the encoded space
LatLonShapeDocValues	A concrete implementation of `ShapeDocValues` for storing binary doc value representation of `LatLonShape` geometries in a `LatLonShapeDocValuesField`
LatLonShapeDocValuesField	Concrete implementation of a `ShapeDocValuesField` for geographic geometries.
LatLonShapeDocValuesQuery	Bounding Box query for `ShapeDocValuesField` representing `XYShape`
LatLonShapeQuery	Finds all previously indexed geo shapes that comply the given `ShapeField.QueryRelation` with the specified array of `LatLonGeometry`.
LatvianAnalyzer	`Analyzer` for Latvian.
LatvianAnalyzer.DefaultSetHolder	Atomically loads the DEFAULT_STOP_SET in a lazy fashion once the outer class accesses the static final set the first time.;
LatvianStemFilter	A `TokenFilter` that applies `LatvianStemmer` to stem Latvian words.
LatvianStemFilterFactory	Factory for `LatvianStemFilter`.
LatvianStemmer	Light stemmer for Latvian.
LatvianStemmer.Affix
LazyDocument	Defers actually loading a field's value until you ask for it.
LeafCollector	Collector decouples the score from the collected doc: the score computation is skipped entirely if it's not needed.
LeafFieldComparator	Expert: comparator that gets instantiated on each leaf from a top-level `FieldComparator` instance.
LeafMetaData	Provides read-only metadata about a leaf.
LeafReader	`LeafReader` is an abstract class, providing an interface for accessing an index.
LeafReaderContext	`IndexReaderContext` for `LeafReader` instances.
LeafSimScorer	`Similarity.SimScorer` on a specific `LeafReader`.
LegacyDirectMonotonicReader	Retrieves an instance previously written by `LegacyDirectMonotonicWriter`.
LegacyDirectMonotonicReader.Meta	In-memory metadata that needs to be kept around for `LegacyDirectMonotonicReader` to read data from disk.
LegacyDirectMonotonicWriter	Write monotonically-increasing sequences of integers.
LegacyDirectReader	Retrieves an instance previously written by `LegacyDirectWriter`
LegacyDirectReader.DirectPackedReader1
LegacyDirectReader.DirectPackedReader12
LegacyDirectReader.DirectPackedReader16
LegacyDirectReader.DirectPackedReader2
LegacyDirectReader.DirectPackedReader20
LegacyDirectReader.DirectPackedReader24
LegacyDirectReader.DirectPackedReader28
LegacyDirectReader.DirectPackedReader32
LegacyDirectReader.DirectPackedReader4
LegacyDirectReader.DirectPackedReader40
LegacyDirectReader.DirectPackedReader48
LegacyDirectReader.DirectPackedReader56
LegacyDirectReader.DirectPackedReader64
LegacyDirectReader.DirectPackedReader8
LegacyDirectWriter	Class for writing packed integers to be directly read from Directory.
LegacyFieldsIndexReader
LegacyPacked64	Immutable version of `Packed64` which is constructed from am existing `DataInput`.
LegacyPacked64SingleBlock	This class is similar to `LegacyPacked64` except that it trades space for speed by ensuring that a single block needs to be read/written in order to read/write a value.
LegacyPacked64SingleBlock.Packed64SingleBlock1
LegacyPacked64SingleBlock.Packed64SingleBlock10
LegacyPacked64SingleBlock.Packed64SingleBlock12
LegacyPacked64SingleBlock.Packed64SingleBlock16
LegacyPacked64SingleBlock.Packed64SingleBlock2
LegacyPacked64SingleBlock.Packed64SingleBlock21
LegacyPacked64SingleBlock.Packed64SingleBlock3
LegacyPacked64SingleBlock.Packed64SingleBlock32
LegacyPacked64SingleBlock.Packed64SingleBlock4
LegacyPacked64SingleBlock.Packed64SingleBlock5
LegacyPacked64SingleBlock.Packed64SingleBlock6
LegacyPacked64SingleBlock.Packed64SingleBlock7
LegacyPacked64SingleBlock.Packed64SingleBlock8
LegacyPacked64SingleBlock.Packed64SingleBlock9
LegacyPackedInts	Legacy PackedInts operations.
LengthFilter	Removes words that are too long or too short from the stream.
LengthFilterFactory	Factory for `LengthFilter`.
LengthGoalBreakIterator	Wraps another `BreakIterator` to skip past breaks that would result in passages that are too short.
LetterTokenizer	A LetterTokenizer is a tokenizer that divides text at non-letters.
LetterTokenizerFactory	Factory for `LetterTokenizer`.
Lev1ParametricDescription	Parametric description for generating a Levenshtein automaton of degree 1.
Lev1TParametricDescription	Parametric description for generating a Levenshtein automaton of degree 1, with transpositions as primitive edits.
Lev2ParametricDescription	Parametric description for generating a Levenshtein automaton of degree 2.
Lev2TParametricDescription	Parametric description for generating a Levenshtein automaton of degree 2, with transpositions as primitive edits.
LevenshteinAutomata	Class to construct DFAs that match a word within some edit distance.
LevenshteinAutomata.ParametricDescription	A ParametricDescription describes the structure of a Levenshtein DFA for some degree n.
LevenshteinDistance	Levenshtein edit distance class.
Lift	The Lift class is a data structure that is a variation of a Patricia trie.
LikeThisQueryBuilder	Builder for `MoreLikeThisQuery`
LimitedFiniteStringsIterator	`FiniteStringsIterator` which limits the number of iterated accepted strings.
LimitTokenCountAnalyzer	This Analyzer limits the number of tokens while indexing.
LimitTokenCountFilter	This TokenFilter limits the number of tokens while indexing.
LimitTokenCountFilterFactory	Factory for `LimitTokenCountFilter`.
LimitTokenOffsetFilter	Lets all tokens pass through until it sees one with a start offset <= a configured limit, which won't pass and ends the stream.
LimitTokenOffsetFilter	This is a simplified version of org.apache.lucene.analysis.miscellaneous.LimitTokenOffsetFilter to prevent a dependency on analysis-common.jar.
LimitTokenOffsetFilterFactory	Factory for `LimitTokenOffsetFilter`.
LimitTokenPositionFilter	This TokenFilter limits its emitted tokens to those with positions that are not greater than the configured limit.
LimitTokenPositionFilterFactory	Factory for `LimitTokenPositionFilter`.
Line	Represents a line on the earth's surface.
Line2D	2D geo line implementation represented as a balanced interval tree of edges.
LinearDistance	Linear distance computation style.
LinearFloatFunction	`LinearFloatFunction` implements a linear function over another `ValueSource`.
LinearSquaredDistance	Linear squared distance computation style.
ListOfOutputs<T>	Wraps another Outputs implementation and encodes one or more of its output values.
LiteralValueSource	Pass a the field value through as a String, no matter the type // Q: doesn't this mean it's a "string"?
LithuanianAnalyzer	`Analyzer` for Lithuanian.
LithuanianAnalyzer.DefaultSetHolder	Atomically loads the DEFAULT_STOP_SET in a lazy fashion once the outer class accesses the static final set the first time.;
LithuanianStemmer	This class implements the stemming algorithm defined by a snowball script.
LiveDocsFormat	Format for live/deleted documents
LiveFieldValues<S,T>	Tracks live field values across NRT reader reopens.
LiveIndexWriterConfig	Holds all the configuration used by `IndexWriter` with few setters for settings that can be changed on an `IndexWriter` instance "live".
LMDirichletSimilarity	Bayesian smoothing using Dirichlet priors.
LMJelinekMercerSimilarity	Language model based on the Jelinek-Mercer smoothing method.
LMSimilarity	Abstract superclass for language modeling Similarities.
LMSimilarity.CollectionModel	A strategy for computing the collection language model.
LMSimilarity.DefaultCollectionModel	Models `p(w\|C)` as the number of occurrences of the term in the collection, divided by the total number of tokens `+ 1`.
LMSimilarity.LMStats	Stores the collection distribution of the current term.
Lock	An interprocess mutex lock.
LockableConcurrentApproximatePriorityQueue<T extends java.util.concurrent.locks.Lock>	A `ConcurrentApproximatePriorityQueue` of `Lock` objects.
LockFactory	Base class for Locking implementation.
LockObtainFailedException	This exception is thrown when the `write.lock` could not be acquired.
LockReleaseFailedException	This exception is thrown when the `write.lock` could not be released.
LockStressTest	Simple standalone tool that forever acquires and releases a lock using a specific `LockFactory`.
LockValidatingDirectoryWrapper	This class makes a best-effort check that a provided `Lock` is valid before any destructive filesystem operation.
LockVerifyServer	Simple standalone server that must be running when you use `VerifyingLockFactory`.
LogByteSizeMergePolicy	This is a `LogMergePolicy` that measures size of a segment as the total byte size of the segment's files.
LogDocMergePolicy	This is a `LogMergePolicy` that measures size of a segment as the number of documents (not taking deletions into account).
LogMergePolicy	This class implements a `MergePolicy` that tries to merge segments into levels of exponentially increasing size, where each level has fewer segments than the value of the merge factor.
LogMergePolicy.SegmentInfoAndLevel
LongArrayList	An array-backed list of `long`.
LongArrayList.ValueIterator	An iterator implementation for `LongArrayList.iterator()`.
LongBitSet	BitSet of fixed length (numBits), backed by accessible (`LongBitSet.getBits()`) long[], accessed with a long index.
LongComparator	Comparator based on `Long.compare(long, long)` for `numHits`.
LongCursor	Forked from HPPC, holding int index and long value.
LongDistanceFeatureQuery
LongDocValues	Abstract `FunctionValues` implementation which supports retrieving long values.
LongField	Field that stores a per-document `long` value for scoring, sorting or value retrieval and index the field for fast range filters.
LongFieldSource	Obtains long field values from `LeafReader.getNumericDocValues(java.lang.String)` and makes those values available as other numeric types, casting as needed.
LongFloatHashMap	A hash map of `long` to `float`, implemented using open addressing with linear probing for collision resolution.
LongFloatHashMap.LongFloatCursor	Forked from HPPC, holding int index,key and value
LongHashSet	A hash set of `long`s, implemented using open addressing with linear probing for collision resolution.
LongHeap	A min heap that stores longs; a primitive priority queue that like all priority queues maintains a partial ordering of its elements such that the least element can always be found in constant time.
LongIntHashMap	A hash map of `long` to `int`, implemented using open addressing with linear probing for collision resolution.
LongIntHashMap.LongIntCursor	Forked from HPPC, holding int index,key and value
LongObjectHashMap<VType>	A hash map of `long` to `Object`, implemented using open addressing with linear probing for collision resolution.
LongObjectHashMap.LongObjectCursor<VType>	Forked from HPPC, holding int index,key and value
LongPoint	An indexed `long` field for fast range filters.
LongPointMultiRangeBuilder	Builder for multi range queries for LongPoints
LongRange	An indexed Long Range field.
LongRange	Represents a contiguous range of long values, with an inclusive minimum and exclusive maximum
LongRangeDocValuesField	DocValues field for LongRange.
LongRangeFactory	Groups double values into ranges
LongRangeGroupSelector	A GroupSelector implementation that groups documents by long values
LongRangeSlowRangeQuery
LongsRef	Represents long[], as a slice (offset + length) into an existing long[].
LongValues	Per-segment, per-document long values, which can be calculated at search-time
LongValues	Abstraction over an array of longs.
LongValuesSource	Base class for producing `LongValues`
LongValuesSource.ConstantLongValuesSource	A ConstantLongValuesSource that always returns a constant value
LongValuesSource.DoubleLongValuesSource
LongValuesSource.FieldValuesSource
LongValuesSource.LongValuesComparatorSource
LongValuesSource.LongValuesHolder
LongValuesSource.LongValuesSortField
Lookup	Simple Lookup interface for `CharSequence` suggestions.
Lookup.CharSequenceComparator
Lookup.LookupPriorityQueue	A `PriorityQueue` collecting a fixed size of high priority `Lookup.LookupResult`
Lookup.LookupResult	Result of a lookup.
LovinsStemmer	This class implements the stemming algorithm defined by a snowball script.
LowercaseAsciiCompression	Utility class that can efficiently compress arrays that mostly contain characters in the [0x1F,0x3F) or [0x5F,0x7F) ranges, which notably include all digits, lowercase characters, '.', '-' and '_'.
LowerCaseFilter	Normalizes token text to lower case.
LowerCaseFilter	Normalizes token text to lower case.
LowerCaseFilterFactory	Factory for `LowerCaseFilter`.
LRUQueryCache	A `QueryCache` that evicts queries using a LRU (least-recently-used) eviction policy in order to remain under a given maximum size and number of bytes used.
LRUQueryCache.CacheAndCount	Cache of doc ids with a count.
LRUQueryCache.MinSegmentSizePredicate
LSBRadixSorter	A LSB Radix sorter for unsigned int values.
Lucene40BlockTreeTermsReader	A block-based terms index and dictionary that assigns terms to variable length blocks according to how they share prefixes.
Lucene50CompoundFormat	Lucene 5.0 compound file format
Lucene50CompoundReader	Class for accessing a compound stream.
Lucene50CompoundReader.FileEntry	Offset/Length for a slice inside of a compound file
Lucene50CompressingStoredFieldsFormat	A `StoredFieldsFormat` that compresses documents in chunks in order to improve the compression ratio.
Lucene50CompressingStoredFieldsReader	`StoredFieldsReader` impl for `Lucene50CompressingStoredFieldsFormat`.
Lucene50CompressingStoredFieldsReader.SerializedDocument	A serialized document, you need to decode its input in order to get an actual `Document`.
Lucene50CompressingTermVectorsFormat	A `TermVectorsFormat` that compresses chunks of documents together in order to improve the compression ratio.
Lucene50CompressingTermVectorsReader	`TermVectorsReader` for `Lucene50CompressingTermVectorsFormat`.
Lucene50CompressingTermVectorsReader.TVPostingsEnum
Lucene50CompressingTermVectorsReader.TVTerms
Lucene50CompressingTermVectorsReader.TVTermsEnum
Lucene50LiveDocsFormat	Lucene 5.0 live docs format
Lucene50PostingsFormat	Lucene 5.0 postings format, which encodes postings in packed integer blocks for fast decode.
Lucene50PostingsFormat.IntBlockTermState	Holds all state required for `Lucene50PostingsReader` to produce a `PostingsEnum` without re-seeking the terms dict.
Lucene50PostingsReader	Concrete class that reads docId(maybe frq,pos,offset,payloads) list with postings format.
Lucene50ScoreSkipReader
Lucene50ScoreSkipReader.MutableImpactList
Lucene50SkipReader	Implements the skip list reader for block postings format that stores positions and payloads.
Lucene50StoredFieldsFormat	Lucene 5.0 stored fields format.
Lucene50StoredFieldsFormat.LZ4FastCompressor
Lucene50StoredFieldsFormat.Mode	Configuration option for stored fields.
Lucene50TermVectorsFormat	Lucene 5.0 `term vectors format`.
Lucene60FieldInfosFormat	Lucene 6.0 Field Infos format.
Lucene60PointsFormat	Lucene 6.0 point format, which encodes dimensional values in a block KD-tree structure for fast 1D range and N dimensional shape intersection filtering.
Lucene60PointsReader	Reads point values previously written with Lucene60PointsWriter
Lucene70Codec	Implements the Lucene 7.0 index format, with configurable per-field postings and docvalues formats.
Lucene70DocValuesConsumer	writer for `Lucene70DocValuesFormat`
Lucene70DocValuesConsumer.MinMaxTracker
Lucene70DocValuesFormat	Lucene 7.0 DocValues format.
Lucene70DocValuesProducer	reader for `Lucene70DocValuesFormat`
Lucene70DocValuesProducer.BaseSortedDocValues
Lucene70DocValuesProducer.BaseSortedSetDocValues
Lucene70DocValuesProducer.BinaryEntry
Lucene70DocValuesProducer.DenseBinaryDocValues
Lucene70DocValuesProducer.DenseNumericDocValues
Lucene70DocValuesProducer.NumericEntry
Lucene70DocValuesProducer.SortedEntry
Lucene70DocValuesProducer.SortedNumericEntry
Lucene70DocValuesProducer.SortedSetEntry
Lucene70DocValuesProducer.SparseBinaryDocValues
Lucene70DocValuesProducer.SparseNumericDocValues
Lucene70DocValuesProducer.TermsDict
Lucene70DocValuesProducer.TermsDictEntry
Lucene70NormsFormat	Lucene 7.0 Score normalization format.
Lucene70NormsProducer	Reader for `Lucene70NormsFormat`
Lucene70NormsProducer.DenseNormsIterator
Lucene70NormsProducer.NormsEntry
Lucene70NormsProducer.SparseNormsIterator
Lucene70SegmentInfoFormat	Lucene 7.0 Segment info format.
Lucene80Codec	Implements the Lucene 8.0 index format.
Lucene80DocValuesConsumer	writer for `Lucene80DocValuesFormat`
Lucene80DocValuesConsumer.MinMaxTracker
Lucene80DocValuesFormat	Lucene 8.0 DocValues format.
Lucene80DocValuesFormat.Mode	Configuration option for doc values.
Lucene80DocValuesProducer	reader for `Lucene80DocValuesFormat`
Lucene80DocValuesProducer.BaseSortedDocValues
Lucene80DocValuesProducer.BaseSortedSetDocValues
Lucene80DocValuesProducer.BinaryDecoder
Lucene80DocValuesProducer.BinaryEntry
Lucene80DocValuesProducer.DenseBinaryDocValues
Lucene80DocValuesProducer.DenseNumericDocValues
Lucene80DocValuesProducer.NumericEntry
Lucene80DocValuesProducer.SortedEntry
Lucene80DocValuesProducer.SortedNumericEntry
Lucene80DocValuesProducer.SortedSetEntry
Lucene80DocValuesProducer.SparseBinaryDocValues
Lucene80DocValuesProducer.SparseNumericDocValues
Lucene80DocValuesProducer.TermsDict
Lucene80DocValuesProducer.TermsDictEntry
Lucene80NormsFormat	Lucene 8.0 Score normalization format.
Lucene80NormsProducer	Reader for `Lucene80NormsFormat`
Lucene80NormsProducer.DenseNormsIterator
Lucene80NormsProducer.NormsEntry
Lucene80NormsProducer.SparseNormsIterator
Lucene84Codec	Implements the Lucene 8.4 index format, with configurable per-field postings and docvalues formats.
Lucene84PostingsFormat	Lucene 5.0 postings format, which encodes postings in packed integer blocks for fast decode.
Lucene84PostingsFormat.IntBlockTermState	Holds all state required for `Lucene84PostingsReader` to produce a `PostingsEnum` without re-seeking the terms dict.
Lucene84PostingsReader	Concrete class that reads docId(maybe frq,pos,offset,payloads) list with postings format.
Lucene84ScoreSkipReader
Lucene84ScoreSkipReader.MutableImpactList
Lucene84SkipReader	Implements the skip list reader for block postings format that stores positions and payloads.
Lucene86Codec	Implements the Lucene 8.6 index format, with configurable per-field postings and docvalues formats.
Lucene86PointsFormat	Lucene 8.6 point format, which encodes dimensional values in a block KD-tree structure for fast 1D range and N dimensional shape intersection filtering.
Lucene86PointsReader	Reads point values previously written with Lucene86PointsWriter
Lucene86SegmentInfoFormat	Lucene 8.6 Segment info format.
Lucene87Codec	Implements the Lucene 8.6 index format, with configurable per-field postings and docvalues formats.
Lucene87Codec.Mode	Configuration option for the codec.
Lucene87StoredFieldsFormat	Lucene 8.7 stored fields format.
Lucene87StoredFieldsFormat.Mode	Configuration option for stored fields.
Lucene90BlockTreeTermsReader	A block-based terms index and dictionary that assigns terms to variable length blocks according to how they share prefixes.
Lucene90BlockTreeTermsWriter	Block-based terms index and dictionary writer.
Lucene90BlockTreeTermsWriter.PendingEntry
Lucene90BlockTreeTermsWriter.PendingTerm
Lucene90BlockTreeTermsWriter.StatsWriter
Lucene90BoundsChecker	A helper class for an hnsw graph that serves as a comparator of the currently set bound value with a new value.
Lucene90BoundsChecker.Max	A helper class for an hnsw graph that serves as a comparator of the currently set maximum value with a new value.
Lucene90BoundsChecker.Min	A helper class for an hnsw graph that serves as a comparator of the currently set minimum value with a new value.
Lucene90Codec	Implements the Lucene 9.0 index format
Lucene90Codec.Mode	Configuration option for the codec.
Lucene90CompoundFormat	Lucene 9.0 compound file format
Lucene90CompoundFormat.SizedFile
Lucene90CompoundFormat.SizedFileQueue
Lucene90CompoundReader	Class for accessing a compound stream.
Lucene90CompoundReader.FileEntry	Offset/Length for a slice inside of a compound file
Lucene90CompressingStoredFieldsFormat	A `StoredFieldsFormat` that compresses documents in chunks in order to improve the compression ratio.
Lucene90CompressingStoredFieldsReader	`StoredFieldsReader` impl for `Lucene90CompressingStoredFieldsFormat`.
Lucene90CompressingStoredFieldsReader.SerializedDocument	A serialized document, you need to decode its input in order to get an actual `Document`.
Lucene90CompressingStoredFieldsWriter	`StoredFieldsWriter` impl for `Lucene90CompressingStoredFieldsFormat`.
Lucene90CompressingStoredFieldsWriter.CompressingStoredFieldsMergeSub
Lucene90CompressingStoredFieldsWriter.MergeStrategy
Lucene90CompressingTermVectorsFormat	A `TermVectorsFormat` that compresses chunks of documents together in order to improve the compression ratio.
Lucene90CompressingTermVectorsReader	`TermVectorsReader` for `Lucene90CompressingTermVectorsFormat`.
Lucene90CompressingTermVectorsReader.BlockState
Lucene90CompressingTermVectorsReader.TVPostingsEnum
Lucene90CompressingTermVectorsReader.TVTerms
Lucene90CompressingTermVectorsReader.TVTermsEnum
Lucene90CompressingTermVectorsWriter	`TermVectorsWriter` for `Lucene90CompressingTermVectorsFormat`.
Lucene90CompressingTermVectorsWriter.CompressingTermVectorsSub
Lucene90DocValuesConsumer	writer for `Lucene90DocValuesFormat`
Lucene90DocValuesConsumer.MinMaxTracker
Lucene90DocValuesFormat	Lucene 9.0 DocValues format.
Lucene90DocValuesProducer	reader for `Lucene90DocValuesFormat`
Lucene90DocValuesProducer.BinaryEntry
Lucene90DocValuesProducer.DenseBinaryDocValues
Lucene90DocValuesProducer.DenseNumericDocValues
Lucene90DocValuesProducer.NumericEntry
Lucene90DocValuesProducer.SortedEntry
Lucene90DocValuesProducer.SortedNumericEntry
Lucene90DocValuesProducer.SortedSetEntry
Lucene90DocValuesProducer.SparseBinaryDocValues
Lucene90DocValuesProducer.SparseNumericDocValues
Lucene90DocValuesProducer.TermsDictEntry
Lucene90FieldInfosFormat	Lucene 9.0 Field Infos format.
Lucene90HnswGraphBuilder	Builder for HNSW graph.
Lucene90HnswVectorsFormat	Lucene 9.0 vector format, which encodes numeric vector values and an optional associated graph connecting the documents having values.
Lucene90HnswVectorsReader	Reads vectors from the index segments along with index data structures supporting KNN search.
Lucene90HnswVectorsReader.FieldEntry
Lucene90HnswVectorsReader.OffHeapFloatVectorValues	Read the vector values from the index input.
Lucene90HnswVectorsReader.OffHeapHnswGraph	Read the nearest-neighbors graph from the index input
Lucene90LiveDocsFormat	Lucene 9.0 live docs format
Lucene90NeighborArray	NeighborArray encodes the neighbors of a node and their mutual scores in the HNSW graph as a pair of growable arrays.
Lucene90NormsConsumer	Writer for `Lucene90NormsFormat`
Lucene90NormsFormat	Lucene 9.0 Score normalization format.
Lucene90NormsProducer	Reader for `Lucene90NormsFormat`
Lucene90NormsProducer.DenseNormsIterator
Lucene90NormsProducer.NormsEntry
Lucene90NormsProducer.SparseNormsIterator
Lucene90OnHeapHnswGraph	An `HnswGraph` where all nodes and connections are held in memory.
Lucene90PointsFormat	Lucene 9.0 point format, which encodes dimensional values in a block KD-tree structure for fast 1D range and N dimensional shape intersection filtering.
Lucene90PointsReader	Reads point values previously written with `Lucene90PointsWriter`
Lucene90PointsWriter	Writes dimensional values
Lucene90PostingsFormat	Lucene 9.0 postings format, which encodes postings in packed integer blocks for fast decode.
Lucene90PostingsFormat.IntBlockTermState	Holds all state required for `Lucene90PostingsReader` to produce a `PostingsEnum` without re-seeking the terms dict.
Lucene90PostingsReader	Concrete class that reads docId(maybe frq,pos,offset,payloads) list with postings format.
Lucene90PostingsWriter	Concrete class that writes docId(maybe frq,pos,offset,payloads) list with postings format.
Lucene90ScoreSkipReader
Lucene90ScoreSkipReader.MutableImpactList
Lucene90SegmentInfoFormat	Lucene 9.0 Segment info format.
Lucene90SkipReader	Implements the skip list reader for block postings format that stores positions and payloads.
Lucene90SkipWriter	Write skip lists with multiple levels, and support skip within block ints.
Lucene90StoredFieldsFormat	Lucene 9.0 stored fields format.
Lucene90StoredFieldsFormat.Mode	Configuration option for stored fields.
Lucene90TermVectorsFormat	Lucene 9.0 `term vectors format`.
Lucene91BoundsChecker	A helper class for an hnsw graph that serves as a comparator of the currently set bound value with a new value.
Lucene91BoundsChecker.Max	A helper class for an hnsw graph that serves as a comparator of the currently set maximum value with a new value.
Lucene91BoundsChecker.Min	A helper class for an hnsw graph that serves as a comparator of the currently set minimum value with a new value.
Lucene91Codec	Implements the Lucene 9.1 index format
Lucene91Codec.Mode	Configuration option for the codec.
Lucene91HnswVectorsFormat	Lucene 9.1 vector format, which encodes numeric vector values and an optional associated graph connecting the documents having values.
Lucene91HnswVectorsReader	Reads vectors from the index segments along with index data structures supporting KNN search.
Lucene91HnswVectorsReader.FieldEntry
Lucene91HnswVectorsReader.OffHeapFloatVectorValues	Read the vector values from the index input.
Lucene91HnswVectorsReader.OffHeapHnswGraph	Read the nearest-neighbors graph from the index input
Lucene91NeighborArray	NeighborArray encodes the neighbors of a node and their mutual scores in the HNSW graph as a pair of growable arrays.
Lucene91OnHeapHnswGraph	An `HnswGraph` where all nodes and connections are held in memory.
Lucene92Codec	Implements the Lucene 9.2 index format
Lucene92Codec.Mode	Configuration option for the codec.
Lucene92HnswVectorsFormat	Lucene 9.2 vector format, which encodes numeric vector values and an optional associated graph connecting the documents having values.
Lucene92HnswVectorsReader	Reads vectors from the index segments along with index data structures supporting KNN search.
Lucene92HnswVectorsReader.FieldEntry
Lucene92HnswVectorsReader.OffHeapHnswGraph	Read the nearest-neighbors graph from the index input
Lucene94Codec	Implements the Lucene 9.4 index format
Lucene94Codec.Mode	Configuration option for the codec.
Lucene94FieldInfosFormat	Lucene 9.0 Field Infos format.
Lucene94HnswVectorsFormat	Lucene 9.4 vector format, which encodes numeric vector values and an optional associated graph connecting the documents having values.
Lucene94HnswVectorsReader	Reads vectors from the index segments along with index data structures supporting KNN search.
Lucene94HnswVectorsReader.FieldEntry
Lucene94HnswVectorsReader.OffHeapHnswGraph	Read the nearest-neighbors graph from the index input
Lucene95Codec	Implements the Lucene 9.5 index format
Lucene95Codec.Mode	Configuration option for the codec.
Lucene95HnswVectorsFormat	Lucene 9.5 vector format, which encodes numeric vector values and an optional associated graph connecting the documents having values.
Lucene95HnswVectorsReader	Reads vectors from the index segments along with index data structures supporting KNN search.
Lucene95HnswVectorsReader.FieldEntry
Lucene95HnswVectorsReader.OffHeapHnswGraph	Read the nearest-neighbors graph from the index input
Lucene99Codec	Implements the Lucene 9.9 index format
Lucene99Codec.Mode	Configuration option for the codec.
Lucene99FlatVectorsFormat	Lucene 9.9 flat vector format, which encodes numeric vector values
Lucene99FlatVectorsReader	Reads vectors from the index segments.
Lucene99FlatVectorsReader.FieldEntry
Lucene99FlatVectorsWriter	Writes vector values to index segments.
Lucene99FlatVectorsWriter.FieldWriter<T>
Lucene99FlatVectorsWriter.FlatCloseableRandomVectorScorerSupplier
Lucene99HnswScalarQuantizedVectorsFormat	Lucene 9.9 vector format, which encodes numeric vector values into an associated graph connecting the documents having values.
Lucene99HnswVectorsFormat	Lucene 9.9 vector format, which encodes numeric vector values into an associated graph connecting the documents having values.
Lucene99HnswVectorsReader	Reads vectors from the index segments along with index data structures supporting KNN search.
Lucene99HnswVectorsReader.FieldEntry
Lucene99HnswVectorsReader.OffHeapHnswGraph	Read the nearest-neighbors graph from the index input
Lucene99HnswVectorsWriter	Writes vector values and knn graphs to index segments.
Lucene99HnswVectorsWriter.FieldWriter<T>
Lucene99PostingsFormat	Lucene 9.9 postings format, which encodes postings in packed integer blocks for fast decode.
Lucene99PostingsFormat.IntBlockTermState	Holds all state required for `Lucene99PostingsReader` to produce a `PostingsEnum` without re-seeking the terms dict.
Lucene99PostingsReader	Concrete class that reads docId(maybe frq,pos,offset,payloads) list with postings format.
Lucene99PostingsWriter	Concrete class that writes docId(maybe frq,pos,offset,payloads) list with postings format.
Lucene99ScalarQuantizedVectorScorer	Optimized scalar quantized implementation of `FlatVectorsScorer` for quantized vectors stored in the Lucene99 format.
Lucene99ScalarQuantizedVectorScorer.CompressedInt4DotProduct
Lucene99ScalarQuantizedVectorScorer.DotProduct	Calculates dot product on quantized vectors, applying the appropriate corrections
Lucene99ScalarQuantizedVectorScorer.Euclidean
Lucene99ScalarQuantizedVectorScorer.FloatToFloatFunction
Lucene99ScalarQuantizedVectorScorer.Int4DotProduct
Lucene99ScalarQuantizedVectorScorer.ScalarQuantizedRandomVectorScorerSupplier
Lucene99ScalarQuantizedVectorsFormat	Format supporting vector quantization, storage, and retrieval
Lucene99ScalarQuantizedVectorsReader	Reads Scalar Quantized vectors from the index segments along with index data structures.
Lucene99ScalarQuantizedVectorsReader.FieldEntry
Lucene99ScalarQuantizedVectorsReader.QuantizedVectorValues
Lucene99ScalarQuantizedVectorsWriter	Writes quantized vector values and metadata to index segments.
Lucene99ScalarQuantizedVectorsWriter.FieldWriter
Lucene99ScalarQuantizedVectorsWriter.FloatVectorWrapper
Lucene99ScalarQuantizedVectorsWriter.MergedQuantizedVectorValues	Returns a merged view over all the segment's `QuantizedByteVectorValues`.
Lucene99ScalarQuantizedVectorsWriter.OffsetCorrectedQuantizedByteVectorValues
Lucene99ScalarQuantizedVectorsWriter.QuantizedByteVectorValueSub
Lucene99ScalarQuantizedVectorsWriter.QuantizedFloatVectorValues
Lucene99ScalarQuantizedVectorsWriter.ScalarQuantizedCloseableRandomVectorScorerSupplier
Lucene99ScoreSkipReader
Lucene99ScoreSkipReader.MutableImpactList
Lucene99SegmentInfoFormat	Lucene 9.9 Segment info format.
Lucene99SkipReader	Implements the skip list reader for block postings format that stores positions and payloads.
Lucene99SkipWriter	Write skip lists with multiple levels, and support skip within block ints.
LuceneDictionary	Lucene Dictionary: terms taken from the given field of a Lucene index.
LuceneLevenshteinDistance	Damerau-Levenshtein (optimal string alignment) implemented in a consistent way as Lucene's FuzzyTermsEnum with the transpositions option enabled.
LZ4	LZ4 compression and decompression routines.
LZ4.FastCompressionHashTable	Simple lossy `LZ4.HashTable` that only stores the last ocurrence for each hash on `2^14` bytes of memory.
LZ4.HashTable	A record of previous occurrences of sequences of 4 bytes.
LZ4.HighCompressionHashTable	A higher-precision `LZ4.HashTable`.
LZ4.Table
LZ4.Table16	16 bits per offset.
LZ4.Table32	32 bits per value, only used when inputs exceed 64kB, e.g.
LZ4WithPresetDictCompressionMode	A compression mode that compromises on the compression ratio to provide fast compression and decompression.
LZ4WithPresetDictCompressionMode	A compression mode that compromises on the compression ratio to provide fast compression and decompression.
LZ4WithPresetDictCompressionMode.LZ4WithPresetDictCompressor
LZ4WithPresetDictCompressionMode.LZ4WithPresetDictCompressor
LZ4WithPresetDictCompressionMode.LZ4WithPresetDictDecompressor
LZ4WithPresetDictCompressionMode.LZ4WithPresetDictDecompressor
MapOfSets<K,V>	Helper class for keeping Lists of Objects associated with keys.
MappedByteBufferIndexInputProvider
MappedMultiFields	A `Fields` implementation that merges multiple Fields into one, and maps around deleted documents.
MappedMultiFields.MappedMultiTerms
MappedMultiFields.MappedMultiTermsEnum
MappingCharFilter	Simplistic `CharFilter` that applies the mappings contained in a `NormalizeCharMap` to the character stream, and correcting the resulting changes to the offsets.
MappingCharFilterFactory	Factory for `MappingCharFilter`.
MappingMultiPostingsEnum	Exposes flex API, merged from flex API of sub-segments, remapping docIDs (this is used for segment merging).
MappingMultiPostingsEnum.MappingPostingsSub
MatchAllDocsQuery	A query that matches all documents.
MatchAllDocsQueryBuilder	Builder for `MatchAllDocsQuery`
MatchAllDocsQueryNode	A `MatchAllDocsQueryNode` indicates that a query node tree or subtree will match all documents if executed in the index.
MatchAllDocsQueryNodeBuilder	Builds a `MatchAllDocsQuery` object from a `MatchAllDocsQueryNode` object.
MatchAllDocsQueryNodeProcessor	This processor converts every `WildcardQueryNode` that is ":" to `MatchAllDocsQueryNode`.
MatcherFactory<T extends QueryMatch>	Interface for the creation of new CandidateMatcher objects
Matches	Reports the positions and optionally offsets of all matching terms in a query for a single document
MatchesIterator	An iterator over match positions (and optionally offsets) for a single document and field
MatchesUtils	Contains static functions that aid the implementation of `Matches` and `MatchesIterator` interfaces.
MatchHighlighter	An example highlighter that combines several lower-level highlighting utilities in this package into a fully featured, ready-to-use component.
MatchHighlighter.DocHighlights	Single document's highlights.
MatchHighlighter.DocHit
MatchHighlighter.FieldValueHighlighter	Actual per-field highlighter.
MatchHighlighter.QueryOffsetRange	An `OffsetRange` of a match, together with the source query that caused it.
MatchingQueries<T extends QueryMatch>	Class to hold the results of matching a single `Document` against queries held in the Monitor
MatchingReaders	Computes which segments have identical field name to number mappings, which allows stored fields and term vectors in this codec to be bulk-merged.
MatchingReaders	Computes which segments have identical field name to number mappings, which allows stored fields and term vectors in this codec to be bulk-merged.
MatchNoDocsQuery	A query that matches no documents.
MatchNoDocsQueryNode	A `MatchNoDocsQueryNode` indicates that a query node tree or subtree will not match any documents if executed in the index.
MatchNoDocsQueryNodeBuilder	Builds a `MatchNoDocsQuery` object from a `MatchNoDocsQueryNode` object.
MatchRegionRetriever	Utility class to compute a list of "match regions" for a given query, searcher and document(s) using `Matches` API.
MatchRegionRetriever.DocumentFieldValueProvider	Implements `MatchRegionRetriever.FieldValueProvider` wrapping a preloaded `Document`.
MatchRegionRetriever.FieldValueProvider	An abstraction that provides document values for a given field.
MatchRegionRetriever.MatchOffsetsConsumer	A callback for accepting a single document (and its associated leaf reader, leaf document ID) and its match offset ranges, as indicated by the `Matches` interface retrieved for the query.
MathUtil	Math static utility methods.
MaxDocValueSource	Returns the value of `IndexReader.maxDoc()` for every document.
MaxFloatFunction	`MaxFloatFunction` returns the max of its components.
MaxGaps	Node that represents `Intervals.maxgaps(int, IntervalsSource)`.
MaxNonCompetitiveBoostAttribute	Add this `Attribute` to a fresh `AttributeSource` before calling `MultiTermQuery.getTermsEnum(Terms,AttributeSource)`.
MaxNonCompetitiveBoostAttributeImpl	Implementation class for `MaxNonCompetitiveBoostAttribute`.
MaxPayloadFunction	Returns the maximum payload score seen, else 1 if there are no payloads on the doc.
MaxScoreAccumulator	Maintains the maximum score and its corresponding document id concurrently
MaxScoreAccumulator.DocAndScore
MaxScoreBulkScorer
MaxScoreCache	Compute maximum scores based on `Impacts` and keep them in a cache in order not to run expensive similarity score computations multiple times on the same data.
MaxWidth	Node that represents `Intervals.maxwidth(int, IntervalsSource)`.
Membership	Implemented by Geo3D shapes that can calculate if a point is within it or not.
MemoryAccountingBitsetCollector	Bitset collector which supports memory tracking
MemoryIndex	High-performance single-document main memory Apache Lucene fulltext search index.
MemoryIndex.BinaryDocValuesProducer
MemoryIndex.BytesRefHashDocValuesProducer
MemoryIndex.MemoryDocValuesIterator
MemoryIndex.NumericDocValuesProducer
MemoryIndex.SliceByteStartArray
MemoryIndex.SlicedIntBlockPool
MemoryIndex.SlicedIntBlockPool.SliceReader	A `MemoryIndex.SlicedIntBlockPool.SliceReader` that can read int slices written by a `MemoryIndex.SlicedIntBlockPool.SliceWriter`
MemoryIndex.SlicedIntBlockPool.SliceWriter	A `MemoryIndex.SlicedIntBlockPool.SliceWriter` that allows to write multiple integer slices into a given `IntBlockPool`.
MemoryIndexOffsetStrategy	Uses an `Analyzer` on content to get offsets and then populates a `MemoryIndex`.
MemoryTracker	Tracks dynamic allocations/deallocations of memory for transient objects
MergedIterator<T extends java.lang.Comparable<T>>	Provides a merged sorted view from several sorted iterators.
MergedIterator.SubIterator<I extends java.lang.Comparable<I>>
MergedIterator.TermMergeQueue<C extends java.lang.Comparable<C>>
MergeInfo	A MergeInfo provides information required for a MERGE context.
MergeOnFlushMergePolicy	A simple extension to wrap `MergePolicy` to merge all tiny segments (or at least segments smaller than specified in `MergeOnFlushMergePolicy.setSmallSegmentThresholdMB(double)` into one segment on commit.
MergeOnFlushMergePolicy.Units	Utility class to handle conversion between megabytes and bytes
MergePolicy	Expert: a MergePolicy determines the sequence of primitive merge operations.
MergePolicy.MergeAbortedException	Thrown when a merge was explicitly aborted because `IndexWriter.abortMerges()` was called.
MergePolicy.MergeContext	This interface represents the current context of the merge selection process.
MergePolicy.MergeException	Exception thrown if there are any problems while executing a merge.
MergePolicy.MergeReader
MergePolicy.MergeSpecification	A MergeSpecification instance provides the information necessary to perform multiple merges.
MergePolicy.OneMerge	OneMerge provides the information necessary to perform an individual primitive merge operation, resulting in a single new segment.
MergePolicy.OneMergeProgress	Progress and state for an executing merge.
MergePolicy.OneMergeProgress.PauseReason	Reason for pausing the merge thread.
MergeRateLimiter	This is the `RateLimiter` that `IndexWriter` assigns to each running merge, to give `MergeScheduler`s ionice like control.
MergeScheduler	Expert: `IndexWriter` uses an instance implementing this interface to execute the merges selected by a `MergePolicy`.
MergeScheduler.MergeSource	Provides access to new merges and executes the actual merge
MergeState	Holds common state used during segment merging.
MergeState.DocMap	A map of doc IDs.
MergeTrigger	MergeTrigger is passed to `MergePolicy.findMerges(MergeTrigger, SegmentInfos, MergePolicy.MergeContext)` to indicate the event that triggered the merge.
Message	Message Interface for a lazy loading.
MessageImpl	Default implementation of Message interface.
MinDocIterator	Docs iterator that starts iterating from a configurable minimum document
MinFloatFunction	`MinFloatFunction` returns the min of its components.
MinHashFilter	Generate min hash tokens from an incoming stream of tokens.
MinHashFilter.FixedSizeTreeSet<E extends java.lang.Comparable<E>>
MinHashFilter.LongPair	128 bits of state
MinHashFilterFactory	`TokenFilterFactory` for `MinHashFilter`.
MinimizationOperations	Operations for minimizing automata.
MinimizationOperations.IntPair
MinimizationOperations.StateList
MinimizationOperations.StateListNode
MinimizingConjunctionIntervalsSource
MinimizingConjunctionIntervalsSource.MatchCallback
MinimumShouldMatchIntervalsSource
MinimumShouldMatchIntervalsSource.MinimumMatchesIterator
MinimumShouldMatchIntervalsSource.MinimumShouldMatchIntervalIterator
MinPayloadFunction	Calculates the minimum payload seen
MinShouldMatchNode	Node that represents a minimum-should-match restriction on a `GroupQueryNode`.
MinShouldMatchNodeBuilder	Builds a `BooleanQuery` from a `MinShouldMatchNode`.
MMapDirectory	File-based `Directory` implementation that uses mmap for reading, and `FSDirectory.FSIndexOutput` for writing.
MMapDirectory.MMapIndexInputProvider
ModifierQueryNode	A `ModifierQueryNode` indicates the modifier value (+,-,?,NONE) for each term on the query string.
ModifierQueryNode.Modifier	Modifier type: such as required (REQ), prohibited (NOT)
ModifierQueryNodeBuilder	Builds no object, it only returns the `Query` object set on the `ModifierQueryNode` object using a `QueryTreeBuilder.QUERY_TREE_BUILDER_TAGID` tag.
ModifyingSuggester	A class that modifies the given misspelled word in various ways to get correct suggestions
ModifyingSuggester.GradedSuggestions
ModuleResourceLoader	Simple `ResourceLoader` that uses `Module.getResourceAsStream(String)` and `Class.forName(Module,String)` to open resources and classes, respectively.
Monitor	A Monitor contains a set of `Query` objects with associated IDs, and efficiently matches them against sets of `Document` objects.
Monitor.QueryCacheStats	Statistics for the query cache and query index
Monitor.StandardQueryCollector<T extends QueryMatch>
MonitorConfiguration	Encapsulates various configuration settings for a Monitor's query index
MonitorQuery	Defines a query to be stored in a Monitor
MonitorQuerySerializer	Serializes and deserializes MonitorQuery objects into byte streams
MonitorUpdateListener	For reporting events on a Monitor's query index
MonotonicBlockPackedReader	Provides random access to a stream written with `MonotonicBlockPackedWriter`.
MonotonicBlockPackedWriter	A writer for large monotonically increasing sequences of positive longs.
MonotonicLongValues
MonotonicLongValues.Builder
MoreLikeThis	Generate "more like this" similarity queries.
MoreLikeThis.FreqQ	PriorityQueue that orders words by score.
MoreLikeThis.Int	Use for frequencies and to avoid renewing Integers.
MoreLikeThis.ScoreTerm
MoreLikeThisQuery	A simple wrapper for MoreLikeThis for use in scenarios where a Query object is required eg in custom QueryParser extensions.
MSBRadixSorter	Radix sorter for variable-length strings.
MultiBits	Concatenates multiple Bits together, on every lookup.
MultiBoolFunction	Abstract `ValueSource` implementation which wraps multiple ValueSources and applies an extendible boolean function to their values.
MultiCollector	A `Collector` which allows running a search with several `Collector`s.
MultiCollector.MinCompetitiveScoreAwareScorable
MultiCollector.MultiLeafCollector
MultiCollectorManager	A `CollectorManager` implements which wrap a set of `CollectorManager` as `MultiCollector` acts for `Collector`.
MultiDocValues	A wrapper for CompositeIndexReader providing access to DocValues.
MultiDocValues.MultiSortedDocValues	Implements SortedDocValues over n subs, using an OrdinalMap
MultiDocValues.MultiSortedSetDocValues	Implements MultiSortedSetDocValues over n subs, using an OrdinalMap
MultiFieldQueryNodeProcessor	This processor is used to expand terms so the query looks for the same term in different fields.
MultiFieldQueryParser	A QueryParser which constructs queries to search multiple fields.
MultiFields	Provides a single `Fields` term index view over an `IndexReader`.
MultiFieldsOffsetStrategy	FieldOffsetStrategy that combines offsets from multiple fields.
MultiFloatFunction	Abstract `ValueSource` implementation which wraps multiple ValueSources and applies an extendible float function to their values.
MultiFunction	Abstract parent class for `ValueSource` implementations that wrap multiple ValueSources and apply their own logic.
MultiLeafFieldComparator
MultiLeafKnnCollector	MultiLeafKnnCollector is a specific KnnCollector that can exchange the top collected results across segments through a shared global queue.
MultiLeafReader	Utility methods for working with a `IndexReader` as if it were a `LeafReader`.
MultiLevelSkipListReader	This abstract class reads skip lists with multiple levels.
MultiLevelSkipListWriter	This abstract class writes skip lists with multiple levels.
MultiMatchingQueries<T extends QueryMatch>	Class to hold the results of matching a batch of `Document`s against queries held in the Monitor
MultiNormsLeafSimScorer	Copy of `LeafSimScorer` that sums document's norms from multiple fields.
MultiNormsLeafSimScorer.MultiFieldNormValues
MultiPassIndexSplitter	This tool splits input index into multiple equal parts.
MultiPassIndexSplitter.FakeDeleteIndexReader	This class emulates deletions on the underlying index.
MultiPassIndexSplitter.FakeDeleteLeafIndexReader
MultipassTermFilteredPresearcher	A TermFilteredPresearcher that indexes queries multiple times, with terms collected from different routes through a querytree.
MultiPhraseQuery	A generalized version of `PhraseQuery`, with the possibility of adding more than one term at the same position that are treated as a disjunction (OR).
MultiPhraseQuery.Builder	A builder for multi-phrase queries
MultiPhraseQuery.PostingsAndPosition
MultiPhraseQuery.UnionFullPostingsEnum	Slower version of UnionPostingsEnum that delegates offsets and positions, for use by MatchesIterator
MultiPhraseQuery.UnionPostingsEnum	Takes the logical union of multiple PostingsEnum iterators.
MultiPhraseQuery.UnionPostingsEnum.DocsQueue	disjunction of postings ordered by docid.
MultiPhraseQuery.UnionPostingsEnum.PositionsQueue	queue of terms for a single document.
MultiPhraseQueryNode	A `MultiPhraseQueryNode` indicates that its children should be used to build a `MultiPhraseQuery` instead of `PhraseQuery`.
MultiPhraseQueryNodeBuilder	Builds a `MultiPhraseQuery` object from a `MultiPhraseQueryNode` object.
MultiPostingsEnum	Exposes `PostingsEnum`, merged from `PostingsEnum` API of sub-segments.
MultiPostingsEnum.EnumWithSlice	Holds a `PostingsEnum` along with the corresponding `ReaderSlice`.
MultiRangeQuery	Abstract class for range queries involving multiple ranges against physical points such as `IntPoints` All ranges are logically ORed together
MultiRangeQuery.Builder	A builder for multirange queries.
MultiRangeQuery.Range	A range represents anything with a min/max value that can compute its relation with another range and can compute if a point is inside it
MultiRangeQuery.RangeClause	Representation of a single clause in a MultiRangeQuery
MultiRangeQuery.RangeTree	An interval tree of Ranges for speeding up computations
MultiRangeQuery.Relatable	Represents a range that can compute its relation with another range and can compute if a point is inside it
MultiReader	A `CompositeReader` which reads multiple indexes, appending their content.
Multiset<T>	A `Multiset` is a set that allows for duplicate elements.
MultiSimilarity	Implements the CombSUM method for combining evidence from multiple similarity values described in: Joseph A.
MultiSimilarity.MultiSimScorer
MultiSorter
MultiSorter.LeafAndDocID
MultiTermHighlighting	Support for highlighting multi-term queries.
MultiTermHighlighting.AutomataCollector
MultiTermIntervalsSource
MultiTermQuery	An abstract `Query` that matches documents containing a subset of terms provided by a `FilteredTermsEnum` enumeration.
MultiTermQuery.RewriteMethod	Abstract class that defines how the query is rewritten.
MultiTermQuery.TopTermsBlendedFreqScoringRewrite	A rewrite method that first translates each term into `BooleanClause.Occur.SHOULD` clause in a BooleanQuery, but adjusts the frequencies used for scoring to be blended across the terms, otherwise the rarest term typically ranks highest (often not useful eg in the set of expanded terms in a FuzzyQuery).
MultiTermQuery.TopTermsBoostOnlyBooleanQueryRewrite	A rewrite method that first translates each term into `BooleanClause.Occur.SHOULD` clause in a BooleanQuery, but the scores are only computed as the boost.
MultiTermQuery.TopTermsScoringBooleanQueryRewrite	A rewrite method that first translates each term into `BooleanClause.Occur.SHOULD` clause in a BooleanQuery, and keeps the scores as computed by the query.
MultiTermQueryConstantScoreBlendedWrapper<Q extends MultiTermQuery>	This class provides the functionality behind `MultiTermQuery.CONSTANT_SCORE_BLENDED_REWRITE`.
MultiTermQueryConstantScoreWrapper<Q extends MultiTermQuery>	This class provides the functionality behind `MultiTermQuery.CONSTANT_SCORE_REWRITE`.
MultiTermRewriteMethodProcessor	This processor instates the default `MultiTermQuery.RewriteMethod`, `MultiTermQuery.CONSTANT_SCORE_BLENDED_REWRITE`, for multi-term query nodes.
MultiTerms	Exposes flex API, merged from flex API of sub-segments.
MultiTermsEnum	Exposes `TermsEnum` API, merged from `TermsEnum` API of sub-segments.
MultiTermsEnum.TermMergeQueue
MultiTermsEnum.TermsEnumWithSlice
MultiTrie	The MultiTrie is a Trie of Tries.
MultiTrie2	The MultiTrie is a Trie of Tries.
MultiValuedDoubleFieldSource	Obtains double field values from `LeafReader.getSortedNumericDocValues(java.lang.String)` and using a `SortedNumericSelector` it gives a single-valued ValueSource view of a field.
MultiValuedFloatFieldSource	Obtains float field values from `LeafReader.getSortedNumericDocValues(java.lang.String)` and using a `SortedNumericSelector` it gives a single-valued ValueSource view of a field.
MultiValuedIntFieldSource	Obtains int field values from `LeafReader.getSortedNumericDocValues(java.lang.String)` and using a `SortedNumericSelector` it gives a single-valued ValueSource view of a field.
MultiValuedLongFieldSource	Obtains long field values from `LeafReader.getSortedNumericDocValues(java.lang.String)` and using a `SortedNumericSelector` it gives a single-valued ValueSource view of a field.
MultiValueSource	A `ValueSource` that abstractly represents `ValueSource`s for poly fields, and other things.
MurmurHash64	This is a very fast, non-cryptographic hash suitable for general hash-based lookup.
MutablePointTree	One leaf `PointValues.PointTree` whose order of points can be changed.
MutablePointTreeReaderUtils	Utility APIs for sorting and partitioning buffered points.
MutableValue	Base class for all mutable values.
MutableValueBool	`MutableValue` implementation of type `boolean`.
MutableValueDate	`MutableValue` implementation of type `Date`.
MutableValueDouble	`MutableValue` implementation of type `double`.
MutableValueFloat	`MutableValue` implementation of type `float`.
MutableValueInt	`MutableValue` implementation of type `int`.
MutableValueLong	`MutableValue` implementation of type `long`.
MutableValueStr	`MutableValue` implementation of type `String`.
NamedMatches	Utility class to help extract the set of sub queries that have matched from a larger query.
NamedMatches.NamedQuery
NamedSPILoader<S extends NamedSPILoader.NamedSPI>	Helper class for loading named SPIs from classpath (e.g.
NamedSPILoader.NamedSPI	Interface to support `NamedSPILoader.lookup(String)` by name.
NamedThreadFactory	A default `ThreadFactory` implementation that accepts the name prefix of the created threads as a constructor argument.
NativeFSLockFactory	Implements `LockFactory` using native OS file locks.
NativeFSLockFactory.NativeFSLock
NearestFuzzyQuery	Simplification of FuzzyLikeThisQuery, to be used in the context of KNN classification.
NearestFuzzyQuery.FieldVals
NearestFuzzyQuery.ScoreTerm
NearestFuzzyQuery.ScoreTermQueue
NearestNeighbor	KNN search on top of 2D lat/lon indexed points.
NearestNeighbor.Cell
NearestNeighbor.NearestHit	Holds one hit from `NearestNeighbor.nearest(double, double, java.util.List<org.apache.lucene.index.PointValues>, java.util.List<org.apache.lucene.util.Bits>, org.apache.lucene.internal.hppc.IntArrayList, int)`
NearestNeighbor.NearestVisitor
NearSpansOrdered	A Spans that is formed from the ordered subspans of a SpanNearQuery where the subspans do not overlap and have a maximum slop between them.
NearSpansUnordered	Similar to `NearSpansOrdered`, but for the unordered case.
NeighborArray	NeighborArray encodes the neighbors of a node and their mutual scores in the HNSW graph as a pair of growable arrays.
NeighborQueue	NeighborQueue uses a `LongHeap` to store lists of arcs in an HNSW graph, represented as a neighbor node id with an associated score packed together as a sortable long, which is sorted primarily by score.
NeighborQueue.Order
NepaliAnalyzer	Analyzer for Nepali.
NepaliAnalyzer.DefaultSetHolder	Atomically loads the DEFAULT_STOP_SET in a lazy fashion once the outer class accesses the static final set the first time.;
NepaliStemmer	This class implements the stemming algorithm defined by a snowball script.
NGramDistance	N-Gram version of edit distance based on paper by Grzegorz Kondrak, "N-gram similarity and distance".
NGramFilterFactory	Factory for `NGramTokenFilter`.
NGramFragmentChecker	A `FragmentChecker` based on all character n-grams possible in a certain language, keeping them in a relatively memory-efficient, but probabilistic data structure.
NGramFragmentChecker.NGramConsumer	A callback for n-gram ranges in words
NGramPhraseQuery	This is a `PhraseQuery` which is optimized for n-gram phrase query.
NGramTokenFilter	Tokenizes the input into n-grams of the given size(s).
NGramTokenizer	Tokenizes the input into n-grams of the given size(s).
NGramTokenizerFactory	Factory for `NGramTokenizer`.
NIOFSDirectory	An `FSDirectory` implementation that uses java.nio's FileChannel's positional read, which allows multiple threads to read from the same file without synchronizing.
NIOFSDirectory.NIOFSIndexInput	Reads bytes with `FileChannel.read(ByteBuffer, long)`
NLS	MessageBundles classes extend this class, to implement a bundle.
NLSException	Interface that exceptions should implement to support lazy loading of messages.
NoChildOptimizationQueryNodeProcessor	A `NoChildOptimizationQueryNodeProcessor` removes every BooleanQueryNode, BoostQueryNode, TokenizedPhraseQueryNode or ModifierQueryNode that do not have a valid children.
NodeHash<T>
NoDeletionPolicy	An `IndexDeletionPolicy` which keeps all index commits around, never deleting them.
NoLockFactory	Use this `LockFactory` to disable locking entirely.
NoLockFactory.NoLock
NoMatchIntervalsSource	A source returning no matches
NoMergePolicy	A `MergePolicy` which never returns merges to execute.
NoMergeScheduler	A `MergeScheduler` which never executes any merges.
NonOverlapping	Node that represents `Intervals.nonOverlapping(IntervalsSource, IntervalsSource)` .
NonOverlappingIntervalsSource
NonOverlappingIntervalsSource.NonOverlappingIterator
NoOpOffsetStrategy	Never returns offsets.
NoOutputs	A null FST `Outputs` implementation; use this if you just want to build an FSA.
NormalDistance	Normal distance computation style.
Normalization	This class acts as the base class for the implementations of the term frequency normalization methods in the DFR framework.
Normalization.NoNormalization	Implementation used when there is no normalization.
NormalizationH1	Normalization model that assumes a uniform distribution of the term frequency.
NormalizationH2	Normalization model in which the term frequency is inversely related to the length.
NormalizationH3	Dirichlet Priors normalization
NormalizationZ	Pareto-Zipf Normalization
NormalizeCharMap	Holds a map of String input to String output, to be used with `MappingCharFilter`.
NormalizeCharMap.Builder	Builds an NormalizeCharMap.
NormalSquaredDistance	Normal squared distance computation style.
NormsConsumer	Abstract API that consumes normalization values.
NormsConsumer.NumericDocValuesSub	Tracks state of one numeric sub-reader that we are merging
NormsFieldExistsQuery	Deprecated. Use `FieldExistsQuery` instead.
NormsFormat	Encodes/decodes per-document score normalization values.
NormsProducer	Abstract API that produces field normalization values
NormValueSource	Function that returns the decoded norm for every document.
NormValuesWriter	Buffers up pending long per doc, then flushes when segment flushes.
NormValuesWriter.BufferedNorms
NorwegianAnalyzer	`Analyzer` for Norwegian.
NorwegianAnalyzer.DefaultSetHolder	Atomically loads the DEFAULT_STOP_SET in a lazy fashion once the outer class accesses the static final set the first time.;
NorwegianLightStemFilter	A `TokenFilter` that applies `NorwegianLightStemmer` to stem Norwegian words.
NorwegianLightStemFilterFactory	Factory for `NorwegianLightStemFilter`.
NorwegianLightStemmer	Light Stemmer for Norwegian.
NorwegianMinimalStemFilter	A `TokenFilter` that applies `NorwegianMinimalStemmer` to stem Norwegian words.
NorwegianMinimalStemFilterFactory	Factory for `NorwegianMinimalStemFilter`.
NorwegianMinimalStemmer	Minimal Stemmer for Norwegian Bokmål (no-nb) and Nynorsk (no-nn)
NorwegianNormalizationFilter	This filter normalize use of the interchangeable Scandinavian characters æÆäÄöÖøØ and folded variants (ae, oe, aa) by transforming them to åÅæÆøØ.
NorwegianNormalizationFilterFactory	Factory for `NorwegianNormalizationFilter`.
NorwegianStemmer	This class implements the stemming algorithm defined by a snowball script.
NotContainedBy	Node that represents `Intervals.notContainedBy(IntervalsSource, IntervalsSource)`.
NotContainedByIntervalsSource
NotContainedByIntervalsSource.NotContainedByIterator
NotContaining	Node that represents `Intervals.notContaining(IntervalsSource, IntervalsSource)`.
NotContainingIntervalsSource
NotContainingIntervalsSource.NotContainingIterator
NotDocIdSet	This `DocIdSet` encodes the negation of another `DocIdSet`.
NoTokenFoundQueryNode	A `NoTokenFoundQueryNode` is used if a term is convert into no tokens by the tokenizer/lemmatizer/analyzer (null).
NotQuery	Factory for prohibited clauses
NotWithin	Node that represents `Intervals.notWithin(IntervalsSource, int, IntervalsSource)`.
NRTCachingDirectory	Wraps a RAM-resident directory around any provided delegate directory, to be used during NRT search.
NRTSuggester	NRTSuggester executes Top N search on a weighted FST specified by a `CompletionScorer`
NRTSuggester.PayLoadProcessor	Helper to encode/decode payload (surface + PAYLOAD_SEP + docID) output
NRTSuggester.ScoringPathComparator	Compares partial completion paths using `CompletionScorer.score(float, float)`, breaks ties comparing path inputs
NRTSuggesterBuilder	Builder for `NRTSuggester`
NRTSuggesterBuilder.Entry
NullFragmenter	`Fragmenter` implementation which does not fragment the text.
NumberDateFormat	This `Format` parses `Long` into date strings and vice-versa.
NumDocsValueSource	Returns the value of `IndexReader.numDocs()` for every document.
NumericComparator<T extends java.lang.Number>	Abstract numeric comparator for comparing numeric values.
NumericDocValues	A per-document numeric value.
NumericDocValuesField	Field that stores a per-document `long` value for scoring, sorting or value retrieval.
NumericDocValuesFieldUpdates	A `DocValuesFieldUpdates` which holds updates of documents, of a single `NumericDocValuesField`.
NumericDocValuesFieldUpdates.Iterator
NumericDocValuesFieldUpdates.SingleValueNumericDocValuesFieldUpdates
NumericDocValuesWriter	Buffers up pending long per doc, then flushes when segment flushes.
NumericDocValuesWriter.BufferedNumericDocValues
NumericDocValuesWriter.NumericDVs
NumericDocValuesWriter.SortingNumericDocValues
NumericPayloadTokenFilter	Assigns a payload to a token based on the `TypeAttribute`
NumericPayloadTokenFilterFactory	Factory for `NumericPayloadTokenFilter`.
NumericUtils	Helper APIs to encode numeric values as sortable bytes and vice-versa.
ObjectCursor<VType>	Forked from HPPC, holding int index and Object value.
OffHeapByteVectorValues	Read the vector values from the index input.
OffHeapByteVectorValues	Read the vector values from the index input.
OffHeapByteVectorValues.DenseOffHeapVectorValues
OffHeapByteVectorValues.DenseOffHeapVectorValues	Dense vector values that are stored off-heap.
OffHeapByteVectorValues.EmptyOffHeapVectorValues
OffHeapByteVectorValues.EmptyOffHeapVectorValues
OffHeapByteVectorValues.SparseOffHeapVectorValues
OffHeapByteVectorValues.SparseOffHeapVectorValues
OffHeapFloatVectorValues	Read the vector values from the index input.
OffHeapFloatVectorValues	Read the vector values from the index input.
OffHeapFloatVectorValues	Read the vector values from the index input.
OffHeapFloatVectorValues.DenseOffHeapVectorValues
OffHeapFloatVectorValues.DenseOffHeapVectorValues
OffHeapFloatVectorValues.DenseOffHeapVectorValues	Dense vector values that are stored off-heap.
OffHeapFloatVectorValues.EmptyOffHeapVectorValues
OffHeapFloatVectorValues.EmptyOffHeapVectorValues
OffHeapFloatVectorValues.EmptyOffHeapVectorValues
OffHeapFloatVectorValues.SparseOffHeapVectorValues
OffHeapFloatVectorValues.SparseOffHeapVectorValues
OffHeapFloatVectorValues.SparseOffHeapVectorValues
OffHeapFSTStore	Provides off heap storage of finite state machine (FST), using underlying index input instead of byte store on heap
OffHeapQuantizedByteVectorValues	Read the quantized vector values and their score correction values from the index input.
OffHeapQuantizedByteVectorValues.DenseOffHeapVectorValues	Dense vector values that are stored off-heap.
OffHeapQuantizedByteVectorValues.EmptyOffHeapVectorValues
OffHeapQuantizedByteVectorValues.SparseOffHeapVectorValues
OfflinePointReader	Reads points from disk in a fixed-with format, previously written with `OfflinePointWriter`.
OfflinePointReader.OfflinePointValue	Reusable implementation for a point value offline
OfflinePointWriter	Writes points to disk in a fixed-with format.
OfflineSorter	On-disk sorting of byte arrays.
OfflineSorter.BufferSize	A bit more descriptive unit for constructors.
OfflineSorter.ByteSequencesReader	Utility class to read length-prefixed byte[] entries from an input.
OfflineSorter.ByteSequencesWriter	Utility class to emit length-prefixed byte[] entries to an output stream for sorting.
OfflineSorter.FileAndTop
OfflineSorter.Partition	Holds one partition of items, either loaded into memory or based on a file.
OffsetAttribute	The start and end character offset of a Token.
OffsetAttributeImpl	Default implementation of `OffsetAttribute`.
OffsetIntervalsSource	Tracks a reference intervals source, and produces a pseudo-interval that appears either one position before or one position after each interval from the reference
OffsetIntervalsSource.OffsetIntervalIterator
OffsetLimitTokenFilter	This TokenFilter limits the number of tokens while indexing by adding up the current offset.
OffsetRange	A non-empty range of offset positions.
OffsetsEnum	An enumeration/iterator of a term and its offsets for use by `FieldHighlighter`.
OffsetsEnum.MultiOffsetsEnum	A view over several OffsetsEnum instances, merging them in-place
OffsetsEnum.OfMatchesIterator	Based on a `MatchesIterator`; does not look at submatches.
OffsetsEnum.OfMatchesIteratorWithSubs	Based on a `MatchesIterator` with submatches.
OffsetsEnum.OfMatchesIteratorWithSubs.CachedOE
OffsetsEnum.OfPostings	Based on a `PostingsEnum` -- the typical/standard OE impl.
OffsetsFromMatchIterator	This strategy retrieves offsets directly from `MatchesIterator`, if they are available, otherwise it falls back to using `OffsetsFromPositions`.
OffsetsFromPositions	This strategy applies to fields with stored positions but no offsets.
OffsetsFromTokens	This strategy works for fields where we know the match occurred but there are no known positions or offsets.
OffsetsFromValues	This strategy works for fields where we know the match occurred but there are no known positions or offsets.
OffsetsRetrievalStrategy	Determines how match offset regions are computed from `MatchesIterator`.
OffsetsRetrievalStrategySupplier	A per-field supplier of `OffsetsRetrievalStrategy`.
OneMergeWrappingMergePolicy	A wrapping merge policy that wraps the `MergePolicy.OneMerge` objects returned by the wrapped merge policy.
OnHeapFSTStore	Provides storage of finite state machine (FST), using byte array or byte store allocated on heap.
OnHeapHnswGraph	An `HnswGraph` where all nodes and connections are held in memory.
OnHeapHnswGraph.EntryNode
OpaqueQueryNode	A `OpaqueQueryNode` is used for specify values that are not supposed to be parsed by the parser.
OpenRangeQueryNodeProcessor	Processes `TermRangeQuery`s with open ranges.
OpenStringBuilder	A StringBuilder that allows one to access the array.
Operations	Automata operations.
Operations.PointTransitions
Operations.PointTransitionSet
Operations.TransitionList
Optimizer	The Optimizer class is a Trie that will be reduced (have empty rows removed).
Optimizer2	The Optimizer class is a Trie that will be reduced (have empty rows removed).
Or	Node that represents `Intervals.or(IntervalsSource...)`.
Ordered	Node that represents `Intervals.ordered(IntervalsSource...)`.
OrderedIntervalsSource
OrderedIntervalsSource.OrderedIntervalIterator
OrdinalMap	Maps per-segment ordinals to/from global ordinal space, using a compact packed-ints representation.
OrdinalMap.SegmentMap
OrdinalMap.TermsEnumPriorityQueue
OrdinalTranslatedKnnCollector	Wraps a provided KnnCollector object, translating the provided vectorId ordinal to a documentId
OrdsBlockTreeTermsReader	See `OrdsBlockTreeTermsWriter`.
OrdsBlockTreeTermsWriter	This is just like `Lucene90BlockTreeTermsWriter`, except it also stores a version per term, and adds a method to its TermsEnum implementation to seekExact only if the version is >= the specified version.
OrdsBlockTreeTermsWriter.FieldMetaData
OrdsBlockTreeTermsWriter.PendingBlock
OrdsBlockTreeTermsWriter.PendingEntry
OrdsBlockTreeTermsWriter.PendingTerm
OrdsBlockTreeTermsWriter.SubIndex
OrdsFieldReader	BlockTree's implementation of `Terms`.
OrdsIntersectTermsEnum
OrdsIntersectTermsEnumFrame
OrdsSegmentTermsEnum	Iterates through terms in this field.
OrdsSegmentTermsEnum.InputOutput	Holds a single input (IntsRef) + output pair.
OrdsSegmentTermsEnumFrame
OrdTermState	An ordinal based `TermState`
OrdToDocDISIReaderConfiguration	Configuration for `DirectMonotonicReader` and `IndexedDISI` for reading sparse vectors.
OrQuery	Factory for disjunctions
OrQueryNode	A `OrQueryNode` represents an OR boolean operation performed on a list of nodes.
Outputs<T>	Represents the outputs for an FST, providing the basic algebra required for building and traversing the FST.
OutputStreamDataOutput	A `DataOutput` wrapping a plain `OutputStream`.
OutputStreamIndexOutput	Implementation class for buffered `IndexOutput` that writes to an `OutputStream`.
OutputStreamIndexOutput.XBufferedOutputStream	This subclass is an optimization for writing primitives.
Overlapping	Node that represents `Intervals.overlapping(IntervalsSource, IntervalsSource)`.
OverlappingIntervalsSource
OverlaySingleDocTermsLeafReader	Overlays a 2nd LeafReader for the terms of one field, otherwise the primary reader is consulted.
Packed64	Space optimized random access capable array of values with a fixed number of bits/value.
Packed64SingleBlock	This class is similar to `Packed64` except that it trades space for speed by ensuring that a single block needs to be read/written in order to read/write a value.
Packed64SingleBlock.Packed64SingleBlock1
Packed64SingleBlock.Packed64SingleBlock10
Packed64SingleBlock.Packed64SingleBlock12
Packed64SingleBlock.Packed64SingleBlock16
Packed64SingleBlock.Packed64SingleBlock2
Packed64SingleBlock.Packed64SingleBlock21
Packed64SingleBlock.Packed64SingleBlock3
Packed64SingleBlock.Packed64SingleBlock32
Packed64SingleBlock.Packed64SingleBlock4
Packed64SingleBlock.Packed64SingleBlock5
Packed64SingleBlock.Packed64SingleBlock6
Packed64SingleBlock.Packed64SingleBlock7
Packed64SingleBlock.Packed64SingleBlock8
Packed64SingleBlock.Packed64SingleBlock9
PackedDataInput	A `DataInput` wrapper to read unaligned, variable-length packed integers.
PackedDataOutput	A `DataOutput` wrapper to write unaligned, variable-length packed integers.
PackedInts	Simplistic compression for array of unsigned long values.
PackedInts.Decoder	A decoder for packed integers.
PackedInts.Encoder	An encoder for packed integers.
PackedInts.Format	A format to write packed ints.
PackedInts.FormatAndBits	Simple class that holds a format and a number of bits per value.
PackedInts.Mutable	A packed integer array that can be modified.
PackedInts.MutableImpl
PackedInts.NullReader	A `PackedInts.Reader` which has all its values equal to 0 (bitsPerValue = 0).
PackedInts.Reader	A read-only random access array of positive integers.
PackedInts.ReaderImpl	A simple base for Readers that keeps track of valueCount and bitsPerValue.
PackedInts.ReaderIterator	Run-once iterator interface, to decode previously saved PackedInts.
PackedInts.ReaderIteratorImpl
PackedInts.Writer	A write-once Writer.
PackedLongValues	Utility class to compress integers into a `LongValues` instance.
PackedLongValues.Builder	A Builder for a `PackedLongValues` instance.
PackedReaderIterator
PackedTokenAttributeImpl	Default implementation of the common attributes used by Lucene: `CharTermAttribute` `TypeAttribute` `PositionIncrementAttribute` `PositionLengthAttribute` `OffsetAttribute` `TermFrequencyAttribute`
PackedWriter
PagedBytes	Represents a logical byte[] as a series of pages.
PagedBytes.Reader	Provides methods to read BytesRefs from a frozen PagedBytes.
PagedGrowableWriter	A `PagedGrowableWriter`.
PagedMutable	A `PagedMutable`.
PairOutputs<A,B>	An FST `Outputs` implementation, holding two other outputs.
PairOutputs.Pair<A,B>	Holds a single pair of two outputs.
ParallelCompositeReader	An `CompositeReader` which reads multiple, parallel indexes.
ParallelLeafReader	An `LeafReader` which reads multiple, parallel indexes.
ParallelLeafReader.ParallelFields
ParallelMatcher<T extends QueryMatch>	Matcher class that runs matching queries in parallel.
ParallelMatcher.MatcherTask
ParallelMatcher.ParallelMatcherFactory<T extends QueryMatch>
ParallelPostingsArray
ParentChildrenBlockJoinQuery	A query that returns all the matching child documents for a specific parent document indexed together in the same block.
ParseException	This exception is thrown when parse errors are encountered.
ParseException	This exception is thrown when parse errors are encountered.
ParseException	This exception is thrown when parse errors are encountered.
ParserException	Thrown when the xml queryparser encounters invalid syntax/configuration.
ParserExtension	This class represents an extension base class to the Lucene standard `QueryParser`.
PartitionMatcher<T extends QueryMatch>	A multi-threaded matcher that collects all possible matches in one pass, and then partitions them amongst a number of worker threads to perform the actual matching.
PartitionMatcher.MatchTask
PartitionMatcher.PartitionMatcherFactory<T extends QueryMatch>
PartOfSpeechAttribute	Attribute for `Token.getPartOfSpeech()`.
PartOfSpeechAttribute	Part of Speech attributes for Korean.
PartOfSpeechAttributeImpl	Attribute for `Token.getPartOfSpeech()`.
PartOfSpeechAttributeImpl	Part of Speech attributes for Korean.
Passage	A passage is a fragment of source text, scored and possibly with a list of sub-offsets (markers) to be highlighted.
Passage	Represents a passage (typically a sentence of the document).
PassageAdjuster	Adjusts the range of one or more passages over a given value.
PassageFormatter	Formats a collection of passages over a given string, cleaning up and resolving restrictions concerning overlaps, allowed sub-ranges over the input string and length restrictions.
PassageFormatter	Creates a formatted snippet from the top passages.
PassageFormatter.SlicePoint
PassageFormatter.SlicePoint.Type
PassageScorer	Ranks passages found by `UnifiedHighlighter`.
PassageSelector	Selects fragments of text that score best for the given set of highlight markers.
PathHierarchyTokenizer	Tokenizer for path-like hierarchies.
PathHierarchyTokenizerFactory	Factory for `PathHierarchyTokenizer`.
PathNode	SmartChineseAnalyzer internal node representation
PathQueryNode	A `PathQueryNode` is used to store queries like /company/USA/California /product/shoes/brown.
PathQueryNode.QueryText	Term text with a beginning and end position
PatternCaptureGroupFilterFactory	Factory for `PatternCaptureGroupTokenFilter`.
PatternCaptureGroupTokenFilter	CaptureGroup uses Java regexes to emit multiple tokens - one for each capture group in one or more patterns.
PatternConsumer	This interface is used to connect the XML pattern file parser to the hyphenation tree.
PatternKeywordMarkerFilter	Marks terms as keywords via the `KeywordAttribute`.
PatternParser	A SAX document handler to read and parse hyphenation patterns from a XML file.
PatternReplaceCharFilter	CharFilter that uses a regular expression for the target of replace string.
PatternReplaceCharFilterFactory	Factory for `PatternReplaceCharFilter`.
PatternReplaceFilter	A TokenFilter which applies a Pattern to each token in the stream, replacing match occurrences with the specified replacement string.
PatternReplaceFilterFactory	Factory for `PatternReplaceFilter`.
PatternTokenizer	This tokenizer uses regex pattern matching to construct distinct tokens for the input stream.
PatternTokenizerFactory	Factory for `PatternTokenizer`.
PatternTypingFilter	Set a type attribute to a parameterized value when tokens are matched by any of a several regex patterns.
PatternTypingFilter.PatternTypingRule	Value holding class for pattern typing rules.
PatternTypingFilterFactory	Provides a filter that will analyze tokens with the analyzer from an arbitrary field type.
PayloadAttribute	The payload of a Token.
PayloadAttributeImpl	Default implementation of `PayloadAttribute`.
PayloadDecoder	Defines a way of converting payloads to float values, for use by `PayloadScoreQuery`
PayloadEncoder	Mainly for use with the DelimitedPayloadTokenFilter, converts char buffers to `BytesRef`.
PayloadFilteredTermIntervalsSource
PayloadFunction	An abstract class that defines a way for PayloadScoreQuery instances to transform the cumulative effects of payload scores for a document.
PayloadHelper	Utility methods for encoding payloads.
PayloadMatcher	Defines an interface for testing if two payloads should be consider to match
PayloadMatcherFactory	Creates a payload matcher object based on a payload type and an operation.
PayloadMatcherFactory.EQPayloadMatcher
PayloadMatcherFactory.FloatPayloadMatcher
PayloadMatcherFactory.GTEFloatPayloadMatcher
PayloadMatcherFactory.GTEIntPayloadMatcher
PayloadMatcherFactory.GTEStringPayloadMatcher
PayloadMatcherFactory.GTFloatPayloadMatcher
PayloadMatcherFactory.GTIntPayloadMatcher
PayloadMatcherFactory.GTStringPayloadMatcher
PayloadMatcherFactory.IntPayloadMatcher
PayloadMatcherFactory.LTEFloatPayloadMatcher
PayloadMatcherFactory.LTEIntPayloadMatcher
PayloadMatcherFactory.LTEStringPayloadMatcher
PayloadMatcherFactory.LTFloatPayloadMatcher
PayloadMatcherFactory.LTIntPayloadMatcher
PayloadMatcherFactory.LTStringPayloadMatcher
PayloadMatcherFactory.StringPayloadMatcher
PayloadScoreQuery	A Query class that uses a `PayloadFunction` to modify the score of a wrapped SpanQuery
PayloadSpanCollector	SpanCollector for collecting payloads
PayloadSpanUtil	Experimental class to get set of payloads for most standard Lucene queries.
PendingDeletes	This class handles accounting and applying pending deletes for live segment readers
PendingSoftDeletes
PerFieldAnalyzerWrapper	This analyzer is used to facilitate scenarios where different fields require different analysis techniques.
PerFieldDocValuesFormat	Enables per field docvalues support.
PerFieldDocValuesFormat.ConsumerAndSuffix
PerFieldKnnVectorsFormat	Enables per field numeric vector support.
PerFieldKnnVectorsFormat.FieldsReader	VectorReader that can wrap multiple delegate readers, selected by field.
PerFieldKnnVectorsFormat.WriterAndSuffix
PerFieldMergeState	Utility class creating a new `MergeState` to be restricted to a set of fields.
PerFieldMergeState.FilterFieldInfos
PerFieldMergeState.FilterFieldsProducer
PerFieldPostingsFormat	Enables per field postings support.
PerFieldPostingsFormat.FieldsGroup	Group of fields written by one PostingsFormat
PerFieldPostingsFormat.FieldsGroup.Builder
PerFieldPostingsFormat.FieldsReader
PerFieldSimilarityWrapper	Provides the ability to use a different `Similarity` for different fields.
PersianAnalyzer	`Analyzer` for Persian.
PersianAnalyzer.DefaultSetHolder	Atomically loads the DEFAULT_STOP_SET in a lazy fashion once the outer class accesses the static final set the first time.;
PersianCharFilter	CharFilter that replaces instances of Zero-width non-joiner with an ordinary space.
PersianCharFilterFactory	Factory for `PersianCharFilter`.
PersianNormalizationFilter	A `TokenFilter` that applies `PersianNormalizer` to normalize the orthography.
PersianNormalizationFilterFactory	Factory for `PersianNormalizationFilter`.
PersianNormalizer	Normalizer for Persian.
PersianStemFilter	A `TokenFilter` that applies `PersianStemmer` to stem Persian words.
PersianStemFilterFactory	Factory for `PersianStemFilter`.
PersianStemmer	Stemmer for Persian.
PersistentSnapshotDeletionPolicy	A `SnapshotDeletionPolicy` which adds a persistence layer so that snapshots can be maintained across the life of an application.
PForUtil	Utility class to encode sequences of 128 small positive integers.
PForUtil	Utility class to encode sequences of 128 small positive integers.
PForUtil	Utility class to encode sequences of 128 small positive integers.
PhoneticFilter	Create tokens for phonetic matches.
PhoneticFilterFactory	Factory for `PhoneticFilter`.
Phrase	Node that represents `Intervals.phrase(String...)`.
PhraseHelper	Helps the `FieldOffsetStrategy` with position sensitive queries (e.g.
PhraseHelper.SingleFieldWithOffsetsFilterLeafReader	Needed to support the ability to highlight a query irrespective of the field a query refers to (aka requireFieldMatch=false).
PhraseHelper.SpanCollectedOffsetsEnum
PhraseMatcher	Base class for exact and sloppy phrase matching
PhrasePositions	Position of a term in a document that takes into account the term offset within the phrase.
PhraseQuery	A Query that matches documents containing a particular sequence of terms.
PhraseQuery.Builder	A builder for phrase queries.
PhraseQuery.PostingsAndFreq	Term postings and position information for phrase matching
PhraseQueryNodeBuilder	Builds a `PhraseQuery` object from a `TokenizedPhraseQueryNode` object.
PhraseQueue
PhraseScorer
PhraseSlopQueryNode	Query node for `PhraseQuery`'s slop factor.
PhraseSlopQueryNodeProcessor	This processor removes invalid `SlopQueryNode` objects in the query node tree.
PhraseWeight	Expert: Weight class for phrase matching
PhraseWildcardQuery	A generalized version of `PhraseQuery`, built with one or more `MultiTermQuery` that provides term expansions for multi-terms (one of the expanded terms must match).
PhraseWildcardQuery.Builder	Builds a `PhraseWildcardQuery`.
PhraseWildcardQuery.MultiTerm	Phrase term with expansions.
PhraseWildcardQuery.PhraseTerm	All `PhraseWildcardQuery.PhraseTerm` are light and immutable.
PhraseWildcardQuery.SingleTerm	Phrase term with no expansion.
PhraseWildcardQuery.TermBytesTermState	Holds a pair of term bytes - term state.
PhraseWildcardQuery.TermData	Holds the `TermState` for all the collected `Term`, for a specific phrase term, for all segments.
PhraseWildcardQuery.TermsData	Holds the `TermState` and `TermStatistics` for all the matched and collected `Term`, for all phrase terms, for all segments.
PhraseWildcardQuery.TermStats	Accumulates the doc freq and total term freq.
PhraseWildcardQuery.TestCounters	Test counters incremented when assertions are enabled.
PKIndexSplitter	Split an index based on a `Query`.
PKIndexSplitter.DocumentFilteredLeafIndexReader
Placeholder	Remove this file when adding back compat codecs
PlainTextDictionary	Dictionary represented by a text file.
Plane	We know about three kinds of planes.
PlanetModel	Holds mathematical constants associated with the model of a planet.
PlanetModel.DocValueEncoder	Utility class for encoding / decoding from lat/lon (decimal degrees) into sortable doc value numerics (integers)
PlanetObject	Relates all Geo3d shape with a specific `PlanetModel`.
Point	Represents a point on the earth's surface.
Point2D	2D point implementation containing geo spatial logic.
PointInGeo3DShapeQuery	Finds all previously indexed points that fall within the specified polygon.
PointInSetIncludingScoreQuery
PointInSetIncludingScoreQuery.Stream
PointInSetQuery	Abstract query class to find all documents whose single or multi-dimensional point values, previously indexed with e.g.
PointInSetQuery.Stream	Iterator of encoded point values.
PointInShapeIntersectVisitor
PointQueryNode	This query node represents a field query that holds a point value.
PointQueryNodeProcessor	This processor is used to convert `FieldQueryNode`s to `PointRangeQueryNode`s.
PointRangeQuery	Abstract class for range queries against single or multidimensional points such as `IntPoint`.
PointRangeQueryBuilder	Creates a range query across 1D `PointValues`.
PointRangeQueryNode	This query node represents a range query composed by `PointQueryNode` bounds, which means the bound values are `Number`s.
PointRangeQueryNodeBuilder	Builds `PointValues` range queries out of `PointRangeQueryNode`s.
PointRangeQueryNodeProcessor	This processor is used to convert `TermRangeQueryNode`s to `PointRangeQueryNode`s.
PointReader	One pass iterator through all points previously written with a `PointWriter`, abstracting away whether points are read from (offline) disk or simple arrays in heap.
PointsConfig	This class holds the configuration used to parse numeric queries and create `PointValues` queries.
PointsConfigListener	This listener is used to listen to `FieldConfig` requests in `QueryConfigHandler` and add `StandardQueryConfigHandler.ConfigurationKeys.POINTS_CONFIG` based on the `StandardQueryConfigHandler.ConfigurationKeys.POINTS_CONFIG_MAP` set in the `QueryConfigHandler`.
PointsFormat	Encodes/decodes indexed points.
PointsReader	Abstract API to visit point values.
PointsWriter	Abstract API to write points
PointValue	Represents a dimensional point value written in the BKD tree.
PointValues	Access to indexed numeric values.
PointValues.IntersectVisitor	We recurse the `PointValues.PointTree`, using a provided instance of this to guide the recursion.
PointValues.PointTree	Basic operations to read the KD-tree.
PointValues.Relation	Used by `PointValues.intersect(org.apache.lucene.index.PointValues.IntersectVisitor)` to check how each recursive cell corresponds to the query.
PointValuesWriter	Buffers up pending byte[][] value(s) per doc, then flushes when segment flushes.
PointValuesWriter.MutableSortingPointValues
PointWriter	Appends many points, and then at the end provides a `PointReader` to iterate those points.
PolishAnalyzer	`Analyzer` for Polish.
PolishAnalyzer.DefaultsHolder	Atomically loads the DEFAULT_STOP_SET in a lazy fashion once the outer class accesses the static final set the first time.;
Polygon	Represents a closed polygon on the earth's surface.
Polygon2D	2D polygon implementation represented as a balanced interval tree of edges.
PorterStemFilter	Transforms the token stream as per the Porter stemming algorithm.
PorterStemFilterFactory	Factory for `PorterStemFilter`.
PorterStemmer	Stemmer, implementing the Porter Stemming Algorithm
PorterStemmer	This class implements the stemming algorithm defined by a snowball script.
PortugueseAnalyzer	`Analyzer` for Portuguese.
PortugueseAnalyzer.DefaultSetHolder	Atomically loads the DEFAULT_STOP_SET in a lazy fashion once the outer class accesses the static final set the first time.;
PortugueseLightStemFilter	A `TokenFilter` that applies `PortugueseLightStemmer` to stem Portuguese words.
PortugueseLightStemFilterFactory	Factory for `PortugueseLightStemFilter`.
PortugueseLightStemmer	Light Stemmer for Portuguese
PortugueseMinimalStemFilter	A `TokenFilter` that applies `PortugueseMinimalStemmer` to stem Portuguese words.
PortugueseMinimalStemFilterFactory	Factory for `PortugueseMinimalStemFilter`.
PortugueseMinimalStemmer	Minimal Stemmer for Portuguese
PortugueseStemFilter	A `TokenFilter` that applies `PortugueseStemmer` to stem Portuguese words.
PortugueseStemFilterFactory	Factory for `PortugueseStemFilter`.
PortugueseStemmer	Portuguese stemmer implementing the RSLP (Removedor de Sufixos da Lingua Portuguesa) algorithm.
PortugueseStemmer	This class implements the stemming algorithm defined by a snowball script.
POS	Part of speech classification for Korean based on Sejong corpus classification.
POS.Tag	Part of speech tag for Korean based on Sejong corpus classification.
POS.Type	The type of the token.
PositionIncrementAttribute	Determines the position of this token relative to the previous Token in a TokenStream, used in phrase searching.
PositionIncrementAttributeImpl	Default implementation of `PositionIncrementAttribute`.
PositionLengthAttribute	Determines how many positions this token spans.
PositionLengthAttributeImpl	Default implementation of `PositionLengthAttribute`.
PositionSpan	Utility class to record Positions Spans
PositiveIntOutputs	An FST `Outputs` implementation where each output is a non-negative long value.
PositiveScoresOnlyCollector	A `Collector` implementation which wraps another `Collector` and makes sure only documents with scores > 0 are collected.
PostingsEnum	Iterates through the postings.
PostingsFormat	Encodes/decodes terms, postings, and proximity data.
PostingsFormat.Holder	This static holder class prevents classloading deadlock by delaying init of postings formats until needed.
PostingsOffsetStrategy	Uses offsets in postings -- `IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS`.
PostingsReaderBase	The core terms dictionaries (BlockTermsReader, BlockTreeTermsReader) interact with a single instance of this class to manage creation of `PostingsEnum` and `PostingsEnum` instances.
PostingsUtil	Utility class to encode/decode postings block.
PostingsWithTermVectorsOffsetStrategy	Like `PostingsOffsetStrategy` but also uses term vectors (only terms needed) for multi-term queries.
PostingsWriterBase	Class that plugs into term dictionaries, such as `Lucene90BlockTreeTermsWriter`, and handles writing postings.
PowFloatFunction	Function to raise the base "a" to the power "b"
PrecedenceQueryNodeProcessorPipeline	This processor pipeline extends `StandardQueryNodeProcessorPipeline` and enables boolean precedence on it.
PrecedenceQueryParser	This query parser works exactly as the standard query parser ( `StandardQueryParser` ), except that it respect the boolean precedence, so <a AND b OR c AND d> is parsed to <(+a +b) (+c +d)> instead of <+a +b +c +d>.
PrefixCodedTerms	Prefix codes term instances (prefixes are shared).
PrefixCodedTerms.Builder	Builds a PrefixCodedTerms: call add repeatedly, then finish.
PrefixCodedTerms.TermIterator	An iterator over the list of terms stored in a `PrefixCodedTerms`.
PrefixCompletionQuery	A `CompletionQuery` which takes an `Analyzer` to analyze the prefix of the query term.
PrefixQuery	A Query that matches documents containing terms with a specified prefix.
PrefixWildcardQueryNode	A `PrefixWildcardQueryNode` represents wildcardquery that matches abc* or *.
PrefixWildcardQueryNodeBuilder	Builds a `PrefixQuery` object from a `PrefixWildcardQueryNode` object.
Presearcher	A Presearcher is used by the Monitor to reduce the number of queries actually run against a Document.
PresearcherMatch<T extends QueryMatch>	Wraps a `QueryMatch` with information about which queries were selected by the presearcher
PresearcherMatches<T extends QueryMatch>	Wraps a `MultiMatchingQueries` with information on which presearcher queries were selected
PrintStreamInfoStream	InfoStream implementation over a `PrintStream` such as `System.out`.
PriorityQueue<T>	A priority queue maintains a partial ordering of its elements such that the least element can always be found in constant time.
ProductFloatFunction	`ProductFloatFunction` returns the product of its components.
ProfilerCollector	This class wraps a Collector and times the execution of: - setScorer() - collect() - doSetNextReader() - needsScores()
ProfilerCollectorResult	Public class for profiled timings of the Collectors used in the search.
ProfilerCollectorWrapper	A collector that profiles how much time is spent calling it.
ProtectedTermFilter	A ConditionalTokenFilter that only applies its wrapped filters to tokens that are not contained in a protected set.
ProtectedTermFilterFactory	Factory for a `ProtectedTermFilter`
ProximityQueryNode	A `ProximityQueryNode` represents a query where the terms should meet specific distance conditions.
ProximityQueryNode.ProximityType	utility class containing the distance condition and number
ProximityQueryNode.Type	Distance condition: PARAGRAPH, SENTENCE, or NUMBER
Pruning	Controls `LeafFieldComparator` how to skip documents
PushPostingsWriterBase	Extension of `PostingsWriterBase`, adding a push API for writing each element of the postings.
QuantizedByteVectorValues	A version of `ByteVectorValues`, but additionally retrieving score correction offset for Scalar quantization scores.
QuantizedVectorsReader	Quantized vector reader
Query	The abstract base class for queries.
QueryAnalyzer	Class to analyze and extract terms from a lucene query, to be used by a `Presearcher` in indexing.
QueryAutoStopWordAnalyzer	An `Analyzer` used primarily at query time to wrap another analyzer and provide a layer of protection which prevents very common words from being passed into queries.
QueryBitSetProducer	A `BitSetProducer` that wraps a query and caches matching `BitSet`s per segment.
QueryBuilder	This interface is used by implementors classes that builds some kind of object from a query tree.
QueryBuilder	Implemented by objects that produce Lucene Query objects from XML streams.
QueryBuilder	Creates queries from the `Analyzer` chain.
QueryBuilder.TermAndBoost	Wraps a term and boost
QueryBuilderFactory	Factory for `QueryBuilder`
QueryCache	A cache for queries.
QueryCacheEntry
QueryCachingPolicy	A policy defining which filters should be cached.
QueryConfigHandler	This class can be used to hold any query configuration and no field configuration.
QueryDecomposer	Split a disjunction query into its consituent parts, so that they can be indexed and run separately in the Monitor.
QueryDocValues
QueryIndex
QueryIndex.CachePopulator
QueryIndex.DataValues
QueryIndex.FIELDS
QueryIndex.QueryBuilder
QueryIndex.QueryCollector
QueryIndex.QueryTermFilter
QueryMatch	Represents a match for a specific query and document
QueryNode	A `QueryNode` is a interface implemented by all nodes on a QueryNode tree.
QueryNodeError	Error class with NLS support
QueryNodeException	This exception should be thrown if something wrong happens when dealing with `QueryNode`s.
QueryNodeImpl	A `QueryNodeImpl` is the default implementation of the interface `QueryNode`
QueryNodeOperation	Allow joining 2 QueryNode Trees, into one.
QueryNodeOperation.ANDOperation
QueryNodeParseException	This should be thrown when an exception happens during the query parsing from string to the query node tree.
QueryNodeProcessor	A `QueryNodeProcessor` is an interface for classes that process a `QueryNode` tree.
QueryNodeProcessorImpl	This is a default implementation for the `QueryNodeProcessor` interface, it's an abstract class, so it should be extended by classes that want to process a `QueryNode` tree.
QueryNodeProcessorImpl.ChildrenList
QueryNodeProcessorPipeline	A `QueryNodeProcessorPipeline` class should be used to build a query node processor pipeline.
QueryParser	This class is generated by JavaCC.
QueryParser	This class is generated by JavaCC.
QueryParser.JJCalls
QueryParser.JJCalls
QueryParser.LookaheadSuccess
QueryParser.LookaheadSuccess
QueryParser.Operator	The default operator for parsing queries.
QueryParserBase	This class is overridden by QueryParser in QueryParser.jj and acts to separate the majority of the Java code from the .jj grammar file.
QueryParserConstants	Token literal values and constants.
QueryParserConstants	Token literal values and constants.
QueryParserHelper	This class is a helper for the query parser framework, it does all the three query parser phrases at once: text parsing, query processing and query building.
QueryParserMessages	Flexible Query Parser message bundle class
QueryParserTokenManager	Token Manager.
QueryParserTokenManager	Token Manager.
QueryParserUtil	This class defines utility methods to (help) parse query strings into `Query` objects.
QueryProfilerBreakdown	A record of timings for the various operations that may happen during query execution.
QueryProfilerIndexSearcher	An extension of `IndexSearcher` that records profile information for all queries it executes.
QueryProfilerResult	This class is the internal representation of a profiled Query, corresponding to a single node in the query tree.
QueryProfilerScorer	`Scorer` wrapper that will compute how much time is spent on moving the iterator, confirming matches and computing scores.
QueryProfilerTimer	Helps measure how much time is spent running some methods.
QueryProfilerTimingType	This enum breaks down the query into different sections to describe what was timed.
QueryProfilerTree	This class tracks the dependency tree for queries (scoring and rewriting) and generates `QueryProfilerBreakdown` for each node in the tree.
QueryProfilerWeight	Weight wrapper that will compute how much time it takes to build the `Scorer` and then return a `Scorer` that is wrapped in order to compute timings as well.
QueryRescorer	A `Rescorer` that uses a provided Query to assign scores to the first-pass hits.
QueryScorer	`Scorer` implementation which scores text fragments by the number of unique query terms found.
QueryTermExtractor	Utility class used to extract the terms used in a query, plus any weights.
QueryTermExtractor.BoostedTermExtractor
QueryTermScorer	`Scorer` implementation which scores text fragments by the number of unique query terms found.
QueryTimeListener	Notified of the time it takes to run individual queries against a set of documents
QueryTimeout	Query timeout abstraction that controls whether a query should continue or be stopped.
QueryTimeoutImpl	An implementation of `QueryTimeout` that can be used by the `ExitableDirectoryReader` class to time out and exit out when a query takes a long time to rewrite.
QueryTree	A representation of a node in a query tree
QueryTree.ConjunctionQueryTree
QueryTree.DisjunctionQueryTree
QueryTreeBuilder	This class should be used when there is a builder for each type of node.
QueryValueSource	`QueryValueSource` returns the relevance score of the query
QueryVisitor	Allows recursion through a query tree
QuotedFieldQueryNode	A `QuotedFieldQueryNode` represents phrase query.
RadixSelector	Radix selector.
RAFDirectory	A straightforward implementation of `FSDirectory` using java.io.RandomAccessFile.
RAFDirectory.RAFIndexInput	Reads bytes with `RandomAccessFile.seek(long)` followed by `RandomAccessFile.read(byte[], int, int)`.
RamUsageEstimator	Estimates the size (memory representation) of Java objects.
RamUsageEstimator.RamUsageQueryVisitor
RamUsageUtil	Utility methods to estimate the RAM usage of objects.
RandomAccessInput	Random Access Index API.
RandomAccessQuantizedByteVectorValues	Random access values for `byte[]`, but also includes accessing the score correction constant for the current vector in the buffer.
RandomAccessVectorValues	Provides random access to vectors by dense ordinal.
RandomAccessVectorValues.Bytes	Byte vector values.
RandomAccessVectorValues.Floats	Float vector values.
RandomVectorScorer	A `RandomVectorScorer` for scoring random nodes in batches against an abstract query.
RandomVectorScorer.AbstractRandomVectorScorer	Creates a default scorer for random access vectors.
RandomVectorScorerSupplier	A supplier that creates `RandomVectorScorer` from an ordinal.
RangeFieldQuery	Query class for searching `RangeField` types by a defined `PointValues.Relation`.
RangeFieldQuery.QueryType	Used by `RangeFieldQuery` to check how each internal or leaf node relates to the query.
RangeMapFloatFunction	`RangeMapFloatFunction` implements a map function over another `ValueSource` whose values fall within min and max inclusive to target.
RangeQueryBuilder	Builder for `TermRangeQuery`
RangeQueryNode<T extends FieldValuePairQueryNode<?>>	This interface should be implemented by a `QueryNode` that represents some kind of range query.
RateLimitedIndexOutput	A `rate limiting` `IndexOutput`
RateLimiter	Abstract base class to rate limit IO.
RateLimiter.SimpleRateLimiter	Simple class to rate limit IO.
ReaderManager	Utility class to safely share `DirectoryReader` instances across multiple threads, while periodically reopening.
ReaderPool	Holds shared SegmentReader instances.
ReadersAndUpdates
ReadersAndUpdates.MergedDocValues<DocValuesInstance extends DocValuesIterator>	This class merges the current on-disk DV with an incoming update DV instance and merges the two instances giving the incoming update precedence in terms of values, in other words the values of the update always wins over the on-disk version.
ReaderSlice	Subreader slice from a parent composite reader.
ReaderUtil	Common util methods for dealing with `IndexReader`s and `IndexReaderContext`s.
ReadingAttribute	Attribute for Kuromoji reading data
ReadingAttribute	Attribute for Korean reading data
ReadingAttributeImpl	Attribute for Kuromoji reading data
ReadingAttributeImpl	Attribute for Korean reading data
ReadonlyQueryIndex
ReadonlyQueryIndex.LazyMonitorQueryCollector	A Collector that decodes the stored query for each document hit reparsing them everytime.
ReadWriteDataOutput	An adapter class to use `ByteBuffersDataOutput` as a `FSTReader`.
ReciprocalFloatFunction	`ReciprocalFloatFunction` implements a reciprocal function f(x) = a/(mx+b), based on the float value of a field or function as exported by `ValueSource`.
Rectangle	Represents a lat/lon rectangle.
Rectangle2D	2D rectangle implementation containing cartesian spatial logic.
RecyclingByteBlockAllocator	A `ByteBlockPool.Allocator` implementation that recycles unused byte blocks in a buffer and reuses them in subsequent calls to `RecyclingByteBlockAllocator.getByteBlock()`.
RecyclingIntBlockAllocator	A `IntBlockPool.Allocator` implementation that recycles unused int blocks in a buffer and reuses them in subsequent calls to `RecyclingIntBlockAllocator.getIntBlock()`.
Reduce	The Reduce object is used to remove gaps in a Trie which stores a dictionary.
RefCount<T>	Manages reference counting for a given object.
ReferenceManager<G>	Utility class to safely share instances of a certain type across multiple threads, while periodically refreshing them.
ReferenceManager.RefreshListener	Use to receive notification when a refresh has finished.
RegexCompletionQuery	A `CompletionQuery` which takes a regular expression as the prefix of the query term.
RegExp	Regular Expression extension to `Automaton`.
RegExp.Kind	The type of expression represented by a RegExp node.
RegExp.MakeRegexGroup	Custom Functional Interface for a Supplying methods with signature of RegExp(int int1, RegExp exp1, RegExp exp2)
RegexpQuery	A fast regular expression query based on the `org.apache.lucene.util.automaton` package.
RegexpQueryHandler	A query handler implementation that matches Regexp queries by indexing regex terms by their longest static substring, and generates ngrams from Document tokens to match them.
RegexpQueryNode	A `RegexpQueryNode` represents `RegexpQuery` query Examples: /[a-z]\|[0-9]/
RegexpQueryNodeBuilder	Builds a `RegexpQuery` object from a `RegexpQueryNode` object.
RegexpQueryNodeProcessor	Processor for Regexp queries.
RelativeIterator
RemoveDeletedQueryNodesProcessor	A `QueryNodeProcessorPipeline` class removes every instance of `DeletedQueryNode` from a query node tree.
RemoveDuplicatesTokenFilter	A TokenFilter which filters out Tokens at the same position and Term text as the previous token in the stream.
RemoveDuplicatesTokenFilterFactory	Factory for `RemoveDuplicatesTokenFilter`.
RemoveEmptyNonLeafQueryNodeProcessor	This processor removes every `QueryNode` that is not a leaf and has not children.
RepeatingIntervalsSource	Generates an iterator that spans repeating instances of a sub-iterator, avoiding minimization.
RepeatingIntervalsSource.DuplicateIntervalIterator
RepeatingIntervalsSource.DuplicateMatchesIterator
RepEntry
ReqExclBulkScorer
ReqExclScorer	A Scorer for queries with a required subscorer and an excluding (prohibited) sub `Scorer`.
ReqOptSumScorer	A Scorer for queries with a required part and an optional part.
Rescorer	Re-scores the topN results (`TopDocs`) from an original query.
ResourceLoader	Abstraction for loading resources (streams, files, and classes).
ResourceLoaderAware	Interface for a component that needs to be initialized by an implementation of `ResourceLoader`.
ReusableStringReader	Internal class to enable reuse of the string reader by `Analyzer.tokenStream(String,String)`
ReverseBytesReader	Reads in reverse from a single byte[].
ReversePathHierarchyTokenizer	Tokenizer for domain-like hierarchies.
ReverseRandomAccessReader	Implements reverse read from a RandomAccessInput.
ReverseStringFilter	Reverse token string, for example "country" => "yrtnuoc".
ReverseStringFilterFactory	Factory for `ReverseStringFilter`.
RewriteQuery<SQ extends SrndQuery>
RoaringDocIdSet	`DocIdSet` implementation inspired from http://roaringbitmap.org/
RoaringDocIdSet.Builder	A builder of `RoaringDocIdSet`s.
RoaringDocIdSet.ShortArrayDocIdSet	`DocIdSet` implementation that can store documents up to 2^16-1 in a short[].
RollingBuffer<T extends RollingBuffer.Resettable>	Acts like forever growing T[], but internally uses a circular buffer to reuse instances of T.
RollingBuffer.Resettable	Implement to reset an instance
RollingCharBuffer	Acts like a forever growing char[] as you read characters into it from the provided reader, but internally it uses a circular buffer to only hold the characters that haven't been freed yet.
RomanianAnalyzer	`Analyzer` for Romanian.
RomanianAnalyzer.DefaultSetHolder	Atomically loads the DEFAULT_STOP_SET in a lazy fashion once the outer class accesses the static final set the first time.;
RomanianStemmer	This class implements the stemming algorithm defined by a snowball script.
Root<T extends java.lang.CharSequence>
Row	The Row class represents a row in a matrix representation of a trie.
RSLPStemmerBase	Base class for stemmers that use a set of RSLP-like stemming steps.
RSLPStemmerBase.Rule	A basic rule, with no exceptions.
RSLPStemmerBase.RuleWithSetExceptions	A rule with a set of whole-word exceptions.
RSLPStemmerBase.RuleWithSuffixExceptions	A rule with a set of exceptional suffixes.
RSLPStemmerBase.Step	A step containing a list of rules.
RunAutomaton	Finite-state automaton with fast run operation.
RussianAnalyzer	`Analyzer` for Russian language.
RussianAnalyzer.DefaultSetHolder
RussianLightStemFilter	A `TokenFilter` that applies `RussianLightStemmer` to stem Russian words.
RussianLightStemFilterFactory	Factory for `RussianLightStemFilter`.
RussianLightStemmer	Light Stemmer for Russian.
RussianStemmer	This class implements the stemming algorithm defined by a snowball script.
SameThreadExecutorService	An `ExecutorService` that executes tasks immediately in the calling thread during submit.
ScalarQuantizedVectorScorer	Default scalar quantized implementation of `FlatVectorsScorer`.
ScalarQuantizedVectorScorer.ScalarQuantizedRandomVectorScorerSupplier	Quantized vector scorer supplier
ScalarQuantizedVectorSimilarity	Calculates and adjust the scores correctly for quantized vectors given the scalar quantization parameters
ScalarQuantizedVectorSimilarity.ByteVectorComparator	Compares two byte vectors
ScalarQuantizedVectorSimilarity.DotProduct	Calculates dot product on quantized vectors, applying the appropriate corrections
ScalarQuantizedVectorSimilarity.Euclidean	Calculates euclidean distance on quantized vectors, applying the appropriate corrections
ScalarQuantizedVectorSimilarity.MaximumInnerProduct	Calculates max inner product on quantized vectors, applying the appropriate corrections
ScalarQuantizer	Will scalar quantize float vectors into `int8` byte values.
ScalarQuantizer.FloatSelector
ScalarQuantizer.OnlineMeanAndVar
ScalarQuantizer.ScoreDocsAndScoreVariance
ScalarQuantizer.ScoreErrorCorrelator	This class is used to correlate the scores of the nearest neighbors with the errors in the scores.
ScaleFloatFunction	Scales values to be between min and max.
ScaleFloatFunction.ScaleInfo
ScandinavianFoldingFilter	This filter folds Scandinavian characters åÅäæÄÆ->a and öÖøØ->o.
ScandinavianFoldingFilterFactory	Factory for `ScandinavianFoldingFilter`.
ScandinavianNormalizationFilter	This filter normalize use of the interchangeable Scandinavian characters æÆäÄöÖøØ and folded variants (aa, ao, ae, oe and oo) by transforming them to åÅæÆøØ.
ScandinavianNormalizationFilterFactory	Factory for `ScandinavianNormalizationFilter`.
ScandinavianNormalizer	This Normalizer does the heavy lifting for a set of Scandinavian normalization filters, normalizing use of the interchangeable Scandinavian characters æÆäÄöÖøØ and folded variants (aa, ao, ae, oe and oo) by transforming them to åÅæÆøØ.
ScandinavianNormalizer.Foldings	List of possible foldings that can be used when configuring the filter
Scorable	Allows access to the score of a Query
Scorable.ChildScorable	A child Scorer and its relationship to its parent.
ScoreAndDoc	Used by `BulkScorer`s that need to pass a `Scorable` to `LeafCollector.setScorer(org.apache.lucene.search.Scorable)`.
ScoreCachingWrappingScorer	A `Scorer` which wraps another scorer and caches the score of the current document.
ScoreDoc	Holds one hit in `TopDocs`.
ScoreMode	How to aggregate multiple child hit scores into a single parent score.
ScoreMode	Different modes of search.
ScoreOrderFragmentsBuilder	An implementation of FragmentsBuilder that outputs score-order fragments.
ScoreOrderFragmentsBuilder.ScoreComparator	Comparator for `FieldFragList.WeightedFragInfo` by boost, breaking ties by offset.
Scorer	A Scorer is responsible for scoring a stream of tokens.
Scorer	Expert: Common scoring functionality for different types of queries.
ScorerSupplier	A supplier of `Scorer`.
ScorerUtil	Util class for Scorer related methods
ScoringMatch	A QueryMatch that reports scores for each match
ScoringRewrite<B>	Base rewrite method that translates each term into a query, and keeps the scores as computed by the query.
ScoringRewrite.TermFreqBoostByteStart	Special implementation of BytesStartArray that keeps parallel arrays for boost and docFreq
ScriptAttribute	This attribute stores the UTR #24 script value for a token of text.
ScriptAttributeImpl	Implementation of `ScriptAttribute` that stores the script as an integer.
ScriptIterator	An iterator that locates ISO 15924 script boundaries in text.
SearcherFactory	Factory class used by `SearcherManager` to create new IndexSearchers.
SearcherLifetimeManager	Keeps track of current plus old IndexSearchers, closing the old ones once they have timed out.
SearcherLifetimeManager.PruneByAge	Simple pruner that drops any searcher older by more than the specified seconds, than the newest searcher.
SearcherLifetimeManager.Pruner	See `SearcherLifetimeManager.prune(org.apache.lucene.search.SearcherLifetimeManager.Pruner)`.
SearcherLifetimeManager.SearcherTracker
SearcherManager	Utility class to safely share `IndexSearcher` instances across multiple threads, while periodically reopening.
SearchGroup<T>	Represents a group that is found during the first pass search.
SearchGroup.GroupComparator<T>
SearchGroup.GroupMerger<T>
SearchGroup.MergedGroup<T>
SearchGroup.ShardIter<T>
SecondPassGroupingCollector<T>	SecondPassGroupingCollector runs over an already collected set of groups, further applying a `GroupReducer` to each group
SeekingTermSetTermsEnum	A filtered TermsEnum that uses a BytesRefHash as a filter
SegGraph	Graph representing possible tokens at each start offset in the sentence.
SegmentCacheable	Interface defining whether or not an object can be cached against a `LeafReader`
SegmentCommitInfo	Embeds a [read-only] SegmentInfo and adds per-commit fields.
SegmentCoreReaders	Holds core readers that are shared (unchanged) when SegmentReader is cloned or reopened
SegmentDocValues	Manages the `DocValuesProducer` held by `SegmentReader` and keeps track of their reference counting.
SegmentDocValuesProducer	Encapsulates multiple producers when there are docvalues updates as one producer
SegmentInfo	Information about a segment such as its name, directory, and files related to the segment.
SegmentInfoFormat	Expert: Controls the format of the `SegmentInfo` (segment metadata file).
SegmentInfos	A collection of segmentInfo objects with methods for operating on those segments in relation to the file system.
SegmentInfos.FindSegmentsFile<T>	Utility class for executing code that needs to do something with the current segments file.
SegmentingTokenizerBase	Breaks text into sentences with a `BreakIterator` and allows subclasses to decompose these sentences into words.
SegmentMerger	The SegmentMerger class combines two or more Segments, represented by an IndexReader, into a single Segment.
SegmentMerger.Merger
SegmentMerger.VoidMerger
SegmentReader	IndexReader implementation over a single segment.
SegmentReaderAccess	Access to `SegmentReader` internals exposed to the test framework.
SegmentReadState	Holder class for common parameters used during read.
SegmentTermsEnum	Iterates through terms in this field.
SegmentTermsEnum	Iterates through terms in this field.
SegmentTermsEnum.OutputAccumulator
SegmentTermsEnumFrame
SegmentTermsEnumFrame
SegmentWriteState	Holder class for common parameters used during write.
SegToken	SmartChineseAnalyzer internal token
SegTokenFilter	Filters a `SegToken` by converting full-width latin to half-width, then lowercasing latin.
SegTokenPair	A pair of tokens in `SegGraph`
Selector	An implementation of a selection algorithm, ie.
SentenceAttribute	This attribute tracks what sentence a given token belongs to as well as potentially other sentence specific attributes.
SentenceAttributeImpl	Default implementation of `SentenceAttribute`.
SentinelIntSet	A native int hash-based set where one value is reserved to mean "EMPTY" internally.
SerbianAnalyzer	`Analyzer` for Serbian.
SerbianAnalyzer.DefaultSetHolder	Atomically loads the DEFAULT_STOP_SET in a lazy fashion once the outer class accesses the static final set the first time.;
SerbianNormalizationFilter	Normalizes Serbian Cyrillic and Latin characters to "bald" Latin.
SerbianNormalizationFilterFactory	Factory for `SerbianNormalizationFilter`.
SerbianNormalizationRegularFilter	Normalizes Serbian Cyrillic to Latin.
SerbianStemmer	This class implements the stemming algorithm defined by a snowball script.
SerializableObject	Indicates that a geo3d object can be serialized and deserialized.
SerialMergeScheduler	A `MergeScheduler` that simply does each merge sequentially, using the current thread.
SetKeywordMarkerFilter	Marks terms as keywords via the `KeywordAttribute`.
SetOnce<T>	A convenient class which offers a semi-immutable object wrapper implementation which allows one to set the value of an object exactly once, and retrieve it many times.
SetOnce.AlreadySetException	Thrown when `SetOnce.set(Object)` is called more than once.
SetOnce.Wrapper<T>	Holding object and marking that it was already set
ShapeDocValues	A binary doc values format representation for `LatLonShape` and `XYShape`
ShapeDocValues.Encoder
ShapeDocValues.Reader	Reads values from a ShapeDocValues Field
ShapeDocValuesField	A doc values field for `LatLonShape` and `XYShape` that uses `ShapeDocValues` as the underlying binary doc value format.
ShapeField	A base shape utility class used for both LatLon (spherical) and XY (cartesian) shape fields.
ShapeField.DecodedTriangle	Represents a encoded triangle using `ShapeField.decodeTriangle(byte[], DecodedTriangle)`.
ShapeField.DecodedTriangle.TYPE	type of triangle
ShapeField.QueryRelation	Query Relation Types *
ShapeField.Triangle	polygons are decomposed into tessellated triangles using `Tessellator` these triangles are encoded and inserted as separate indexed POINT fields
ShingleAnalyzerWrapper	A ShingleAnalyzerWrapper wraps a `ShingleFilter` around another `Analyzer`.
ShingleFilter	A ShingleFilter constructs shingles (token n-grams) from a token stream.
ShingleFilter.InputWindowToken
ShingleFilterFactory	Factory for `ShingleFilter`.
SidedPlane	Combination of a plane, and a sign value indicating what evaluation values are on the correct side of the plane.
Similarity	Similarity defines the components of Lucene scoring.
Similarity.SimScorer	Stores the weight for a query across the indexed collection.
SimilarityBase	A subclass of `Similarity` that provides a simplified API for its descendants.
SimpleAnalyzer	An `Analyzer` that filters `LetterTokenizer` with `LowerCaseFilter`
SimpleBindings	Simple class that binds expression variable names to `DoubleValuesSource`s or other `Expression`s.
SimpleBoolFunction	`BoolFunction` implementation which applies an extendible boolean function to the values of a single wrapped `ValueSource`.
SimpleBoundaryScanner	Simple boundary scanner implementation that divides fragments based on a set of separator characters.
SimpleCollector	Base `Collector` implementation that is used to collect all contexts.
SimpleFieldComparator<T>	Base `FieldComparator` implementation that is used for all contexts.
SimpleFieldFragList	A simple implementation of `FieldFragList`.
SimpleFloatFunction	A simple float function with a single argument
SimpleFragListBuilder	A simple implementation of `FragListBuilder`.
SimpleFragmenter	`Fragmenter` implementation which breaks text up into same-size fragments with no concerns over spotting sentence boundaries.
SimpleFragmentsBuilder	A simple implementation of FragmentsBuilder.
SimpleFSLockFactory	Implements `LockFactory` using `Files.createFile(java.nio.file.Path, java.nio.file.attribute.FileAttribute<?>...)`.
SimpleFSLockFactory.SimpleFSLock
SimpleGeoJSONPolygonParser	Does minimal parsing of a GeoJSON object, to extract either Polygon or MultiPolygon, either directly as the top-level type, or if the top-level type is Feature, as the geometry of that feature.
SimpleHTMLEncoder	Simple `Encoder` implementation to escape text for HTML output
SimpleHTMLFormatter	Simple `Formatter` implementation to highlight terms with a pre and post tag.
SimpleMergedSegmentWarmer	A very simple merged segment warmer that just ensures data structures are initialized.
SimpleNaiveBayesClassifier	A simplistic Lucene based NaiveBayes classifier, see `http://en.wikipedia.org/wiki/Naive_Bayes_classifier`
SimpleNaiveBayesDocumentClassifier	A simplistic Lucene based NaiveBayes classifier, see `http://en.wikipedia.org/wiki/Naive_Bayes_classifier`
SimplePatternSplitTokenizer	This tokenizer uses a Lucene `RegExp` or (expert usage) a pre-built determinized `Automaton`, to locate tokens.
SimplePatternSplitTokenizerFactory	Factory for `SimplePatternSplitTokenizer`, for producing tokens by splitting according to the provided regexp.
SimplePatternTokenizer	This tokenizer uses a Lucene `RegExp` or (expert usage) a pre-built determinized `Automaton`, to locate tokens.
SimplePatternTokenizerFactory	Factory for `SimplePatternTokenizer`, for matching tokens based on the provided regexp.
SimpleQueryParser	SimpleQueryParser is used to parse human readable query syntax.
SimpleQueryParser.State
SimpleSpanFragmenter	`Fragmenter` implementation which breaks text up into same-size fragments but does not split up `Spans`.
SimpleTerm	Base class for queries that expand to sets of simple terms.
SimpleTerm.MatchingTermVisitor	Callback to visit each matching term during "rewrite" in `SimpleTerm.MatchingTermVisitor.visitMatchingTerm(Term)`
SimpleTermRewriteQuery
SimpleTextBKDReader	Forked from `BKDReader` and simplified/specialized for SimpleText's usage
SimpleTextBKDWriter	Forked from `BKDWriter` and simplified/specialized for SimpleText's usage
SimpleTextCodec	plain text index format.
SimpleTextCompoundFormat	plain text compound format.
SimpleTextDocValuesFormat	plain text doc values format.
SimpleTextDocValuesReader
SimpleTextDocValuesReader.DocValuesIterator
SimpleTextDocValuesReader.OneField
SimpleTextDocValuesWriter
SimpleTextFieldInfosFormat	plaintext field infos format
SimpleTextFieldsReader
SimpleTextFieldsWriter
SimpleTextKnnVectorsFormat	For debugging, curiosity, transparency only!! Do not use this codec in production.
SimpleTextKnnVectorsReader	Reads vector values from a simple text format.
SimpleTextKnnVectorsReader.FieldEntry
SimpleTextKnnVectorsReader.SimpleTextByteVectorValues
SimpleTextKnnVectorsReader.SimpleTextFloatVectorValues
SimpleTextKnnVectorsWriter	Writes vector-valued fields in a plain text format
SimpleTextLiveDocsFormat	reads/writes plaintext live docs
SimpleTextLiveDocsFormat.SimpleTextBits
SimpleTextNormsFormat	plain-text norms format.
SimpleTextNormsFormat.SimpleTextNormsConsumer	Writes plain-text norms.
SimpleTextNormsFormat.SimpleTextNormsProducer	Reads plain-text norms.
SimpleTextPointsFormat	For debugging, curiosity, transparency only!! Do not use this codec in production.
SimpleTextPointsReader
SimpleTextPointsWriter
SimpleTextPostingsFormat	For debugging, curiosity, transparency only!! Do not use this codec in production.
SimpleTextSegmentInfoFormat	plain text segments file format.
SimpleTextSegmentInfoFormat.BytesRefOutput
SimpleTextSkipReader	This class reads skip lists with multiple levels.
SimpleTextSkipWriter	plain text skip data.
SimpleTextStoredFieldsFormat	plain text stored fields format.
SimpleTextStoredFieldsReader	reads plaintext stored fields
SimpleTextStoredFieldsWriter	Writes plain-text stored fields.
SimpleTextTermVectorsFormat	plain text term vectors format.
SimpleTextTermVectorsReader	Reads plain-text term vectors.
SimpleTextTermVectorsReader.SimpleTVDocsEnum
SimpleTextTermVectorsReader.SimpleTVFields
SimpleTextTermVectorsReader.SimpleTVPostings
SimpleTextTermVectorsReader.SimpleTVPostingsEnum
SimpleTextTermVectorsReader.SimpleTVTerms
SimpleTextTermVectorsReader.SimpleTVTermsEnum
SimpleTextTermVectorsWriter	Writes plain-text term vectors.
SimpleTextUtil
SimpleWKTShapeParser	Parses shape geometry represented in WKT format
SimpleWKTShapeParser.ShapeType	Enumerated type for Shapes
SingleDocsEnum
SingleFragListBuilder	An implementation class of `FragListBuilder` that generates one `FieldFragList.WeightedFragInfo` object.
SingleFunction	A function with a single argument
SingleInstanceLockFactory	Implements `LockFactory` for a single in-process instance, meaning all locking will take place through this one instance.
SinglePostingsEnum
SingleTermsEnum	Subclass of FilteredTermsEnum for enumerating a single term.
SingletonSortedNumericDocValues	Exposes multi-valued view over a single-valued instance.
SingletonSortedSetDocValues	Exposes multi-valued iterator view over a single-valued iterator.
SleepingLockWrapper	Directory that wraps another, and that sleeps and retries if obtaining the lock fails.
SloppyMath	Math functions that trade off accuracy for speed.
SloppyPhraseMatcher	Find all slop-valid position-combinations (matches) encountered while traversing/hopping the PhrasePositions.
SlopQueryNode	A `SlopQueryNode` represents phrase query with a slop.
SlopQueryNodeBuilder	This builder basically reads the `Query` object set on the `SlopQueryNode` child using `QueryTreeBuilder.QUERY_TREE_BUILDER_TAGID` and applies the slop value defined in the `SlopQueryNode`.
SlowCodecReaderWrapper	Wraps arbitrary readers for merging.
SlowCompositeCodecReaderWrapper	A merged `CodecReader` view of multiple `CodecReader`.
SlowCompositeCodecReaderWrapper.DocValuesSub<T extends DocIdSetIterator>
SlowCompositeCodecReaderWrapper.MergedDocIdSetIterator<T extends DocIdSetIterator>
SlowCompositeCodecReaderWrapper.PointValuesSub
SlowCompositeCodecReaderWrapper.SlowCompositeDocValuesProducerWrapper
SlowCompositeCodecReaderWrapper.SlowCompositeFieldsProducerWrapper
SlowCompositeCodecReaderWrapper.SlowCompositeKnnVectorsReaderWrapper
SlowCompositeCodecReaderWrapper.SlowCompositeNormsProducer
SlowCompositeCodecReaderWrapper.SlowCompositePointsReaderWrapper
SlowImpactsEnum	`ImpactsEnum` that doesn't index impacts but implements the API in a legal way.
SlowLog	Reports on slow queries in a given match run
SlowLog.Entry	An individual entry in the slow log
SmallFloat	Floating point numbers smaller than 32 bits.
SmartChineseAnalyzer	SmartChineseAnalyzer is an analyzer for Chinese or mixed Chinese-English text.
SmartChineseAnalyzer.DefaultSetHolder	Atomically loads the DEFAULT_STOP_SET in a lazy fashion once the outer class accesses the static final set the first time.;
SnapshotDeletionPolicy	An `IndexDeletionPolicy` that wraps any other `IndexDeletionPolicy` and adds the ability to hold and later release snapshots of an index.
SnowballFilter	A filter that stems words using a Snowball-generated stemmer.
SnowballPorterFilterFactory	Factory for `SnowballFilter`, with configurable language
SnowballProgram	Base class for a snowball stemmer
SnowballStemmer	Parent class of all snowball stemmers, which must implement `stem`
SoftDeletesDirectoryReaderWrapper	This reader filters out documents that have a doc values value in the given field and treat these documents as soft deleted.
SoftDeletesDirectoryReaderWrapper.SoftDeletesFilterCodecReader
SoftDeletesDirectoryReaderWrapper.SoftDeletesFilterLeafReader
SoftDeletesDirectoryReaderWrapper.SoftDeletesSubReaderWrapper
SoftDeletesRetentionMergePolicy	This `MergePolicy` allows to carry over soft deleted documents across merges.
SolrSynonymParser	Parser for the Solr synonyms format.
SoraniAnalyzer	`Analyzer` for Sorani Kurdish.
SoraniAnalyzer.DefaultSetHolder	Atomically loads the DEFAULT_STOP_SET in a lazy fashion once the outer class accesses the static final set the first time.;
SoraniNormalizationFilter	A `TokenFilter` that applies `SoraniNormalizer` to normalize the orthography.
SoraniNormalizationFilterFactory	Factory for `SoraniNormalizationFilter`.
SoraniNormalizer	Normalizes the Unicode representation of Sorani text.
SoraniStemFilter	A `TokenFilter` that applies `SoraniStemmer` to stem Sorani words.
SoraniStemFilterFactory	Factory for `SoraniStemFilter`.
SoraniStemmer	Light stemmer for Sorani
Sort	Encapsulates sort criteria for returned hits.
SortableBytesRefArray
SortedDocValues	A per-document byte[] with presorted values.
SortedDocValuesField	Field that stores a per-document `BytesRef` value, indexed for sorting.
SortedDocValuesTermsEnum	Implements a `TermsEnum` wrapping a provided `SortedDocValues`.
SortedDocValuesWriter	Buffers up pending byte[] per doc, deref and sorting via int ord, then flushes when segment flushes.
SortedDocValuesWriter.BufferedSortedDocValues
SortedDocValuesWriter.SortingSortedDocValues
SortedInputIterator	This wrapper buffers incoming elements and makes sure they are sorted based on given comparator.
SortedNumericDocValues	A list of per-document numeric values, sorted according to `Long.compare(long, long)`.
SortedNumericDocValuesField	Field that stores a per-document `long` values for scoring, sorting or value retrieval.
SortedNumericDocValuesRangeQuery
SortedNumericDocValuesSetQuery	Similar to SortedNumericDocValuesRangeQuery but for a set
SortedNumericDocValuesWriter	Buffers up pending long[] per doc, sorts, then flushes when segment flushes.
SortedNumericDocValuesWriter.BufferedSortedNumericDocValues
SortedNumericDocValuesWriter.LongValues
SortedNumericDocValuesWriter.SortingSortedNumericDocValues
SortedNumericSelector	Selects a value from the document's list to use as the representative value
SortedNumericSelector.MaxValue	Wraps a SortedNumericDocValues and returns the last value (max)
SortedNumericSelector.MinValue	Wraps a SortedNumericDocValues and returns the first value (min)
SortedNumericSelector.Type	Type of selection to perform.
SortedNumericSortField	SortField for `SortedNumericDocValues`.
SortedNumericSortField.Provider	A SortFieldProvider for this sort field
SortedSetDocValues	A multi-valued version of `SortedDocValues`.
SortedSetDocValuesField	Field that stores a set of per-document `BytesRef` values, indexed for faceting,grouping,joining.
SortedSetDocValuesRangeQuery
SortedSetDocValuesTermsEnum	Implements a `TermsEnum` wrapping a provided `SortedSetDocValues`.
SortedSetDocValuesWriter	Buffers up pending byte[]s per doc, deref and sorting via int ord, then flushes when segment flushes.
SortedSetDocValuesWriter.BufferedSortedSetDocValues
SortedSetDocValuesWriter.DocOrds
SortedSetDocValuesWriter.SortingSortedSetDocValues
SortedSetFieldSource	Retrieves `FunctionValues` instances for multi-valued string based fields.
SortedSetSelector	Selects a value from the document's set to use as the representative value
SortedSetSelector.MaxValue	Wraps a SortedSetDocValues and returns the last ordinal (max)
SortedSetSelector.MiddleMaxValue	Wraps a SortedSetDocValues and returns the middle ordinal (or max of the two)
SortedSetSelector.MiddleMinValue	Wraps a SortedSetDocValues and returns the middle ordinal (or min of the two)
SortedSetSelector.MinValue	Wraps a SortedSetDocValues and returns the first ordinal (min)
SortedSetSelector.Type	Type of selection to perform.
SortedSetSortField	SortField for `SortedSetDocValues`.
SortedSetSortField.Provider	A SortFieldProvider for this sort
Sorter	Sorts documents of a given index by returning a permutation on the document IDs.
Sorter	Base class for sorting algorithms implementations.
Sorter.DocMap	A permutation of doc IDs.
Sorter.DocValueSorter
SortField	Stores information about how to sort documents by terms in an individual field.
SortField.Provider	A SortFieldProvider for field sorts
SortField.Type	Specifies the type of the terms to be sorted, or special types such as CUSTOM
SortFieldProvider	Reads/Writes a named SortField from a segment info file, used to record index sorts
SortFieldProvider.Holder
SortingCodecReader	An `CodecReader` which supports sorting documents by a given `Sort`.
SortingCodecReader.SortingBits
SortingCodecReader.SortingByteVectorValues
SortingCodecReader.SortingFloatVectorValues	Sorting FloatVectorValues that iterate over documents in the order of the provided sortMap
SortingCodecReader.SortingIntersectVisitor
SortingCodecReader.SortingPointTree
SortingCodecReader.SortingPointValues
SortingStoredFieldsConsumer
SortingStoredFieldsConsumer.CopyVisitor	A visitor that copies every field it sees in the provided `StoredFieldsWriter`.
SortingStrategy	The strategy defining how a Hunspell dictionary should be loaded, with different tradeoffs.
SortingStrategy.EntryAccumulator
SortingStrategy.EntrySupplier
SortingTermVectorsConsumer
SortRescorer	A `Rescorer` that re-sorts according to a provided Sort.
SpanBuilderBase	Base class for building `SpanQuery`s
SpanCollector	An interface defining the collection of postings information from the leaves of a `Spans`
SpanContainingQuery	Keep matches that contain another SpanScorer.
SpanContainQuery
SpanDisiPriorityQueue	A priority queue of DocIdSetIterators that orders by current doc ID.
SpanDisiWrapper	Wrapper used in `SpanDisiPriorityQueue`.
SpanDisjunctionDISIApproximation	A `DocIdSetIterator` which is a disjunction of the approximations of the provided iterators.
SpanFirstBuilder	Builder for `SpanFirstQuery`
SpanFirstQuery	Matches spans near the beginning of a field.
SpanGradientFormatter	Formats text with different color intensity depending on the score of the term using the span tag.
SpanishAnalyzer	`Analyzer` for Spanish.
SpanishAnalyzer.DefaultSetHolder	Atomically loads the DEFAULT_STOP_SET in a lazy fashion once the outer class accesses the static final set the first time.;
SpanishLightStemFilter	A `TokenFilter` that applies `SpanishLightStemmer` to stem Spanish words.
SpanishLightStemFilterFactory	Factory for `SpanishLightStemFilter`.
SpanishLightStemmer	Light Stemmer for Spanish
SpanishMinimalStemFilter	Deprecated. Use `SpanishPluralStemFilter` instead.
SpanishMinimalStemFilterFactory	Deprecated. Use `SpanishPluralStemFilterFactory` instead
SpanishMinimalStemmer	Deprecated. Use `SpanishPluralStemmer` instead.
SpanishPluralStemFilter	A `TokenFilter` that applies `SpanishPluralStemmer` to stem Spanish words.
SpanishPluralStemFilterFactory	Factory for `SpanishPluralStemFilterFactory`.
SpanishPluralStemmer	Plural Stemmer for Spanish
SpanishStemmer	This class implements the stemming algorithm defined by a snowball script.
SpanMultiTermQueryWrapper<Q extends MultiTermQuery>	Wraps any `MultiTermQuery` as a `SpanQuery`, so it can be nested within other SpanQuery classes.
SpanMultiTermQueryWrapper.SpanRewriteMethod	Abstract class that defines how the query is rewritten.
SpanMultiTermQueryWrapper.TopTermsSpanBooleanQueryRewrite	A rewrite method that first translates each term into a SpanTermQuery in a `BooleanClause.Occur.SHOULD` clause in a BooleanQuery, and keeps the scores as computed by the query.
SpanNearBuilder	Builder for `SpanNearQuery`
SpanNearClauseFactory	Factory for `SpanOrQuery`
SpanNearQuery	Matches spans which are near one another.
SpanNearQuery.Builder	A builder for SpanNearQueries
SpanNearQuery.GapSpans
SpanNearQuery.SpanGapQuery
SpanNotBuilder	Builder for `SpanNotQuery`
SpanNotQuery	Removes matches which overlap with another SpanQuery or which are within x tokens before or y tokens after another SpanQuery.
SpanOrBuilder	Builder for `SpanOrQuery`
SpanOrQuery	Matches the union of its clauses.
SpanOrTermsBuilder	Builder that analyzes the text into a `SpanOrQuery`
SpanPayloadCheckQuery	Only return those matches that have a specific payload at the given position.
SpanPayloadCheckQuery.MatchOperation	The payload type.
SpanPayloadCheckQuery.PayloadType	The payload type.
SpanPositionCheckQuery	Base class for filtering a SpanQuery based on the position of a match.
SpanPositionQueue
SpanPositionRangeBuilder	Builder for `SpanPositionRangeQuery`
SpanPositionRangeQuery	Checks to see if the `SpanPositionCheckQuery.getMatch()` lies between a start and end position
SpanQuery	Base class for span-based queries.
SpanQueryBuilder	Interface for retrieving a `SpanQuery`.
SpanQueryBuilderFactory	Factory for `SpanQueryBuilder`s
Spans	Iterates through combinations of start/end positions per-doc.
SpanScorer	A basic `Scorer` over `Spans`.
SpanTermBuilder	Builder for `SpanTermQuery`
SpanTermQuery	Matches spans containing a term.
SpanWeight	Expert-only.
SpanWeight.Postings	Enumeration defining what postings information should be retrieved from the index for a given Spans
SpanWeight.TermMatch
SpanWithinQuery	Keep matches that are contained within another Spans.
SparseFixedBitSet	A bit set that only stores longs that have at least one bit which is set.
SpatialQuery	Base query class for all spatial geometries: `LatLonShape`, `LatLonPoint` and `XYShape`.
SpatialQuery.EncodedRectangle	Holds spatial logic for a bounding box that works in the encoded space
SpatialQuery.RelationScorerSupplier	utility class for implementing constant score logic specific to INTERSECT, WITHIN, and DISJOINT
SpatialQuery.SpatialVisitor	Visitor used for walking the BKD tree.
SpellChecker	Spell Checker class (Main class). (initially inspired by the David Spencer code).
SplittingBreakIterator	Virtually slices the text on both sides of every occurrence of the specified character.
SrndBooleanQuery
SrndPrefixQuery	Query that matches String prefixes
SrndQuery	Lowest level base class for surround queries
SrndTermQuery	Simple single-term clause
SrndTruncQuery	Query that matches wildcards
StableMSBRadixSorter	Stable radix sorter for variable-length strings.
StableMSBRadixSorter.MergeSorter	A MergeSorter taking advantage of temporary storage.
StableStringSorter
StandardAnalyzer	Filters `StandardTokenizer` with `LowerCaseFilter` and `StopFilter`, using a configurable list of stop words.
StandardDirectoryReader	Default implementation of `DirectoryReader`.
StandardDirectoryReader.ReaderCommit
StandardObjects	Lookup tables for classes that can be serialized using a code.
StandardQueryBuilder	This interface should be implemented by every class that wants to build `Query` objects from `QueryNode` objects.
StandardQueryConfigHandler	This query configuration handler is used for almost every processor defined in the `StandardQueryNodeProcessorPipeline` processor pipeline.
StandardQueryConfigHandler.ConfigurationKeys	Class holding keys for StandardQueryNodeProcessorPipeline options.
StandardQueryConfigHandler.Operator	Boolean Operator: AND or OR
StandardQueryNodeProcessorPipeline	This pipeline has all the processors needed to process a query node tree, generated by `StandardSyntaxParser`, already assembled.
StandardQueryParser	The `StandardQueryParser` is a pre-assembled query parser that supports most features of the classic Lucene query parser, allows dynamic configuration of some of its features (like multi-field expansion or wildcard query restrictions) and adds support for new query types and expressions.
StandardQueryTreeBuilder	This query tree builder only defines the necessary map to build a `Query` tree object.
StandardSyntaxParser	Parser for the standard Lucene syntax
StandardSyntaxParser.JJCalls
StandardSyntaxParser.LookaheadSuccess
StandardSyntaxParserConstants	Token literal values and constants.
StandardSyntaxParserTokenManager	Token Manager.
StandardTokenizer	A grammar-based tokenizer constructed with JFlex.
StandardTokenizerFactory	Factory for `StandardTokenizer`.
StandardTokenizerImpl	This class implements Word Break rules from the Unicode Text Segmentation algorithm, as specified in Unicode Standard Annex #29.
StandardXYZSolid	3D rectangle, bounded on six sides by X,Y,Z limits
StatePair	Pair of states.
StateSet	A thin wrapper of `IntIntHashMap` Maps from state in integer representation to its reference count Whenever the count of a state is 0, that state will be removed from the set
Stats	BlockTree statistics for a single field returned by `FieldReader.getStats()`.
Stats	BlockTree statistics for a single field returned by `FieldReader.getStats()`.
STBlockLine	Represents a term and its details stored in the `BlockTermState`.
STBlockLine.Serializer	Reads block lines encoded incrementally, with all fields corresponding to the term of the line.
STBlockReader	Reads terms blocks with the Shared Terms format.
STBlockWriter	Writes terms blocks with the Shared Terms format.
Stemmer	Stemmer uses the affix rules declared in the Dictionary to generate one or more stems for a word.
Stemmer.CaseVariationProcessor
Stemmer.RootProcessor
Stemmer.StemCandidateProcessor
StemmerOverrideFilter	Provides the ability to override any `KeywordAttribute` aware stemmer with custom dictionary-based stemming.
StemmerOverrideFilter.Builder	This builder builds an `FST` for the `StemmerOverrideFilter`
StemmerOverrideFilter.StemmerOverrideMap	A read-only 4-byte FST backed map that allows fast case-insensitive key value lookups for `StemmerOverrideFilter`
StemmerOverrideFilterFactory	Factory for `StemmerOverrideFilter`.
StemmerUtil	Some commonly-used stemming functions
StempelFilter	Transforms the token stream as per the stemming algorithm.
StempelPolishStemFilterFactory	Factory for `StempelFilter` using a Polish stemming table.
StempelStemmer	Stemmer class is a convenient facade for other stemmer-related classes.
STIntersectBlockReader	The "intersect" `TermsEnum` response to `STUniformSplitTerms.intersect(CompiledAutomaton, BytesRef)`, intersecting the terms with an automaton.
STMergingBlockReader	`TermsEnum` used when merging segments, to enumerate the terms of an input segment and get all the fields `TermState`s of each term.
STMergingTermsEnum	Combines `PostingsEnum` for the same term for a given field from multiple segments.
StopAnalyzer	Filters `LetterTokenizer` with `LowerCaseFilter` and `StopFilter`.
StopFilter	Removes stop words from a token stream.
StopFilter	Removes stop words from a token stream.
StopFilterFactory	Factory for `StopFilter`.
StopwordAnalyzerBase	Base class for Analyzers that need to make use of stopword sets.
StoredField	A field whose value is stored so that `IndexSearcher.storedFields()` and `IndexReader.storedFields()` will return the field and its value.
StoredFields	API for reading stored fields.
StoredFieldsConsumer
StoredFieldsFormat	Controls the format of stored fields
StoredFieldsInts
StoredFieldsReader	Codec API for reading stored fields.
StoredFieldsWriter	Codec API for writing stored fields: For every document, `StoredFieldsWriter.startDocument()` is called, informing the Codec that a new document has started.
StoredFieldsWriter.StoredFieldsMergeSub
StoredFieldVisitor	Expert: provides a low-level means of accessing the stored field values in an index.
StoredFieldVisitor.Status	Enumeration of possible return values for `StoredFieldVisitor.needsField(org.apache.lucene.index.FieldInfo)`.
StoredValue	Abstraction around a stored value.
StoredValue.Type	Type of a `StoredValue`.
StrDocValues	Abstract `FunctionValues` implementation which supports retrieving String values.
StrictStringTokenizer	Used for parsing Version strings so we don't have to use overkill String.split nor StringTokenizer (which silently skips empty tokens).
StringDistance	Interface for string distances.
StringField	A field that is indexed but not tokenized: the entire String value is indexed as a single token.
StringHelper	Methods for manipulating strings.
StringSorter	A `BytesRef` sorter tries to use a efficient radix sorter if `StringSorter.cmp` is a `BytesRefComparator`, otherwise fallback to `StringSorter.fallbackSorter(java.util.Comparator<org.apache.lucene.util.BytesRef>)`
StringUtils	String manipulation routines
STUniformSplitPostingsFormat	`PostingsFormat` based on the Uniform Split technique and supporting Shared Terms.
STUniformSplitTerms	Extends `UniformSplitTerms` for a shared-terms dictionary, with all the fields of a term in the same block line.
STUniformSplitTermsReader	A block-based terms index and dictionary based on the Uniform Split technique, and sharing all the fields terms in the same dictionary, with all the fields of a term in the same block line.
STUniformSplitTermsWriter	Extends `UniformSplitTermsWriter` by sharing all the fields terms in the same dictionary and by writing all the fields of a term in the same block line.
STUniformSplitTermsWriter.FieldsIterator
STUniformSplitTermsWriter.SharedTermsWriter
SuffixingNGramTokenFilter
Suggester	A generator for misspelled word corrections based on Hunspell flags.
SuggestField	Field that indexes a string value and a weight as a weighted completion against a named suggester.
SuggestibleEntryCache	A cache allowing for CPU-cache-friendlier iteration over `WordStorage` entries that can be used for suggestions.
SuggestIndexSearcher	Adds document suggest capabilities to IndexSearcher.
Suggestion
SuggestionTimeoutException	An exception thrown when `Hunspell.suggest(java.lang.String)` call takes too long, if `TimeoutPolicy.THROW_EXCEPTION` is used.
SuggestMode	Set of strategies for suggesting related terms
SuggestScoreDocPriorityQueue	Bounded priority queue for `TopSuggestDocs.SuggestScoreDoc`s.
SuggestStopFilter	Like `StopFilter` except it will not remove the last token if that token was not followed by some token separator.
SuggestStopFilterFactory	Factory for `SuggestStopFilter`.
SuggestWord	SuggestWord, used in suggestSimilar method in SpellChecker class.
SuggestWordFrequencyComparator	Frequency first, then score.
SuggestWordQueue	Sorts SuggestWord instances
SuggestWordScoreComparator	Score first, then frequency
SumFloatFunction	`SumFloatFunction` returns the sum of its components.
SumPayloadFunction	Calculate the final score as the sum of scores of all payloads seen.
SumTotalTermFreqValueSource	`SumTotalTermFreqValueSource` returns the number of tokens.
SuppressForbidden	Annotation to suppress forbidden-apis errors inside a whole class, a method, or a field.
SwedishAnalyzer	`Analyzer` for Swedish.
SwedishAnalyzer.DefaultSetHolder	Atomically loads the DEFAULT_STOP_SET in a lazy fashion once the outer class accesses the static final set the first time.;
SwedishLightStemFilter	A `TokenFilter` that applies `SwedishLightStemmer` to stem Swedish words.
SwedishLightStemFilterFactory	Factory for `SwedishLightStemFilter`.
SwedishLightStemmer	Light Stemmer for Swedish.
SwedishMinimalStemFilter	A `TokenFilter` that applies `SwedishMinimalStemmer` to stem Swedish words.
SwedishMinimalStemFilterFactory	Factory for `SwedishMinimalStemFilter`.
SwedishMinimalStemmer	Minimal Stemmer for Swedish.
SwedishStemmer	This class implements the stemming algorithm defined by a snowball script.
SweetSpotSimilarity	A similarity with a lengthNorm that provides for a "plateau" of equally good lengths, and tf helper functions.
SynonymFilter	Deprecated. Use `SynonymGraphFilter` instead, but be sure to also use `FlattenGraphFilter` at index time (not at search time) as well.
SynonymFilter.PendingInput
SynonymFilter.PendingOutputs
SynonymFilterFactory	Deprecated. Use `SynonymGraphFilterFactory` instead, but be sure to also use `FlattenGraphFilterFactory` at index time (not at search time) as well.
SynonymGraphFilter	Applies single- or multi-token synonyms from a `SynonymMap` to an incoming `TokenStream`, producing a fully correct graph output.
SynonymGraphFilter.BufferedInputToken
SynonymGraphFilter.BufferedOutputToken
SynonymGraphFilterFactory	Factory for `SynonymGraphFilter`.
SynonymMap	A map of synonyms, keys and values are phrases.
SynonymMap.Builder	Builds an FSTSynonymMap.
SynonymMap.Builder.MapEntry
SynonymMap.Parser	Abstraction for parsing synonym files.
SynonymQuery	A query that treats multiple terms as synonyms.
SynonymQuery.Builder	A builder for `SynonymQuery`.
SynonymQuery.DisiWrapperFreq
SynonymQuery.FreqBoostTermScorer
SynonymQuery.SynonymScorer
SynonymQuery.TermAndBoost
SynonymQueryNode	`QueryNode` for clauses that are synonym of each other.
SynonymQueryNodeBuilder	Builder for `SynonymQueryNode`.
SyntaxParser	A parser needs to implement `SyntaxParser` interface
TamilAnalyzer	Analyzer for Tamil.
TamilAnalyzer.DefaultSetHolder	Atomically loads the DEFAULT_STOP_SET in a lazy fashion once the outer class accesses the static final set the first time.;
TamilStemmer	This class implements the stemming algorithm defined by a snowball script.
TaskExecutor	Executor wrapper responsible for the execution of concurrent tasks.
TaskExecutor.TaskGroup<T>	Holds all the sub-tasks that a certain operation gets split into as it gets parallelized and exposes the ability to invoke such tasks and wait for them all to complete their execution and provide their results.
TeeSinkTokenFilter	This TokenFilter provides the ability to set aside attribute states that have already been analyzed.
TeeSinkTokenFilter.SinkTokenStream	TokenStream output from a tee.
TeeSinkTokenFilter.States	A convenience wrapper for storing the cached states as well the final state of the stream.
TeluguAnalyzer	Analyzer for Telugu.
TeluguAnalyzer.DefaultSetHolder	Atomically loads the DEFAULT_STOP_SET in a lazy fashion once the outer class accesses the static final set the first time.;
TeluguNormalizationFilter	A `TokenFilter` that applies `TeluguNormalizer` to normalize the orthography.
TeluguNormalizationFilterFactory	Factory for `TeluguNormalizationFilter`.
TeluguNormalizer	Normalizer for Telugu.
TeluguStemFilter	A `TokenFilter` that applies `TeluguStemmer` to stem Telugu words.
TeluguStemFilterFactory	Factory for `TeluguStemFilter`.
TeluguStemmer	Stemmer for Telugu.
Term	A Term represents a word from text.
TermAndBoost	Wraps a term and boost
TermAndVector	Word2Vec unit composed by a term with the associated vector
TermAutomatonQuery	A proximity query that lets you express an automaton, whose transitions are terms, to match documents.
TermAutomatonQuery.EnumAndScorer
TermAutomatonScorer
TermAutomatonScorer.DocIDQueue	Sorts by docID so we can quickly pull out all scorers that are on the same (lowest) docID.
TermAutomatonScorer.PositionQueue	Sorts by position so we can visit all scorers on one doc, by position.
TermAutomatonScorer.PosState
TermAutomatonScorer.TermRunAutomaton
TermBytes	Term of a block line.
TermCollectingRewrite<B>
TermCollectingRewrite.TermCollector
TermFilteredPresearcher	Presearcher implementation that uses terms extracted from queries to index them in the Monitor, and builds a disjunction from terms in a document to match them.
TermFilteredPresearcher.DocumentQueryBuilder	Constructs a document disjunction from a set of terms
TermFrequencyAttribute	Sets the custom term frequency of a term within one document.
TermFrequencyAttributeImpl	Default implementation of `TermFrequencyAttribute`.
TermFreqValueSource	Function that returns `PostingsEnum.freq()` for the supplied term in every document.
TermGroupFacetCollector	An implementation of `GroupFacetCollector` that computes grouped facets based on the indexed terms from DocValues.
TermGroupFacetCollector.GroupedFacetHit
TermGroupFacetCollector.MV
TermGroupFacetCollector.MV.SegmentResult
TermGroupFacetCollector.SV
TermGroupFacetCollector.SV.SegmentResult
TermGroupSelector	A GroupSelector implementation that groups via SortedDocValues
TermInSetQuery	Specialization for a disjunction over many terms that, by default, behaves like a `ConstantScoreQuery` over a `BooleanQuery` containing only `BooleanClause.Occur.SHOULD` clauses.
TermIntervalsSource
TermMatchesIterator	A `MatchesIterator` over a single term's postings list
TermOrdValComparator	Sorts by field's natural Term sort order, using ordinals.
TermOrdValComparator.PostingsEnumAndOrd
TermQuery	A Query that matches documents containing a term.
TermQueryBuilder	Builder for `TermQuery`
TermRangeQuery	A Query that matches documents within an range of terms.
TermRangeQueryNode	This query node represents a range query composed by `FieldQueryNode` bounds, which means the bound values are strings.
TermRangeQueryNodeBuilder	Builds a `TermRangeQuery` object from a `TermRangeQueryNode` object.
TermRangeQueryNodeProcessor	This processors process `TermRangeQueryNode`s.
Terms	Access to the terms in a specific field.
TermsCollector<DV>	A collector that collects all terms from a specified field matching the query.
TermsCollector.MV
TermsCollector.SV
TermScorer	Expert: A `Scorer` for documents matching a `Term`.
TermsEnum	Iterator to seek (`TermsEnum.seekCeil(BytesRef)`, `TermsEnum.seekExact(BytesRef)`) or step through (`BytesRefIterator.next()` terms to obtain frequency information (`TermsEnum.docFreq()`), `PostingsEnum` or `PostingsEnum` for the current term (`TermsEnum.postings(org.apache.lucene.index.PostingsEnum)`.
TermsEnum.SeekStatus	Represents returned result from `TermsEnum.seekCeil(org.apache.lucene.util.BytesRef)`.
TermsEnumIndex	Wrapper around a `TermsEnum` and an integer that identifies it.
TermsEnumIndex.TermState	Wrapper around a term that allows for quick equals comparisons.
TermsEnumTokenStream	A TokenStream created from a `TermsEnum`
TermsHash	This class is passed each token produced by the analyzer on each field during indexing, and it stores these tokens in a hash table, and allocates separate byte streams per token.
TermsHashBuilder
TermsHashPerField	This class stores streams of information per term without knowing the size of the stream ahead of time.
TermsHashPerField.PostingsBytesStartArray
TermsIncludingScoreQuery
TermsIndexReaderBase	`BlockTermsReader` interacts with an instance of this class to manage its terms index.
TermsIndexReaderBase.FieldIndexEnum	Similar to TermsEnum, except, the only "metadata" it reports for a given indexed term is the long fileOffset into the main terms dictionary file.
TermsIndexWriterBase	Base class for terms index implementations to plug into `BlockTermsWriter`.
TermSpans	Expert: Public for extension only.
TermsQuery	A query that has an array of terms from a specific field.
TermsQueryBuilder	Builds a BooleanQuery from all of the terms found in the XML element using the choice of analyzer
TermState	Encapsulates all required internal state to position the associated `TermsEnum` without re-seeking.
TermStates	Maintains a `IndexReader` `TermState` view over `IndexReader` instances containing a single term.
TermStates.TermStateInfo	Wrapper over TermState, ordinal value, term doc frequency and total term frequency
TermStatistics	Contains statistics for a specific term
TermStats	Holder for per-term statistics.
TermStats	Holder for a term along with its statistics (`TermStats.docFreq` and `TermStats.totalTermFreq`).
TermsWithScoreCollector<DV>
TermsWithScoreCollector.MV
TermsWithScoreCollector.MV.Avg
TermsWithScoreCollector.SV
TermsWithScoreCollector.SV.Avg
TermToBytesRefAttribute	This attribute is requested by TermsHashPerField to index the contents.
TermVectorFilteredLeafReader	A filtered LeafReader that only includes the terms that are also in a provided set of terms.
TermVectorFilteredLeafReader.TermsFilteredTerms
TermVectorFilteredLeafReader.TermVectorFilteredTermsEnum
TermVectorLeafReader	Wraps a Terms with a `LeafReader`, typically from term vectors.
TermVectorOffsetStrategy	Uses term vectors that contain offsets.
TermVectors	API for reading term vectors.
TermVectorsConsumer
TermVectorsConsumerPerField
TermVectorsConsumerPerField.TermVectorsPostingsArray
TermVectorsFormat	Controls the format of term vectors
TermVectorsReader	Codec API for reading term vectors:
TermVectorsWriter	Codec API for writing term vectors: For every document, `TermVectorsWriter.startDocument(int)` is called, informing the Codec how many fields will be written.
TermVectorsWriter.TermVectorsMergeSub
TermWeightor	Calculates the weight of a `Term`
TernaryTree	Ternary Search Tree.
TernaryTreeNode	The class creates a TST node.
Tessellator	Computes a triangular mesh tessellation for a given polygon.
Tessellator.Monitor	Implementation of this interface will receive calls with internal data at each step of the triangulation algorithm.
Tessellator.Node	Circular Doubly-linked list used for polygon coordinates
Tessellator.State	state of the tessellated split - avoids recursion
Tessellator.Triangle	Triangle in the tessellated mesh
TestSecrets	A set of static methods returning accessors for internal, package-private functionality in Lucene.
TextableQueryNode	Interface for a node that has text as a `CharSequence`
TextField	A field that is indexed and tokenized, without term vectors.
TextFragment	Low-level class used to record information about a section of a document with a score.
TFIDFSimilarity	Implementation of `Similarity` with the Vector Space Model.
TFValueSource	Function that returns `TFIDFSimilarity.tf(float)` for every document.
ThaiAnalyzer	`Analyzer` for Thai language.
ThaiAnalyzer.DefaultSetHolder	Atomically loads the DEFAULT_STOP_SET in a lazy fashion once the outer class accesses the static final set the first time.;
ThaiTokenizer	Tokenizer that use `BreakIterator` to tokenize Thai text.
ThaiTokenizerFactory	Factory for `ThaiTokenizer`.
ThreadInterruptedException	Thrown by lucene on detecting that Thread.interrupt() had been called.
TieredMergePolicy	Merges segments of approximately equal size, subject to an allowed number of segments per tier.
TieredMergePolicy.MERGE_TYPE
TieredMergePolicy.MergeScore	Holds score and explanation for a single candidate merge.
TieredMergePolicy.SegmentSizeAndDocs
TimeLimitingBulkScorer	The `TimeLimitingBulkScorer` is used to timeout search requests that take longer than the maximum allowed search time limit.
TimeLimitingBulkScorer.TimeExceededException	Thrown when elapsed search time exceeds allowed search time.
TimeLimitingCollector	Deprecated. Use `IndexSearcher.setTimeout(QueryTimeout)` to time out queries.
TimeLimitingCollector.TimeExceededException	Thrown when elapsed search time exceeds allowed search time.
TimeLimitingCollector.TimerThread	Thread used to timeout search requests.
TimeLimitingCollector.TimerThreadHolder
TimeLimitingKnnCollectorManager	A `KnnCollectorManager` that collects results with a timeout.
TimeoutPolicy	A strategy determining what to do when Hunspell API calls take too much time
TimSorter	`Sorter` implementation based on the TimSort algorithm.
ToChildBlockJoinQuery	Just like `ToParentBlockJoinQuery`, except this query joins in reverse: you provide a Query matching parent documents and it joins down to child documents.
ToChildBlockJoinQuery.ToChildBlockJoinScorer
ToChildBlockJoinQuery.ToChildBlockJoinWeight
Token	Analyzed token with morphological data from its dictionary.
Token	Analyzed token with morphological data.
Token	Describes the input token stream.
Token	Describes the input token stream.
Token	Describes the input token stream.
TokenFilter	A TokenFilter is a TokenStream whose input is another TokenStream.
TokenFilterFactory	Abstract parent class for analysis factories that create `TokenFilter` instances.
TokenFilterFactory.Holder	This static holder class prevents classloading deadlock by delaying init of factories until needed.
TokenGroup	One, or several overlapping tokens, along with the score(s) and the scope of the original text.
TokenInfoDictionary	Binary dictionary implementation for a known-word dictionary model: Words are encoded into an FST mapping to a list of wordIDs.
TokenInfoDictionary	Binary dictionary implementation for a known-word dictionary model: Words are encoded into an FST mapping to a list of wordIDs.
TokenInfoDictionary.SingletonHolder
TokenInfoDictionary.SingletonHolder
TokenInfoDictionaryBuilder
TokenInfoDictionaryBuilder
TokenInfoDictionaryWriter
TokenInfoDictionaryWriter
TokenInfoFST	Thin wrapper around an FST with root-arc caching for Japanese.
TokenInfoFST	Thin wrapper around an FST with root-arc caching for Hangul syllables (11,172 arcs).
TokenizedPhraseQueryNode	A `TokenizedPhraseQueryNode` represents a node created by a code that tokenizes/lemmatizes/analyzes.
Tokenizer	A Tokenizer is a TokenStream whose input is a Reader.
TokenizerFactory	Abstract parent class for analysis factories that create `Tokenizer` instances.
TokenizerFactory.Holder	This static holder class prevents classloading deadlock by delaying init of factories until needed.
TokenMgrError	Token Manager Error.
TokenMgrError	Token Manager Error.
TokenMgrError	Token Manager Error.
TokenOffsetPayloadTokenFilter	Adds the `OffsetAttribute.startOffset()` and `OffsetAttribute.endOffset()` First 4 bytes are the start
TokenOffsetPayloadTokenFilterFactory	Factory for `TokenOffsetPayloadTokenFilter`.
TokenSources	Convenience methods for obtaining a `TokenStream` for use with the `Highlighter` - can obtain from term vectors with offsets and positions or from an Analyzer re-parsing the stored content.
TokenStream	A `TokenStream` enumerates the sequence of tokens, either from `Field`s of a `Document` or from query text.
TokenStreamFromTermVector	TokenStream created from a term vector field.
TokenStreamFromTermVector.TokenLL
TokenStreamOffsetStrategy	Analyzes the text, producing a single `OffsetsEnum` wrapping the `TokenStream` filtered to terms in the query, including wildcards.
TokenStreamOffsetStrategy.TokenStreamOffsetsEnum
TokenStreamToAutomaton	Consumes a TokenStream and creates an `Automaton` where the transition labels are UTF8 bytes (or Unicode code points if unicodeArcs is true) from the `TermToBytesRefAttribute`.
TokenStreamToAutomaton.Position
TokenStreamToAutomaton.Positions
TokenStreamToTermAutomatonQuery	Consumes a TokenStream and creates an `TermAutomatonQuery` where the transition labels are tokens from the `TermToBytesRefAttribute`.
TooComplexToDeterminizeException	This exception is thrown when determinizing an automaton would require too much work.
Tools	Static methods globally useful for 3d geometric work.
TooManyBasicQueries	Exception thrown when `BasicQueryFactory` would exceed the limit of query clauses.
ToParentBlockJoinQuery	This query requires that you index children and parent docs as a single block, using the `IndexWriter.addDocuments()` or `IndexWriter.updateDocuments()` API.
ToParentBlockJoinQuery.BlockJoinScorer
ToParentBlockJoinQuery.BlockJoinWeight
ToParentBlockJoinQuery.ParentApproximation
ToParentBlockJoinQuery.ParentTwoPhase
ToParentBlockJoinSortField	A special sort field that allows sorting parent docs based on nested / child level fields.
ToParentDocValues
ToParentDocValues.Accumulator
ToParentDocValues.NumDV
ToParentDocValues.SortedDVs
TopDocs	Represents hits returned by `IndexSearcher.search(Query,int)`.
TopDocs.MergeSortQueue
TopDocs.ScoreMergeSortQueue
TopDocs.ShardRef
TopDocsCollector<T extends ScoreDoc>	A base class for all collectors that return a `TopDocs` output.
TopFieldCollector	A `Collector` that sorts by `SortField` using `FieldComparator`s.
TopFieldCollector.PagingFieldCollector
TopFieldCollector.SimpleFieldCollector
TopFieldCollectorManager	Create a TopFieldCollectorManager which uses a shared hit counter to maintain number of hits and a shared `MaxScoreAccumulator` to propagate the minimum score across segments if the primary sort is by relevancy.
TopFieldDocs	Represents hits returned by `IndexSearcher.search(Query,int,Sort)`.
TopGroups<T>	Represents result returned by a grouping search.
TopGroups.ScoreMergeMode	How the GroupDocs score (if any) should be merged.
TopGroupsCollector<T>	A second-pass collector that collects the TopDocs for each group, and returns them as a `TopGroups` object
TopGroupsCollector.MaxScoreCollector
TopGroupsCollector.TopDocsAndMaxScoreCollector
TopGroupsCollector.TopDocsReducer<T>
TopKnnCollector	TopKnnCollector is a specific KnnCollector.
TopKnnCollectorManager	TopKnnCollectorManager responsible for creating `TopKnnCollector` instances.
TopScoreDocCollector	A `Collector` implementation that collects the top-scoring hits, returning them as a `TopDocs`.
TopScoreDocCollector.PagingTopScoreDocCollector
TopScoreDocCollector.ScorerLeafCollector	Scorable leaf collector
TopScoreDocCollector.SimpleTopScoreDocCollector
TopScoreDocCollectorManager	Create a TopScoreDocCollectorManager which uses a shared hit counter to maintain number of hits and a shared `MaxScoreAccumulator` to propagate the minimum score across segments
TopSuggestDocs	`TopDocs` wrapper with an additional CharSequence key per `ScoreDoc`
TopSuggestDocs.SuggestScoreDoc	`ScoreDoc` with an additional CharSequence key
TopSuggestDocsCollector	`Collector` that collects completion and score, along with document id
TopTermsRewrite<B>	Base rewrite method for collecting only the top terms via a priority queue.
TopTermsRewrite.ScoreTerm
ToStringUtil	Utility class for english translations of morphological data, used only for debugging.
ToStringUtils	Helper methods to ease implementing `Object.toString()`.
TotalHitCountCollector	Just counts the total number of hits.
TotalHitCountCollectorManager	Collector manager based on `TotalHitCountCollector` that allows users to parallelize counting the number of hits, expected to be used mostly wrapped in `MultiCollectorManager`.
TotalHits	Description of the total number of hits of a query.
TotalHits.Relation	How the `TotalHits.value` should be interpreted.
TotalTermFreqValueSource	`TotalTermFreqValueSource` returns the total term freq (sum of term freqs across all documents).
TrackingDirectoryWrapper	A delegating Directory that records which files were written to and deleted.
TrackingTmpOutputDirectoryWrapper
Transition	Holds one transition from an `Automaton`.
Trie	A Trie is used to store a dictionary of words and their stems.
TrigramAutomaton	An automaton allowing to achieve the same results as non-weighted `GeneratingSuggester.ngramScore(int, java.lang.String, java.lang.String, boolean)`, but faster (in O(s2.length) time).
TrimFilter	Trims leading and trailing whitespace from Tokens in the stream.
TrimFilterFactory	Factory for `TrimFilter`.
TruncateTokenFilter	A token filter for truncating the terms into a specific length.
TruncateTokenFilterFactory	Factory for `TruncateTokenFilter`.
TSTAutocomplete	Ternary Search Trie implementation.
TSTLookup	Suggest implementation based on a Ternary Search Tree
TurkishAnalyzer	`Analyzer` for Turkish.
TurkishAnalyzer.DefaultSetHolder	Atomically loads the DEFAULT_STOP_SET in a lazy fashion once the outer class accesses the static final set the first time.;
TurkishLowerCaseFilter	Normalizes Turkish token text to lower case.
TurkishLowerCaseFilterFactory	Factory for `TurkishLowerCaseFilter`.
TurkishStemmer	This class implements the stemming algorithm defined by a snowball script.
TwoPhaseCommit	An interface for implementations that support 2-phase commit.
TwoPhaseCommitTool	A utility for executing 2-phase commit on several objects.
TwoPhaseCommitTool.CommitFailException	Thrown by `TwoPhaseCommitTool.execute(TwoPhaseCommit...)` when an object fails to commit().
TwoPhaseCommitTool.PrepareCommitFailException	Thrown by `TwoPhaseCommitTool.execute(TwoPhaseCommit...)` when an object fails to prepareCommit().
TwoPhaseIterator	Returned by `Scorer.twoPhaseIterator()` to expose an approximation of a `DocIdSetIterator`.
TwoPhaseIterator.TwoPhaseIteratorAsDocIdSetIterator
TypeAsPayloadTokenFilter	Makes the `TypeAttribute` a payload.
TypeAsPayloadTokenFilterFactory	Factory for `TypeAsPayloadTokenFilter`.
TypeAsSynonymFilter	Adds the `TypeAttribute.type()` as a synonym, i.e.
TypeAsSynonymFilterFactory	Factory for `TypeAsSynonymFilter`.
TypeAttribute	A Token's lexical type.
TypeAttributeImpl	Default implementation of `TypeAttribute`.
TypeTokenFilter	Removes tokens whose types appear in a set of blocked types from a token stream.
TypeTokenFilterFactory	Factory class for `TypeTokenFilter`.
UAX29URLEmailAnalyzer	Filters `UAX29URLEmailTokenizer` with `LowerCaseFilter` and `StopFilter`, using a list of English stop words.
UAX29URLEmailTokenizer	This class implements Word Break rules from the Unicode Text Segmentation algorithm, as specified in Unicode Standard Annex #29 URLs and email addresses are also tokenized according to the relevant RFCs.
UAX29URLEmailTokenizerFactory	Factory for `UAX29URLEmailTokenizer`.
UAX29URLEmailTokenizerImpl	This class implements Word Break rules from the Unicode Text Segmentation algorithm, as specified in Unicode Standard Annex #29 URLs and email addresses are also tokenized according to the relevant RFCs.
UHComponents	A parameter object to hold the components a `FieldOffsetStrategy` needs.
UnescapedCharSequence	CharsSequence with escaped chars information.
UnicodeProps	This file contains unicode properties used by various `CharTokenizer`s.
UnicodeUtil	Class to encode java's UTF16 char[] into UTF8 byte[] without always allocating a new byte[] as String.getBytes(StandardCharsets.UTF_8) does.
UnicodeUtil.UTF8CodePoint	Holds a codepoint along with the number of bytes required to represent it in UTF8
UnicodeWhitespaceAnalyzer	An Analyzer that uses `UnicodeWhitespaceTokenizer`.
UnicodeWhitespaceTokenizer	A UnicodeWhitespaceTokenizer is a tokenizer that divides text at whitespace.
UnifiedHighlighter	A Highlighter that can get offsets from either postings (`IndexOptions.DOCS_AND_FREQS_AND_POSITIONS_AND_OFFSETS`), term vectors (`FieldType.setStoreTermVectorOffsets(boolean)`), or via re-analyzing text.
UnifiedHighlighter.Builder	Builder for UnifiedHighlighter.
UnifiedHighlighter.HighlightFlag	Flags for controlling highlighting behavior.
UnifiedHighlighter.LimitedStoredFieldVisitor	Fetches stored fields for highlighting.
UnifiedHighlighter.OffsetSource	Source of term offsets; essential for highlighting.
UnifiedHighlighter.TermVectorReusingLeafReader	Wraps an IndexReader that remembers/caches the last call to `TermVectors.get(int)` so that if the next call has the same ID, then it is reused.
UniformSplitPostingsFormat	`PostingsFormat` based on the Uniform Split technique.
UniformSplitTerms	`Terms` based on the Uniform Split technique.
UniformSplitTermsReader	A block-based terms index and dictionary based on the Uniform Split technique.
UniformSplitTermsWriter	A block-based terms index and dictionary that assigns terms to nearly uniform length blocks.
UnionFieldMetadataBuilder	Builds a `FieldMetadata` that is the union of multiple `FieldMetadata`.
UnknownDictionary	Dictionary for unknown-word handling.
UnknownDictionary	Dictionary for unknown-word handling.
UnknownDictionary.SingletonHolder
UnknownDictionary.SingletonHolder
UnknownDictionaryBuilder
UnknownDictionaryBuilder
UnknownDictionaryWriter
UnknownDictionaryWriter
Unordered	Node that represents `Intervals.unordered(IntervalsSource...)`.
UnorderedIntervalsSource
UnorderedIntervalsSource.UnorderedIntervalIterator
UnorderedNoOverlaps	Node that represents `Intervals.unorderedNoOverlaps(IntervalsSource, IntervalsSource)`.
UnsortedInputIterator	This wrapper buffers the incoming elements and makes sure they are in random order.
Unwrappable<T>	An object with this interface is a wrapper around another object (e.g., a filter with a delegate).
UpgradeIndexMergePolicy	This `MergePolicy` is used for upgrading all existing segments of an index when calling `IndexWriter.forceMerge(int)`.
UpperCaseFilter	Normalizes token text to UPPER CASE.
UpperCaseFilterFactory	Factory for `UpperCaseFilter`.
UpToTwoPositiveIntOutputs	An FST `Outputs` implementation where each output is one or two non-negative long values.
UpToTwoPositiveIntOutputs.TwoLongs	Holds two long outputs.
UsageTrackingQueryCachingPolicy	A `QueryCachingPolicy` that tracks usage statistics of recently-used filters in order to decide on which filters are worth caching.
UserDictionary	Class for building a User Dictionary.
UserDictionary	Class for building a User Dictionary.
UserInputQueryBuilder	UserInputQueryBuilder uses 1 of 2 strategies for thread-safe parsing: 1) Synchronizing access to "parse" calls on a previously supplied QueryParser or..
UTF32ToUTF8	Converts UTF-32 automata to the equivalent UTF-8 representation.
UTF32ToUTF8.UTF8Byte
UTF32ToUTF8.UTF8Sequence
Util	Static helper methods.
Util.FSTPath<T>	Represents a path in TopNSearcher.
Util.Result<T>	Holds a single input (IntsRef) + output, returned by `shortestPaths()`.
Util.TieBreakByInputComparator<T>	Compares first by the provided comparator, and then tie breaks by path.input.
Util.TopNSearcher<T>	Utility class to find top N shortest paths from start point(s).
Util.TopResults<T>	Holds the results for a top N search using `Util.TopNSearcher`
Utility	SmartChineseAnalyzer utility constants and methods
ValueQueryNode<T>	This interface should be implemented by `QueryNode` that holds an arbitrary value.
ValueSource	Instantiates `FunctionValues` for a particular reader.
ValueSource.FromDoubleValuesSource
ValueSource.ScorableView
ValueSource.WrappedDoubleValuesSource
ValueSource.WrappedLongValuesSource
ValueSourceGroupSelector	A GroupSelector that groups via a ValueSource
ValueSourceScorer	`Scorer` which returns the result of `FunctionValues.floatVal(int)` as the score for a document, and which filters out documents that don't match `ValueSourceScorer.matches(int)`.
VariableContext	A helper to parse the context of a variable name, which is the base variable, followed by the sequence of array (integer or string indexed) and member accesses.
VariableContext.Type	Represents what a piece of a variable does.
VariableGapTermsIndexReader	See `VariableGapTermsIndexWriter`
VariableGapTermsIndexReader.IndexEnum
VariableGapTermsIndexWriter	Selects index terms according to provided pluggable `VariableGapTermsIndexWriter.IndexTermSelector`, and stores them in a prefix trie that's loaded entirely in RAM stored as an FST.
VariableGapTermsIndexWriter.EveryNOrDocFreqTermSelector	Sets an index term when docFreq >= docFreqThresh, or every interval terms.
VariableGapTermsIndexWriter.EveryNTermSelector	Same policy as `FixedGapTermsIndexWriter`
VariableGapTermsIndexWriter.IndexTermSelector	Hook for selecting which terms should be placed in the terms index.
Vector	A 3d vector in space, not necessarily going through the origin.
VectorEncoding	The numeric datatype of the vector values.
VectorFieldFunction	An implementation for retrieving `FunctionValues` instances for knn vectors fields.
VectorizationProvider	A provider of vectorization implementations.
VectorizationProvider.Holder	This static holder class prevents classloading deadlock.
VectorScorer	Computes the similarity score between a given query vector and different document vectors.
VectorSimilarityCollector	Perform a similarity-based graph search.
VectorSimilarityFunction	Vector similarity function; used in search to return top K most similar vectors to a target vector.
VectorSimilarityFunction	`VectorSimilarityFunction` returns a similarity function between two knn vectors.
VectorSimilarityValuesSource	An abstract class that provides the vector similarity scores between the query vector and the `KnnFloatVectorField` or `KnnByteVectorField` for documents.
VectorUtil	Utilities for computations with numeric arrays, especially algebraic operations like vector dot products.
VectorUtilSupport	Interface for implementations of VectorUtil support.
VectorValues	Deprecated. use `FloatVectorValues` instead
VectorValuesConsumer	Streams vector values for indexing to the given codec's vectors writer.
VectorValueSource	Converts individual ValueSource instances to leverage the FunctionValues *Val functions that work with multiple values, i.e.
VerifyingLockFactory	A `LockFactory` that wraps another `LockFactory` and verifies that each lock obtain/release is "correct" (never results in two processes holding the lock at the same time).
Version	Use by certain classes to match version compatibility across releases of Lucene.
VersionBlockTreeTermsReader	See `VersionBlockTreeTermsWriter`.
VersionBlockTreeTermsWriter	This is just like `Lucene90BlockTreeTermsWriter`, except it also stores a version per term, and adds a method to its TermsEnum implementation to seekExact only if the version is >= the specified version.
VersionBlockTreeTermsWriter.FieldMetaData
VersionBlockTreeTermsWriter.PendingBlock
VersionBlockTreeTermsWriter.PendingEntry
VersionBlockTreeTermsWriter.PendingTerm
VersionFieldReader	BlockTree's implementation of `Terms`.
VirtualMethod<C>	A utility for keeping backwards compatibility on previously abstract methods (or similar replacements).
WANDScorer	This implements the WAND (Weak AND) algorithm for dynamic pruning described in "Efficient Query Evaluation using a Two-Level Retrieval Process" by Broder, Carmel, Herscovici, Soffer and Zien.
WeakIdentityMap<K,V>	Implements a combination of `WeakHashMap` and `IdentityHashMap`.
WeakIdentityMap.IdentityWeakReference
Weight	Expert: Calculate query weights and build query scorers.
Weight.DefaultBulkScorer	Just wraps a Scorer and performs top scoring using it.
WeightedFieldFragList	A weighted implementation of `FieldFragList`.
WeightedFragListBuilder	A weighted implementation of `FragListBuilder`.
WeightedSpanTerm	Lightweight class to hold term, weight, and positions used for scoring this term.
WeightedSpanTermExtractor	Class used to extract `WeightedSpanTerm`s from a `Query` based on whether `Term`s from the `Query` are contained in a supplied `TokenStream`.
WeightedSpanTermExtractor.DelegatingLeafReader
WeightedSpanTermExtractor.PositionCheckingMap<K>	This class makes sure that if both position sensitive and insensitive versions of the same term are added, the position insensitive one wins.
WeightedTerm	Lightweight class to hold term and a weight value used for scoring this term
WFSTCompletionLookup	Suggester based on a weighted FST: it first traverses the prefix, then walks the n shortest paths to retrieve top-ranked suggestions.
WFSTCompletionLookup.WFSTInputIterator
WhitespaceAnalyzer	An Analyzer that uses `WhitespaceTokenizer`.
WhitespaceTokenizer	A tokenizer that divides text at whitespace characters as defined by `Character.isWhitespace(int)`.
WhitespaceTokenizerFactory	Factory for `WhitespaceTokenizer`.
WholeBreakIterator	Just produces one single fragment for the entire text
WikipediaTokenizer	Extension of StandardTokenizer that is aware of Wikipedia syntax.
WikipediaTokenizerFactory	Factory for `WikipediaTokenizer`.
WikipediaTokenizerImpl	JFlex-generated tokenizer that is aware of Wikipedia syntax.
Wildcard	Node that represents `Intervals.wildcard(BytesRef)`.
WildcardQuery	Implements the wildcard search query.
WildcardQueryNode	A `WildcardQueryNode` represents wildcard query This does not apply to phrases.
WildcardQueryNodeBuilder	Builds a `WildcardQuery` object from a `WildcardQueryNode` object.
WildcardQueryNodeProcessor	The `StandardSyntaxParser` creates `PrefixWildcardQueryNode` nodes which have values containing the prefixed wildcard.
Within	Node that represents `Intervals.within(IntervalsSource, int, IntervalsSource)`.
Word2VecModel	Word2VecModel is a class representing the parsed Word2Vec model containing the vectors for each word in dictionary
Word2VecSynonymFilter	Applies single-token synonyms from a Word2Vec trained network to an incoming `TokenStream`.
Word2VecSynonymFilterFactory	Factory for `Word2VecSynonymFilter`.
Word2VecSynonymProvider	The Word2VecSynonymProvider generates the list of sysnonyms of a term.
Word2VecSynonymProviderFactory	Supply Word2Vec Word2VecSynonymProvider cache avoiding that multiple instances of Word2VecSynonymFilterFactory will instantiate multiple instances of the same SynonymProvider.
Word2VecSynonymProviderFactory.Word2VecSupportedFormats
WordBreakSpellChecker	A spell checker whose sole function is to offer suggestions by combining multiple terms into one word and/or breaking terms into multiple words.
WordBreakSpellChecker.BreakSuggestionSortMethod	Determines the order to list word break suggestions
WordBreakSpellChecker.CombinationsThenFreqComparator
WordBreakSpellChecker.CombineSuggestionWrapper
WordBreakSpellChecker.LengthThenMaxFreqComparator
WordBreakSpellChecker.LengthThenSumFreqComparator
WordBreakSpellChecker.SuggestWordArrayWrapper
WordCase
WordCase.CharCase
WordContext
WordDelimiterFilter	Deprecated. Use `WordDelimiterGraphFilter` instead: it produces a correct token graph so that e.g.
WordDelimiterFilterFactory	Deprecated. Use `WordDelimiterGraphFilterFactory` instead: it produces a correct token graph so that e.g.
WordDelimiterGraphFilter	Splits words into subwords and performs optional transformations on subword groups, producing a correct token graph so that e.g.
WordDelimiterGraphFilterFactory	Factory for `WordDelimiterGraphFilter`.
WordDelimiterIterator	A BreakIterator-like API for iterating over subwords in text, according to WordDelimiterGraphFilter rules.
WordDictionary	SmartChineseAnalyzer Word Dictionary
WordFormGenerator	A utility class used for generating possible word forms by adding affixes to stems (`WordFormGenerator.getAllWordForms(String, String, Runnable)`), and suggesting stems and flags to generate the given set of words (`WordFormGenerator.compress(List, Set, Runnable)`).
WordFormGenerator.AffixEntry
WordFormGenerator.FlagSet
WordFormGenerator.State
WordlistLoader	Loader for text files that represent a list of stopwords.
WordnetSynonymParser	Parser for wordnet prolog format
WordSegmenter	Segment a sentence of Chinese text into words.
WordStorage	A data structure for memory-efficient word storage and fast lookup/enumeration.
WordStorage.Builder
WordType	Internal SmartChineseAnalyzer token type constants
WritableQueryIndex
WritableQueryIndex.Indexable
WritableQueryIndex.MonitorQueryCollector	A Collector that decodes the stored query for each document hit.
XdYdZSolid	3D rectangle, bounded on six sides by X,Y,Z limits, degenerate in Y and Z.
XdYZSolid	3D rectangle, bounded on six sides by X,Y,Z limits, degenerate in Y
XYCircle	Represents a circle on the XY plane.
XYDocValuesField	An per-document location field.
XYDocValuesPointInGeometryQuery	XYGeometry query for `XYDocValuesField`.
XYdZSolid	3D rectangle, bounded on six sides by X,Y,Z limits, degenerate in Z
XYEncodingUtils	reusable cartesian geometry encoding methods
XYGeometry	Cartesian Geometry object.
XYLine	Represents a line in cartesian space.
XYPoint	Represents a point on the earth's surface.
XYPointDistanceComparator	Compares documents by distance from an origin point
XYPointField	An indexed XY position field.
XYPointInGeometryQuery	Finds all previously indexed points that fall within the specified XY geometries.
XYPointSortField	Sorts by distance from an origin location.
XYPolygon	Represents a polygon in cartesian space.
XYRectangle	Represents a x/y cartesian rectangle.
XYShape	A cartesian shape utility class for indexing and searching geometries whose vertices are unitless x, y values.
XYShapeDocValues	A concrete implementation of `ShapeDocValues` for storing binary doc value representation of `XYShape` geometries in a `XYShapeDocValuesField`
XYShapeDocValuesField	Concrete implementation of a `ShapeDocValuesField` for cartesian geometries.
XYShapeDocValuesQuery	Bounding Box query for `ShapeDocValuesField` representing `XYShape`
XYShapeQuery	Finds all previously indexed cartesian shapes that comply the given `ShapeField.QueryRelation` with the specified array of `XYGeometry`.
XYZBounds	An object for accumulating XYZ bounds information.
XYZSolid	Interface for a family of 3D rectangles, bounded on six sides by X,Y,Z limits
XYZSolidFactory	Factory for `XYZSolid`.
YiddishStemmer	This class implements the stemming algorithm defined by a snowball script.