# All Classes

- All Classes Interface Summary Class Summary Enum Summary Exception Summary Annotation Types Summary
  Class | Description
  --- | ---
  AbstractAnalysisFactory | Abstract parent class for analysis factories `TokenizerFactory`, `TokenFilterFactory` and `CharFilterFactory`.
  AbstractKnnCollector | AbstractKnnCollector is the default implementation for a knn collector used for gathering kNN results and providing topDocs from the gathered neighbors
  AbstractPagedMutable<T extends AbstractPagedMutable<T>> | Base implementation for `PagedMutable` and `PagedGrowableWriter`.
  Accountable | An object whose RAM usage can be computed.
  Accountables | Helper methods for constructing nested resource descriptions and debugging RAM usage.
  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.
  AlreadyClosedException | This exception is thrown when there is an attempt to access something that has already been closed.
  AnalysisSPILoader<S extends AbstractAnalysisFactory> | Helper class for loading named SPIs from classpath (e.g.
  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.TokenStreamComponents | This class encapsulates the outer components of a token stream.
  AnalyzerWrapper | Extension to `Analyzer` suitable for Analyzers which wrap other Analyzers.
  ArrayUtil | Methods for manipulating arrays.
  ArrayUtil.ByteArrayComparator | Comparator for a fixed number of bytes.
  Attribute | Base interface for attributes.
  AttributeFactory | An AttributeFactory creates instances of `AttributeImpl`s.
  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.
  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
  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.
  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.
  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(ne) 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.
  BasicStats | Stores all statistics commonly used ranking methods.
  BinaryDocValues | A per-document numeric value.
  BinaryDocValuesField | Field that stores a per-document `BytesRef` value.
  BinaryPoint | An indexed binary field for fast range filters.
  BinaryRangeDocValues | A binary representation of a range that wraps a BinaryDocValues field
  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.
  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`.
  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`.
  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.
  BlockingFloatHeap | A blocking bounded min heap that stores floats.
  BlockPackedReaderIterator | Reader for sequences of longs written with `BlockPackedWriter`.
  BlockPackedWriter | A writer for large sequences of longs.
  BlockTermState | Holds all state required for `PostingsReaderBase` to produce a `PostingsEnum` without re-seeking the terms dict.
  BM25Similarity | BM25 Similarity.
  BooleanClause | A clause in a BooleanQuery.
  BooleanClause.Occur | Specifies how clauses are to occur in matching documents.
  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`
  BooleanSimilarity | Simple similarity that gives terms a score that is equal to their query boost.
  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`.
  BoostQuery | A `Query` wrapper that allows to give a boost to the wrapped query.
  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`.
  BufferingKnnVectorsWriter | Buffers up pending vector value(s) per doc, then flushes when segment flushes.
  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.
  ByteBufferIndexInput | Base IndexInput implementation that uses an array of ByteBuffers to represent a file.
  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`.
  ByteRunAutomaton | Automaton representation for matching UTF-8 byte[].
  ByteSequenceOutputs | An FST `Outputs` implementation where each output is a sequence of bytes.
  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.
  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.
  BytesTermAttribute | This attribute can be used if you have the raw term bytes to be indexed.
  BytesTermAttributeImpl | Implementation class for `BytesTermAttribute`.
  ByteVectorSimilarityQuery | Search for all (approximate) byte vectors above a similarity threshold.
  ByteVectorValues | This class provides access to per-document floating point vector values indexed as `KnnByteVectorField`.
  CachingCollector | Caches all docs, and optionally also scores, coming from a search, and is then able to replay them to another collector.
  CachingTokenFilter | This class can be used if the token attributes of a TokenStream are intended to be consumed more than once.
  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)`.
  CharArrayMap<V> | A simple class that stores key Strings as char[]'s in a hash table.
  CharArraySet | A simple class that stores Strings as char[]'s in a hash table.
  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.
  CharSequenceOutputs | An FST `Outputs` implementation where each output is a sequence of characters.
  CharsRef | Represents char[], as a slice (offset + length) into an existing char[].
  CharsRefBuilder | A builder for `CharsRef` instances.
  CharTermAttribute | The term text of a Token.
  CharTermAttributeImpl | Default implementation of `CharTermAttribute`.
  CheckedIntConsumer<T extends 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.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.
  ChecksumIndexInput | Extension of IndexInput, computing checksum as it goes.
  Circle | Represents a circle on the earth's surface.
  ClassicSimilarity | Expert: Historical scoring implementation.
  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.
  CodecReader | LeafReader implemented by codec APIs.
  CodecUtil | Utility class for reading and writing versioned headers.
  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.
  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.
  CommandLineUtil | Class containing some useful methods used by command line tools
  CompetitiveImpactAccumulator | This class accumulates the (freq, norm) pairs that may produce competitive scores.
  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.
  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.
  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.
  CompoundDirectory | A read-only `Directory` that consists of a view over a compound file.
  CompoundFormat | Encodes/decodes compound files
  CompressionMode | A compression mode.
  Compressor | A data compressor.
  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.
  ConjunctionUtils | Helper methods for building conjunction iterators
  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.
  ConstantScoreScorer | A constant-scoring `Scorer`.
  ConstantScoreWeight | A Weight that has a constant score equal to the boost of the wrapped query.
  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.
  CorruptIndexException | This exception is thrown when Lucene detects an inconsistency in the index.
  Counter | Simple counter class
  DaciukMihovAutomatonBuilder | Deprecated. Visibility of this class will be reduced in a future release.
  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.
  DateTools | Provides support for converting dates to strings and vice-versa.
  DateTools.Resolution | Specifies the time granularity.
  Decompressor | A decompressor.
  DeflateWithPresetDictCompressionMode | A compression mode that trades speed for compression ratio.
  DelegatingAnalyzerWrapper | An analyzer wrapper, that doesn't allow to wrap components or readers.
  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.
  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`.
  DirectReader | Retrieves an instance previously written by `DirectWriter`
  DirectWriter | Class for writing packed integers to be directly read from Directory.
  DisiPriorityQueue | A priority queue of DocIdSetIterators that orders by current doc ID.
  DisiWrapper | Wrapper used in `DisiPriorityQueue`.
  DisjunctionDISIApproximation | A `DocIdSetIterator` which is a disjunction of the approximations of the provided iterators.
  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.
  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.
  DocBaseBitSetIterator | A `DocIdSetIterator` like `BitSetIterator` but has a doc base in onder to avoid storing previous 0s.
  DocComparator | Comparator that sorts by asc _doc
  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.Sub | Represents one sub-reader being merged
  DocIdSet | A DocIdSet contains a set of doc ids.
  DocIdSetBuilder | A builder of `DocIdSet`s.
  DocIdSetBuilder.BulkAdder | Utility class to efficiently add many docs in one go.
  DocIdSetIterator | This abstract class defines methods to iterate over a set of non-decreasing doc ids.
  DocIdStream | A stream of doc IDs.
  DocsWithFieldSet | Accumulator for documents that have a value for a field.
  Document | Documents are the unit of indexing and search.
  DocumentStoredFieldVisitor | A `StoredFieldVisitor` that creates a `Document` from stored fields.
  DocValues | This class contains utility methods and constants for DocValues
  DocValuesConsumer | Abstract API that consumes numeric, binary and sorted docvalues.
  DocValuesFieldExistsQuery | Deprecated. Use `FieldExistsQuery` instead.
  DocValuesFormat | Encodes/decodes per-document values.
  DocValuesProducer | Abstract API that produces numeric, binary, sorted, sortedset, and sortednumeric docvalues.
  DocValuesRewriteMethod | Rewrites MultiTermQueries into a filter, using DocValues for term enumeration.
  DocValuesType | DocValues types.
  DoubleComparator | Comparator based on `Double.compare(double, double)` for `numHits`.
  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.
  DoublePoint | An indexed `double` field for fast range filters.
  DoubleRange | An indexed Double Range field.
  DoubleRangeDocValuesField | DocValues field for DoubleRange.
  DoubleValues | Per-segment, per-document double values, which can be calculated at search-time
  DoubleValuesSource | Base class for producing `DoubleValues`
  EmptyDocValuesProducer | Abstract base class implementing a `DocValuesProducer` that has no doc values.
  ExactPhraseMatcher | Expert: Find exact phrases
  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.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.
  Explanation | Expert: Describes the score computation for document and query.
  FeatureField | `Field` that can be used to store static scoring factors into documents.
  Field | Expert: directly create a field for a document.
  Field.Store | Specifies whether and how a field should be stored.
  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.
  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.
  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).
  FieldInfosFormat | Encodes/decodes `FieldInfos`
  FieldInvertState | This class tracks the number and position / offset parameters of terms being added to the index.
  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.
  FieldsIndexWriter | Efficient index format for block-based `Codec`s.
  FieldsProducer | Abstract API that produces terms, doc, freq, prox, offset and payloads postings.
  FieldType | Describes the properties of a field.
  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.
  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:
  FileSwitchDirectory | Expert: A Directory instance that switches files between two other Directory instances.
  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.
  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.
  FilterIndexOutput | IndexOutput implementation that delegates calls to another directory.
  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`.
  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.
  FiniteStringsIterator | Iterates all accepted strings.
  FixedBitSet | BitSet of fixed length (numBits), backed by accessible (`FixedBitSet.getBits()`) long[], accessed with an int index, implementing `Bits` and `DocIdSet`.
  FlagsAttribute | This attribute can be used to pass different flags down the `Tokenizer` chain, e.g.
  FlagsAttributeImpl | Default implementation of `FlagsAttribute`.
  FlatFieldVectorsWriter<T> | Vectors' writer for a field
  FlatVectorsFormat | Encodes/decodes per-document vectors
  FlatVectorsReader | Reads vectors from an index.
  FlatVectorsWriter | Vectors' writer for a field that allows additional indexing logic to be implemented by the caller
  FloatComparator | Comparator based on `Float.compare(float, float)` for `numHits`.
  FloatDocValuesField | Syntactic sugar for encoding floats as NumericDocValues via `Float.floatToRawIntBits(float)`.
  FloatField | Field that stores a per-document `float` value for scoring, sorting or value retrieval and index the field for fast range filters.
  FloatHeap | A bounded min heap that stores floats.
  FloatPoint | An indexed `float` field for fast range filters.
  FloatRange | An indexed Float Range field.
  FloatRangeDocValuesField | DocValues field for FloatRange.
  FloatVectorSimilarityQuery | Search for all (approximate) float vectors above a similarity threshold.
  FloatVectorValues | This class provides access to per-document floating point vector values indexed as `KnnFloatVectorField`.
  FlushInfo | A FlushInfo provides information required for a FLUSH context.
  ForDeltaUtil | Utility class to encode/decode increasing sequences of 128 integers.
  FrequencyTrackingRingBuffer | A ring buffer that tracks the frequency of the integers that it contains.
  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.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.Builder<T> | Fluent-style constructor for FST `FSTCompiler`.
  FSTReader | Abstraction for reading bytes necessary for FST.
  FSTStore | A type of `FSTReader` which needs data to be initialized before use
  FuzzyQuery | Implements the fuzzy search query.
  FuzzyTermsEnum | Subclass of TermsEnum for enumerating all terms that are similar to the specified filter term.
  FuzzyTermsEnum.FuzzyTermsException | Thrown to indicate that there was an issue creating a fuzzy query for a given term.
  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.
  Geometry | Base class for `LatLonGeometry` and `XYGeometry`
  GeoUtils | Basic reusable geo-spatial utility methods
  GeoUtils.WindingOrder | used to define the orientation of 3 points -1 = Clockwise 0 = Colinear 1 = Counter-clockwise
  GraphTokenFilter | An abstract TokenFilter that exposes its input stream as a graph
  GraphTokenStreamFiniteStrings | Consumes a TokenStream and creates an `Automaton` where the transition labels are terms from the `TermToBytesRefAttribute`.
  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.
  GrowableWriter | Implements `PackedInts.Mutable`, but grows the bit count of the underlying packed ints on-demand.
  HeapPointReader | Utility class to read buffered points from in-heap arrays.
  HeapPointWriter | Utility class to write new points into in-heap arrays.
  HitQueue | Expert: Priority queue containing hit docs
  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.
  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.
  IBSimilarity | Provides a framework for the family of information-based models, as described in Stéphane Clinchant and Eric Gaussier.
  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`.
  IndexedDISI | Disk-based implementation of a `DocIdSetIterator` which can return the index of the current document, i.e.
  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
  IndexInput | Abstract base class for input from a file in a `Directory`.
  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.
  IndexSearcher | Implements search over a single IndexReader.
  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.
  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.DocStats | DocStats for this index
  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.
  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
  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
  InfoStream | Debugging API for Lucene classes such as `IndexWriter` and `SegmentInfos`.
  InitializedHnswGraphBuilder | This creates a graph builder that is initialized with the provided HnswGraph.
  InPlaceMergeSorter | `Sorter` implementation based on the merge-sort algorithm that merges in place (no extra memory will be allocated).
  InputStreamDataInput | A `DataInput` wrapping a plain `InputStream`.
  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`.
  IntField | Field that stores a per-document `int` value for scoring, sorting or value retrieval and index the field for fast range filters.
  IntIntHashMap | A hash map of `int` to `int`, implemented using open addressing with linear probing for collision resolution.
  IntIntHashMap.AbstractIterator<E> | Simplifies the implementation of iterators a bit.
  IntIntHashMap.BufferAllocationException | BufferAllocationException forked from HPPC
  IntPoint | An indexed `int` field for fast range filters.
  IntRange | An indexed Integer Range field.
  IntRangeDocValuesField | DocValues field for IntRange.
  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.
  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
  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
  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`.
  JavaLoggingInfoStream | InfoStream implementation that logs every message using Java Utils Logging (JUL) with the supplied log level.
  KeepOnlyLastCommitDeletionPolicy | This `IndexDeletionPolicy` implementation that keeps only the most recent commit and immediately removes all prior commits after a new commit is done.
  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.
  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
  KnnVectorsReader | Reads vectors from an index.
  KnnVectorsWriter | Writes vectors to an index.
  KnnVectorsWriter.MergedVectorValues | View over multiple vector values supporting iterator-style access via DocIdMerger.
  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`.
  LatLonDocValuesField | An per-document location field.
  LatLonGeometry | Lat/Lon Geometry object.
  LatLonPoint | An indexed location field.
  LatLonShape | An geo shape utility class for indexing and searching gis geometries whose vertices are latitude, longitude values (in decimal degrees).
  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.
  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`.
  LevenshteinAutomata | Class to construct DFAs that match a word within some edit distance.
  LimitedFiniteStringsIterator | `FiniteStringsIterator` which limits the number of iterated accepted strings.
  Line | Represents a line on the earth's surface.
  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.
  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.
  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`.
  LongField | Field that stores a per-document `long` value for scoring, sorting or value retrieval and index the field for fast range filters.
  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.
  LongPoint | An indexed `long` field for fast range filters.
  LongRange | An indexed Long Range field.
  LongRangeDocValuesField | DocValues field for LongRange.
  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
  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.
  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.
  LSBRadixSorter | A LSB Radix sorter for unsigned int values.
  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.
  Lucene90CompoundFormat | Lucene 9.0 compound file format
  Lucene90CompressingStoredFieldsFormat | A `StoredFieldsFormat` that compresses documents in chunks in order to improve the compression ratio.
  Lucene90CompressingStoredFieldsReader | `StoredFieldsReader` impl for `Lucene90CompressingStoredFieldsFormat`.
  Lucene90CompressingStoredFieldsWriter | `StoredFieldsWriter` impl for `Lucene90CompressingStoredFieldsFormat`.
  Lucene90CompressingTermVectorsFormat | A `TermVectorsFormat` that compresses chunks of documents together in order to improve the compression ratio.
  Lucene90CompressingTermVectorsReader | `TermVectorsReader` for `Lucene90CompressingTermVectorsFormat`.
  Lucene90CompressingTermVectorsWriter | `TermVectorsWriter` for `Lucene90CompressingTermVectorsFormat`.
  Lucene90DocValuesFormat | Lucene 9.0 DocValues format.
  Lucene90LiveDocsFormat | Lucene 9.0 live docs format
  Lucene90NormsFormat | Lucene 9.0 Score normalization format.
  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
  Lucene90StoredFieldsFormat | Lucene 9.0 stored fields format.
  Lucene90StoredFieldsFormat.Mode | Configuration option for stored fields.
  Lucene90TermVectorsFormat | Lucene 9.0 `term vectors format`.
  Lucene94FieldInfosFormat | Lucene 9.0 Field Infos format.
  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.
  Lucene99FlatVectorsWriter | Writes vector values to index segments.
  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.
  Lucene99HnswVectorsWriter | Writes vector values and knn graphs to index segments.
  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.
  Lucene99ScalarQuantizedVectorsFormat | Format supporting vector quantization, storage, and retrieval
  Lucene99ScalarQuantizedVectorsReader | Reads Scalar Quantized vectors from the index segments along with index data structures.
  Lucene99ScalarQuantizedVectorsWriter | Writes quantized vector values and metadata to index segments.
  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.
  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.HighCompressionHashTable | A higher-precision `LZ4.HashTable`.
  LZ4WithPresetDictCompressionMode | A compression mode that compromises on the compression ratio to provide fast compression and decompression.
  MapOfSets<K,​V> | Helper class for keeping Lists of Objects associated with keys.
  MappedMultiFields | A `Fields` implementation that merges multiple Fields into one, and maps around deleted documents.
  MatchAllDocsQuery | A query that matches all documents.
  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.
  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.
  MathUtil | Math static utility methods.
  MaxNonCompetitiveBoostAttribute | Add this `Attribute` to a fresh `AttributeSource` before calling `MultiTermQuery.getTermsEnum(Terms,AttributeSource)`.
  MaxNonCompetitiveBoostAttributeImpl | Implementation class for `MaxNonCompetitiveBoostAttribute`.
  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.
  MergedIterator<T extends Comparable<T>> | Provides a merged sorted view from several sorted iterators.
  MergeInfo | A MergeInfo provides information required for a MERGE context.
  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.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.
  MinDocIterator | Docs iterator that starts iterating from a configurable minimum document
  MinimizationOperations | Operations for minimizing automata.
  MMapDirectory | File-based `Directory` implementation that uses mmap for reading, and `FSDirectory.FSIndexOutput` for writing.
  ModuleResourceLoader | Simple `ResourceLoader` that uses `Module.getResourceAsStream(String)` and `Class.forName(Module,String)` to open resources and classes, respectively.
  MonotonicBlockPackedReader | Provides random access to a stream written with `MonotonicBlockPackedWriter`.
  MonotonicBlockPackedWriter | A writer for large monotonically increasing sequences of positive longs.
  MSBRadixSorter | Radix sorter for variable-length strings.
  MultiBits | Concatenates multiple Bits together, on every lookup.
  MultiCollector | A `Collector` which allows running a search with several `Collector`s.
  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
  MultiFields | Provides a single `Fields` term index view over an `IndexReader`.
  MultiLeafReader | Utility methods for working with a `IndexReader` as if it were a `LeafReader`.
  MultiLeafTopKnnCollector | MultiLeafTopKnnCollector is a specific KnnCollector that can exchange the top collected results across segments through a shared global queue.
  MultiLevelSkipListReader | This abstract class reads skip lists with multiple levels.
  MultiLevelSkipListWriter | This abstract class writes skip lists with multiple levels.
  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.UnionFullPostingsEnum | Slower version of UnionPostingsEnum that delegates offsets and positions, for use by MatchesIterator
  MultiPhraseQuery.UnionPostingsEnum | Takes the logical union of multiple PostingsEnum iterators.
  MultiPostingsEnum | Exposes `PostingsEnum`, merged from `PostingsEnum` API of sub-segments.
  MultiPostingsEnum.EnumWithSlice | Holds a `PostingsEnum` along with the corresponding `ReaderSlice`.
  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.
  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.
  MultiTerms | Exposes flex API, merged from flex API of sub-segments.
  MultiTermsEnum | Exposes `TermsEnum` API, merged from `TermsEnum` API of sub-segments.
  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.
  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.
  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.
  NGramPhraseQuery | This is a `PhraseQuery` which is optimized for n-gram phrase query.
  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.
  NoDeletionPolicy | An `IndexDeletionPolicy` which keeps all index commits around, never deleting them.
  NoLockFactory | Use this `LockFactory` to disable locking entirely.
  NoMergePolicy | A `MergePolicy` which never returns merges to execute.
  NoMergeScheduler | A `MergeScheduler` which never executes any merges.
  NoOutputs | A null FST `Outputs` implementation; use this if you just want to build an FSA.
  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
  NormsConsumer | Abstract API that consumes normalization values.
  NormsFieldExistsQuery | Deprecated. Use `FieldExistsQuery` instead.
  NormsFormat | Encodes/decodes per-document score normalization values.
  NormsProducer | Abstract API that produces field normalization values
  NotDocIdSet | This `DocIdSet` encodes the negation of another `DocIdSet`.
  NRTCachingDirectory | Wraps a RAM-resident directory around any provided delegate directory, to be used during NRT search.
  NumericComparator<T extends 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.
  NumericUtils | Helper APIs to encode numeric values as sortable bytes and vice-versa.
  OffHeapByteVectorValues | Read the vector values from the index input.
  OffHeapByteVectorValues.DenseOffHeapVectorValues | Dense vector values that are stored off-heap.
  OffHeapFloatVectorValues | Read the vector values from the index input.
  OffHeapFloatVectorValues.DenseOffHeapVectorValues | Dense vector values that are stored off-heap.
  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.
  OfflinePointReader | Reads points from disk in a fixed-with format, previously written with `OfflinePointWriter`.
  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.
  OffsetAttribute | The start and end character offset of a Token.
  OffsetAttributeImpl | Default implementation of `OffsetAttribute`.
  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.
  Operations | Automata operations.
  OrdinalMap | Maps per-segment ordinals to/from global ordinal space, using a compact packed-ints representation.
  OrdinalTranslatedKnnCollector | Wraps a provided KnnCollector object, translating the provided vectorId ordinal to a documentId
  OrdTermState | An ordinal based `TermState`
  OrdToDocDISIReaderConfiguration | Configuration for `DirectMonotonicReader` and `IndexedDISI` for reading sparse vectors.
  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`.
  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.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.ReaderIterator | Run-once iterator interface, to decode previously saved PackedInts.
  PackedInts.Writer | A write-once Writer.
  PackedLongValues | Utility class to compress integers into a `LongValues` instance.
  PackedLongValues.Builder | A Builder for a `PackedLongValues` instance.
  PackedTokenAttributeImpl | Default implementation of the common attributes used by Lucene: `CharTermAttribute` `TypeAttribute` `PositionIncrementAttribute` `PositionLengthAttribute` `OffsetAttribute` `TermFrequencyAttribute`
  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.
  PayloadAttribute | The payload of a Token.
  PayloadAttributeImpl | Default implementation of `PayloadAttribute`.
  PerFieldDocValuesFormat | Enables per field docvalues support.
  PerFieldKnnVectorsFormat | Enables per field numeric vector support.
  PerFieldKnnVectorsFormat.FieldsReader | VectorReader that can wrap multiple delegate readers, selected by field.
  PerFieldPostingsFormat | Enables per field postings support.
  PerFieldSimilarityWrapper | Provides the ability to use a different `Similarity` for different fields.
  PersistentSnapshotDeletionPolicy | A `SnapshotDeletionPolicy` which adds a persistence layer so that snapshots can be maintained across the life of an application.
  PhraseMatcher | Base class for exact and sloppy phrase matching
  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
  PhraseWeight | Expert: Weight class for phrase matching
  Point | Represents a point on the earth's surface.
  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.
  PointRangeQuery | Abstract class for range queries against single or multidimensional points such as `IntPoint`.
  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.
  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.
  PointWriter | Appends many points, and then at the end provides a `PointReader` to iterate those points.
  Polygon | Represents a closed polygon on the earth's surface.
  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`.
  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.
  PostingsReaderBase | The core terms dictionaries (BlockTermsReader, BlockTreeTermsReader) interact with a single instance of this class to manage creation of `PostingsEnum` and `PostingsEnum` instances.
  PostingsWriterBase | Class that plugs into term dictionaries, such as `Lucene90BlockTreeTermsWriter`, and handles writing postings.
  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`.
  PrefixQuery | A Query that matches documents containing terms with a specified prefix.
  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.
  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.
  QueryBuilder | Creates queries from the `Analyzer` chain.
  QueryBuilder.TermAndBoost | Wraps a term and boost
  QueryCache | A cache for queries.
  QueryCachingPolicy | A policy defining which filters should be cached.
  QueryRescorer | A `Rescorer` that uses a provided Query to assign scores to the first-pass hits.
  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.
  QueryVisitor | Allows recursion through a query tree
  RadixSelector | Radix selector.
  RamUsageEstimator | Estimates the size (memory representation) of Java 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<T> | Provides random access to vectors by dense ordinal.
  RandomVectorScorer | A `RandomVectorScorer` for scoring random nodes in batches against an abstract query.
  RandomVectorScorer.AbstractRandomVectorScorer<T> | Creates a default scorer for random access vectors.
  RandomVectorScorerSupplier | A supplier that creates `RandomVectorScorer` from an ordinal.
  RandomVectorScorerSupplier.ByteScoringSupplier | RandomVectorScorerSupplier for bytes vector
  RandomVectorScorerSupplier.FloatScoringSupplier | RandomVectorScorerSupplier for Float vector
  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.
  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.
  ReaderSlice | Subreader slice from a parent composite reader.
  ReaderUtil | Common util methods for dealing with `IndexReader`s and `IndexReaderContext`s.
  Rectangle | Represents a lat/lon rectangle.
  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()`.
  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.
  RegExp | Regular Expression extension to `Automaton`.
  RegExp.Kind | The type of expression represented by a RegExp node.
  RegexpQuery | A fast regular expression query based on the `org.apache.lucene.util.automaton` package.
  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`.
  RoaringDocIdSet | `DocIdSet` implementation inspired from http://roaringbitmap.org/
  RoaringDocIdSet.Builder | A builder of `RoaringDocIdSet`s.
  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
  RunAutomaton | Finite-state automaton with fast run operation.
  SameThreadExecutorService | An `ExecutorService` that executes tasks immediately in the calling thread during submit.
  ScalarQuantizedRandomVectorScorer | Quantized vector scorer
  ScalarQuantizedRandomVectorScorerSupplier | Quantized vector scorer supplier
  ScalarQuantizedVectorSimilarity | Calculates and adjust the scores correctly for quantized vectors given the scalar quantization parameters
  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.
  Scorable | Allows access to the score of a Query
  Scorable.ChildScorable | A child Scorer and its relationship to its parent.
  ScoreCachingWrappingScorer | A `Scorer` which wraps another scorer and caches the score of the current document.
  ScoreDoc | Holds one hit in `TopDocs`.
  ScoreMode | Different modes of search.
  Scorer | Expert: Common scoring functionality for different types of queries.
  ScorerSupplier | A supplier of `Scorer`.
  ScoringRewrite<B> | Base rewrite method that translates each term into a query, and keeps the scores as computed by the query.
  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)`.
  SearcherManager | Utility class to safely share `IndexSearcher` instances across multiple threads, while periodically reopening.
  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.
  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.
  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.
  SegmentWriteState | Holder class for common parameters used during write.
  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.
  SerialMergeScheduler | A `MergeScheduler` that simply does each merge sequentially, using the current thread.
  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.
  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
  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.
  SimpleCollector | Base `Collector` implementation that is used to collect all contexts.
  SimpleFieldComparator<T> | Base `FieldComparator` implementation that is used for all contexts.
  SimpleFSLockFactory | Implements `LockFactory` using `Files.createFile(java.nio.file.Path, java.nio.file.attribute.FileAttribute<?>...)`.
  SimpleMergedSegmentWarmer | A very simple merged segment warmer that just ensures data structures are initialized.
  SimpleWKTShapeParser | Parses shape geometry represented in WKT format
  SimpleWKTShapeParser.ShapeType | Enumerated type for Shapes
  SingleInstanceLockFactory | Implements `LockFactory` for a single in-process instance, meaning all locking will take place through this one instance.
  SingleTermsEnum | Subclass of FilteredTermsEnum for enumerating a single term.
  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.
  SlowCodecReaderWrapper | Wraps arbitrary readers for merging.
  SlowImpactsEnum | `ImpactsEnum` that doesn't index impacts but implements the API in a legal way.
  SmallFloat | Floating point numbers smaller than 32 bits.
  SnapshotDeletionPolicy | An `IndexDeletionPolicy` that wraps any other `IndexDeletionPolicy` and adds the ability to hold and later release snapshots of an index.
  SoftDeletesDirectoryReaderWrapper | This reader filters out documents that have a doc values value in the given field and treat these documents as soft deleted.
  SoftDeletesRetentionMergePolicy | This `MergePolicy` allows to carry over soft deleted documents across merges.
  Sort | Encapsulates sort criteria for returned hits.
  SortedDocValues | A per-document byte[] with presorted values.
  SortedDocValuesField | Field that stores a per-document `BytesRef` value, indexed for sorting.
  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.
  SortedNumericSelector | Selects a value from the document's list to use as the representative value
  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.
  SortedSetSelector | Selects a value from the document's set to use as the representative value
  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.
  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
  SortingCodecReader | An `CodecReader` which supports sorting documents by a given `Sort`.
  SortRescorer | A `Rescorer` that re-sorts according to a provided Sort.
  SparseFixedBitSet | A bit set that only stores longs that have at least one bit which is set.
  StableMSBRadixSorter | Stable radix sorter for variable-length strings.
  StableMSBRadixSorter.MergeSorter | A MergeSorter taking advantage of temporary storage.
  StandardAnalyzer | Filters `StandardTokenizer` with `LowerCaseFilter` and `StopFilter`, using a configurable list of stop words.
  StandardDirectoryReader | Default implementation of `DirectoryReader`.
  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.
  StatePair | Pair of states.
  Stats | BlockTree statistics for a single field returned by `FieldReader.getStats()`.
  StopFilter | Removes stop words from a token stream.
  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.
  StoredFieldsFormat | Controls the format of stored fields
  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.
  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`.
  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>)`
  SuppressForbidden | Annotation to suppress forbidden-apis errors inside a whole class, a method, or a field.
  SynonymQuery | A query that treats multiple terms as synonyms.
  SynonymQuery.Builder | A builder for `SynonymQuery`.
  TaskExecutor | Executor wrapper responsible for the execution of concurrent tasks.
  Term | A Term represents a word from text.
  TermAndVector | Word2Vec unit composed by a term with the associated vector
  TermFrequencyAttribute | Sets the custom term frequency of a term within one document.
  TermFrequencyAttributeImpl | Default implementation of `TermFrequencyAttribute`.
  TermInSetQuery | Specialization for a disjunction over many terms that, by default, behaves like a `ConstantScoreQuery` over a `BooleanQuery` containing only `BooleanClause.Occur.SHOULD` clauses.
  TermOrdValComparator | Sorts by field's natural Term sort order, using ordinals.
  TermQuery | A Query that matches documents containing a term.
  TermRangeQuery | A Query that matches documents within an range of terms.
  Terms | Access to the terms in a specific field.
  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)`.
  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.
  TermStatistics | Contains statistics for a specific term
  TermStats | Holder for per-term statistics.
  TermToBytesRefAttribute | This attribute is requested by TermsHashPerField to index the contents.
  TermVectors | API for reading term vectors.
  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.
  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.Triangle | Triangle in the tessellated mesh
  TestSecrets | A set of static methods returning accessors for internal, package-private functionality in Lucene.
  TextField | A field that is indexed and tokenized, without term vectors.
  TFIDFSimilarity | Implementation of `Similarity` with the Vector Space Model.
  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.MergeScore | Holds score and explanation for a single candidate merge.
  TimeLimitingCollector | The `TimeLimitingCollector` is used to timeout search requests that take longer than the maximum allowed search time limit.
  TimeLimitingCollector.TimeExceededException | Thrown when elapsed search time exceeds allowed search time.
  TimeLimitingCollector.TimerThread | Thread used to timeout search requests.
  TimSorter | `Sorter` implementation based on the TimSort algorithm.
  TokenFilter | A TokenFilter is a TokenStream whose input is another TokenStream.
  TokenFilterFactory | Abstract parent class for analysis factories that create `TokenFilter` instances.
  Tokenizer | A Tokenizer is a TokenStream whose input is a Reader.
  TokenizerFactory | Abstract parent class for analysis factories that create `Tokenizer` instances.
  TokenStream | A `TokenStream` enumerates the sequence of tokens, either from `Field`s of a `Document` or from query text.
  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`.
  TooComplexToDeterminizeException | This exception is thrown when determinizing an automaton would require too much work.
  TopDocs | Represents hits returned by `IndexSearcher.search(Query,int)`.
  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.
  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)`.
  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.ScorerLeafCollector | Scorable leaf collector
  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
  TopTermsRewrite<B> | Base rewrite method for collecting only the top terms via a priority queue.
  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.
  TrackingDirectoryWrapper | A delegating Directory that records which files were written to and deleted.
  Transition | Holds one transition from an `Automaton`.
  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`.
  TypeAttribute | A Token's lexical type.
  TypeAttributeImpl | Default implementation of `TypeAttribute`.
  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
  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)`.
  UsageTrackingQueryCachingPolicy | A `QueryCachingPolicy` that tracks usage statistics of recently-used filters in order to decide on which filters are worth caching.
  UTF32ToUTF8 | Converts UTF-32 automata to the equivalent UTF-8 representation.
  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.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`
  VectorEncoding | The numeric datatype of the vector values.
  VectorizationProvider | A provider of vectorization implementations.
  VectorSimilarityFunction | Vector similarity function; used in search to return top K most similar vectors to a target vector.
  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
  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.
  VirtualMethod<C> | A utility for keeping backwards compatibility on previously abstract methods (or similar replacements).
  WeakIdentityMap<K,​V> | Implements a combination of `WeakHashMap` and `IdentityHashMap`.
  Weight | Expert: Calculate query weights and build query scorers.
  Weight.DefaultBulkScorer | Just wraps a Scorer and performs top scoring using it.
  WildcardQuery | Implements the wildcard search query.
  WordlistLoader | Loader for text files that represent a list of stopwords.
  XYCircle | Represents a circle on the XY plane.
  XYDocValuesField | An per-document location field.
  XYDocValuesPointInGeometryQuery | XYGeometry query for `XYDocValuesField`.
  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.
  XYPointField | An indexed XY position field.
  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.