Strings.Designer.cs

//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:4.0.30319.42000
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace Lucene.Net.Cli.Resources {
    using System;
    using System.Reflection;


    /// <summary>
    ///    A strongly-typed resource class, for looking up localized strings, etc.
    /// </summary>
    // This class was auto-generated by the StronglyTypedResourceBuilder
    // class via a tool like ResGen or Visual Studio.
    // To add or remove a member, edit your .ResX file then rerun ResGen
    // with the /str option, or rebuild your VS project.
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    public class Strings {

        private static global::System.Resources.ResourceManager resourceMan;

        private static global::System.Globalization.CultureInfo resourceCulture;

        internal Strings() {
        }

        /// <summary>
        ///    Returns the cached ResourceManager instance used by this class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        public static global::System.Resources.ResourceManager ResourceManager {
            get {
                if (object.ReferenceEquals(resourceMan, null)) {
                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("lucene-cli.Resources.Strings", typeof(Strings).GetTypeInfo().Assembly);
                    resourceMan = temp;
                }
                return resourceMan;
            }
        }

        /// <summary>
        ///    Overrides the current thread's CurrentUICulture property for all
        ///    resource lookups using this strongly typed resource class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        public static global::System.Globalization.CultureInfo Culture {
            get {
                return resourceCulture;
            }
            set {
                resourceCulture = value;
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Utilities to manage specialized analyzers..
        /// </summary>
        public static string AnalysisCommandDescription {
            get {
                return ResourceManager.GetString("AnalysisCommandDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Generates a set of custom dictionary files for the Lucene.Net.Analysis.Kuromoji library..
        /// </summary>
        public static string AnalysisKuromojiBuildDictionaryCommandDescription {
            get {
                return ResourceManager.GetString("AnalysisKuromojiBuildDictionaryCommandDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to  Generates the following set of binary files:
        ///
        ///- CharacterDefinition.dat
        ///- ConnectionCosts.dat
        ///- TokenInfoDictionary$buffer.dat
        ///- TokenInfoDictionary$fst.dat
        ///- TokenInfoDictionary$posDict.dat
        ///- TokenInfoDictionary$targetMap.dat
        ///- UnknownDictionary$buffer.dat
        ///- UnknownDictionary$posDict.dat
        ///- UnknownDictionary$targetMap.dat
        ///
        ///If these files are placed into a subdirectory of your application named &apos;kuromoji-data&apos;, they will be used automatically by Lucene.Net.Analysis.Kuromoji features such as the J [rest of string was truncated]&quot;;.
        /// </summary>
        public static string AnalysisKuromojiBuildDictionaryCommandExtendedHelpText {
            get {
                return ResourceManager.GetString("AnalysisKuromojiBuildDictionaryCommandExtendedHelpText", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to The dictionary format. Valid values are IPADIC and UNIDIC. If an invalid value is passed, IPADIC is assumed..
        /// </summary>
        public static string AnalysisKuromojiBuildDictionaryCommandFormatDescription {
            get {
                return ResourceManager.GetString("AnalysisKuromojiBuildDictionaryCommandFormatDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to The directory where the dictionary input files are located..
        /// </summary>
        public static string AnalysisKuromojiBuildDictionaryCommandInputDirectoryDescription {
            get {
                return ResourceManager.GetString("AnalysisKuromojiBuildDictionaryCommandInputDirectoryDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to The file encoding used by the input files. If not supplied, the default value is EUC-JP..
        /// </summary>
        public static string AnalysisKuromojiBuildDictionaryCommandInputDirectoryEncodingDescription {
            get {
                return ResourceManager.GetString("AnalysisKuromojiBuildDictionaryCommandInputDirectoryEncodingDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Normalize the entries using normalization form KC..
        /// </summary>
        public static string AnalysisKuromojiBuildDictionaryCommandNormalizeDescription {
            get {
                return ResourceManager.GetString("AnalysisKuromojiBuildDictionaryCommandNormalizeDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to The directory to put the dictionary output..
        /// </summary>
        public static string AnalysisKuromojiBuildDictionaryCommandOutputDirectoryDescription {
            get {
                return ResourceManager.GetString("AnalysisKuromojiBuildDictionaryCommandOutputDirectoryDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Compiles a stemmer table for the Egothor stemmer..
        /// </summary>
        public static string AnalysisStempelCompileStemsCommandDescription {
            get {
                return ResourceManager.GetString("AnalysisStempelCompileStemsCommandDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to The path to a file containing a stemmer table. Multiple values are allowed..
        /// </summary>
        public static string AnalysisStempelCompileStemsCommandStemmerTableFilesDescription {
            get {
                return ResourceManager.GetString("AnalysisStempelCompileStemsCommandStemmerTableFilesDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to The encoding to use for the stemmer table files. If not supplied, defaults to UTF-8..
        /// </summary>
        public static string AnalysisStempelCompileStemsCommandStemmerTableFilesEncodingDescription {
            get {
                return ResourceManager.GetString("AnalysisStempelCompileStemsCommandStemmerTableFilesEncodingDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to The name of the desired stemming algorithm to use..
        /// </summary>
        public static string AnalysisStempelCompileStemsCommandStemmingAlgorithmDescription {
            get {
                return ResourceManager.GetString("AnalysisStempelCompileStemsCommandStemmingAlgorithmDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Generates patch commands from an already prepared stemmer table..
        /// </summary>
        public static string AnalysisStempelPatchStemsCommandDescription {
            get {
                return ResourceManager.GetString("AnalysisStempelPatchStemsCommandDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to The path to a file containing a stemmer table. Multiple values are allowed..
        /// </summary>
        public static string AnalysisStempelPatchStemsCommandStemmerTableFilesDescription {
            get {
                return ResourceManager.GetString("AnalysisStempelPatchStemsCommandStemmerTableFilesDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to The encoding to use for the stemmer table files. If not supplied, defaults to UTF-8..
        /// </summary>
        public static string AnalysisStempelPatchStemsCommandStemmerTableFilesEncodingDescription {
            get {
                return ResourceManager.GetString("AnalysisStempelPatchStemsCommandStemmerTableFilesEncodingDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Utilities for benchmarking Lucene.Net..
        /// </summary>
        public static string BenchmarkCommandDescription {
            get {
                return ResourceManager.GetString("BenchmarkCommandDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Splits Reuters SGML documents into simple text files containing: Title, Date, Dateline, Body..
        /// </summary>
        public static string BenchmarkExtractReutersCommandDescription {
            get {
                return ResourceManager.GetString("BenchmarkExtractReutersCommandDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Path to Reuters SGML files..
        /// </summary>
        public static string BenchmarkExtractReutersCommandInputDirectoryDescription {
            get {
                return ResourceManager.GetString("BenchmarkExtractReutersCommandInputDirectoryDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Path to a directory where the output files will be written..
        /// </summary>
        public static string BenchmarkExtractReutersCommandOutputDirectoryDescription {
            get {
                return ResourceManager.GetString("BenchmarkExtractReutersCommandOutputDirectoryDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Extracts a downloaded Wikipedia dump into separate files for indexing..
        /// </summary>
        public static string BenchmarkExtractWikipediaCommandDescription {
            get {
                return ResourceManager.GetString("BenchmarkExtractWikipediaCommandDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Tells the extractor to skip WIKI docs that contain only images..
        /// </summary>
        public static string BenchmarkExtractWikipediaCommandDiscardImageOnlyDocsDescription {
            get {
                return ResourceManager.GetString("BenchmarkExtractWikipediaCommandDiscardImageOnlyDocsDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Input path to a Wikipedia XML file..
        /// </summary>
        public static string BenchmarkExtractWikipediaCommandInputWikipediaFileDescription {
            get {
                return ResourceManager.GetString("BenchmarkExtractWikipediaCommandInputWikipediaFileDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Path to a directory where the output files will be written..
        /// </summary>
        public static string BenchmarkExtractWikipediaCommandOutputDirectoryDescription {
            get {
                return ResourceManager.GetString("BenchmarkExtractWikipediaCommandOutputDirectoryDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Suggests quality queries based on index contents. Used for making quality test benchmarks..
        /// </summary>
        public static string BenchmarkFindQualityQueriesCommandDescription {
            get {
                return ResourceManager.GetString("BenchmarkFindQualityQueriesCommandDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to An algorithm file specifying the parameters of the benchmark to run..
        /// </summary>
        public static string BenchmarkRunCommandAlgorithmFileDescription {
            get {
                return ResourceManager.GetString("BenchmarkRunCommandAlgorithmFileDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Runs a benchmark based on an algorithm file..
        /// </summary>
        public static string BenchmarkRunCommandDescription {
            get {
                return ResourceManager.GetString("BenchmarkRunCommandDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Runs a TREC evaluation..
        /// </summary>
        public static string BenchmarkRunTrecEvalCommandDescription {
            get {
                return ResourceManager.GetString("BenchmarkRunTrecEvalCommandDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Output submission file for TREC evaluation..
        /// </summary>
        public static string BenchmarkRunTrecEvalCommandOutputSubmissionFileDescription {
            get {
                return ResourceManager.GetString("BenchmarkRunTrecEvalCommandOutputSubmissionFileDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Use description field in query..
        /// </summary>
        public static string BenchmarkRunTrecEvalCommandQueryOnDescriptionDescription {
            get {
                return ResourceManager.GetString("BenchmarkRunTrecEvalCommandQueryOnDescriptionDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Use narrative field in query..
        /// </summary>
        public static string BenchmarkRunTrecEvalCommandQueryOnNarrativeDescription {
            get {
                return ResourceManager.GetString("BenchmarkRunTrecEvalCommandQueryOnNarrativeDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Use title field in query. This flag will automatically be on if no other field is specified..
        /// </summary>
        public static string BenchmarkRunTrecEvalCommandQueryOnTitleDescription {
            get {
                return ResourceManager.GetString("BenchmarkRunTrecEvalCommandQueryOnTitleDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Input file conataining relevance judgements..
        /// </summary>
        public static string BenchmarkRunTrecEvalCommandQueryRelevanceFileDescription {
            get {
                return ResourceManager.GetString("BenchmarkRunTrecEvalCommandQueryRelevanceFileDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Input file containing queries..
        /// </summary>
        public static string BenchmarkRunTrecEvalCommandTopicsFileDescription {
            get {
                return ResourceManager.GetString("BenchmarkRunTrecEvalCommandTopicsFileDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Sample of a performance test written programmatically instead of using an algorithm file..
        /// </summary>
        public static string BenchmarkSampleCommandDescription {
            get {
                return ResourceManager.GetString("BenchmarkSampleCommandDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Cross check term vectors..
        /// </summary>
        public static string CrossCheckTermVectorsDescription {
            get {
                return ResourceManager.GetString("CrossCheckTermVectorsDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Shows example usage of category associations..
        /// </summary>
        public static string DemoAssociationsFacetsCommandDescription {
            get {
                return ResourceManager.GetString("DemoAssociationsFacetsCommandDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Demos for various Lucene.Net functionality including C# code samples..
        /// </summary>
        public static string DemoCommandDescription {
            get {
                return ResourceManager.GetString("DemoCommandDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Shows simple usage of dynamic range faceting, using the expressions module to calculate distance..
        /// </summary>
        public static string DemoDistanceFacetsCommandDescription {
            get {
                return ResourceManager.GetString("DemoDistanceFacetsCommandDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Shows facets aggregation by an expression..
        /// </summary>
        public static string DemoExpressionAggregationFacetsCommandDescription {
            get {
                return ResourceManager.GetString("DemoExpressionAggregationFacetsCommandDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Index all text files under a directory..
        /// </summary>
        public static string DemoIndexFilesCommandDescription {
            get {
                return ResourceManager.GetString("DemoIndexFilesCommandDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to This demo can be used to learn how to build a Lucene.Net index. After the index is built, you can run the search-files demo to run queries against it..
        /// </summary>
        public static string DemoIndexFilesCommandExtendedHelpText {
            get {
                return ResourceManager.GetString("DemoIndexFilesCommandExtendedHelpText", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to The source directory containing files to index. This operation is recursive..
        /// </summary>
        public static string DemoIndexFilesCommandSourceDirectoryDescription {
            get {
                return ResourceManager.GetString("DemoIndexFilesCommandSourceDirectoryDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Adds new documents to an existing index. If not supplied, any existing index in the &lt;INDEX_DIRECTORY&gt; will be overwritten..
        /// </summary>
        public static string DemoIndexFilesCommandUpdateDescription {
            get {
                return ResourceManager.GetString("DemoIndexFilesCommandUpdateDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Demonstrates indexing categories into different indexed fields..
        /// </summary>
        public static string DemoMultiCategoryListsFacetsCommandDescription {
            get {
                return ResourceManager.GetString("DemoMultiCategoryListsFacetsCommandDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Shows simple usage of dynamic range faceting..
        /// </summary>
        public static string DemoRangeFacetsCommandDescription {
            get {
                return ResourceManager.GetString("DemoRangeFacetsCommandDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Simple command-line based search demo. Run index-files demo first..
        /// </summary>
        public static string DemoSearchFilesCommandDescription {
            get {
                return ResourceManager.GetString("DemoSearchFilesCommandDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Run the index-files demo first to create an index to run this command against. You can either use a file containing many queries (each on a single line), a single query on the command line, or omit both options to run queries interactively..
        /// </summary>
        public static string DemoSearchFilesCommandExtendedHelpText {
            get {
                return ResourceManager.GetString("DemoSearchFilesCommandExtendedHelpText", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to The index field to use in the search. If not supplied, defaults to &quot;contents&quot;..
        /// </summary>
        public static string DemoSearchFilesCommandFieldDescription {
            get {
                return ResourceManager.GetString("DemoSearchFilesCommandFieldDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Hits per page to display..
        /// </summary>
        public static string DemoSearchFilesCommandPageSizeDescription {
            get {
                return ResourceManager.GetString("DemoSearchFilesCommandPageSizeDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to A file containing the queries to perform..
        /// </summary>
        public static string DemoSearchFilesCommandQueriesFileDescription {
            get {
                return ResourceManager.GetString("DemoSearchFilesCommandQueriesFileDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to A query to perform..
        /// </summary>
        public static string DemoSearchFilesCommandQueryDescription {
            get {
                return ResourceManager.GetString("DemoSearchFilesCommandQueryDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Output raw format..
        /// </summary>
        public static string DemoSearchFilesCommandRawDescription {
            get {
                return ResourceManager.GetString("DemoSearchFilesCommandRawDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Repeat the search and time as a benchmark..
        /// </summary>
        public static string DemoSearchFilesCommandRepeatDescription {
            get {
                return ResourceManager.GetString("DemoSearchFilesCommandRepeatDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Shows simple usage of faceted indexing and search..
        /// </summary>
        public static string DemoSimpleFacetsCommandDescription {
            get {
                return ResourceManager.GetString("DemoSimpleFacetsCommandDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Shows simple usage of faceted indexing and search using SortedSetDocValuesFacetField and SortedSetDocValuesFacetCounts..
        /// </summary>
        public static string DemoSimpleSortedSetFacetsCommandDescription {
            get {
                return ResourceManager.GetString("DemoSimpleSortedSetFacetsCommandDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to The FSDirectory implementation to use. Defaults to the optimal FSDirectory for your OS platform..
        /// </summary>
        public static string DirectoryTypeOptionDescription {
            get {
                return ResourceManager.GetString("DirectoryTypeOptionDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Source code exported to &apos;{0}&apos;..
        /// </summary>
        public static string ExportingSourceCodeCompleteMessage {
            get {
                return ResourceManager.GetString("ExportingSourceCodeCompleteMessage", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Exporting source code....
        /// </summary>
        public static string ExportingSourceCodeMessage {
            get {
                return ResourceManager.GetString("ExportingSourceCodeMessage", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to An error occurred:.
        /// </summary>
        public static string GeneralExceptionMessage {
            get {
                return ResourceManager.GetString("GeneralExceptionMessage", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Specify --help for a list of available options and commands..
        /// </summary>
        public static string HelpCommandsMessage {
            get {
                return ResourceManager.GetString("HelpCommandsMessage", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Checks an index for problematic segments..
        /// </summary>
        public static string IndexCheckCommandDescription {
            get {
                return ResourceManager.GetString("IndexCheckCommandDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Basic tool to check the health of an index.
        ///
        ///As this tool checks every byte in the index, on a large index it can take quite a long time to run..
        /// </summary>
        public static string IndexCheckCommandExtendedHelpText {
            get {
                return ResourceManager.GetString("IndexCheckCommandExtendedHelpText", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Only check the specified segment(s). This can be specified multiple times, to check more than one segment, eg --segment _2 --segment _a..
        /// </summary>
        public static string IndexCheckCommandSegmentsDescription {
            get {
                return ResourceManager.GetString("IndexCheckCommandSegmentsDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Utilities to analyze or maintain an index..
        /// </summary>
        public static string IndexCommandDescription {
            get {
                return ResourceManager.GetString("IndexCommandDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Copies segments from one index to another index..
        /// </summary>
        public static string IndexCopySegmentsCommandDescription {
            get {
                return ResourceManager.GetString("IndexCopySegmentsCommandDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to This tool does file-level copying of segments files. This means it&apos;s unable to split apart a single segment into multiple segments. For example if your index is a single segment, this tool won&apos;t help. Also, it does basic file-level copying (using a simple FileStream) so it will not work with non FSDirectory Directory implementations..
        /// </summary>
        public static string IndexCopySegmentsCommandExtendedHelpText {
            get {
                return ResourceManager.GetString("IndexCopySegmentsCommandExtendedHelpText", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to The directory of the index to copy..
        /// </summary>
        public static string IndexCopySegmentsCommandInputDirectoryDescription {
            get {
                return ResourceManager.GetString("IndexCopySegmentsCommandInputDirectoryDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to The directory of the destination index..
        /// </summary>
        public static string IndexCopySegmentsCommandOutputDirectoryDescription {
            get {
                return ResourceManager.GetString("IndexCopySegmentsCommandOutputDirectoryDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to The segments to copy, separated by a space..
        /// </summary>
        public static string IndexCopySegmentsCommandSegmentsDescription {
            get {
                return ResourceManager.GetString("IndexCopySegmentsCommandSegmentsDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Deletes segments from an index..
        /// </summary>
        public static string IndexDeleteSegmentsCommandDescription {
            get {
                return ResourceManager.GetString("IndexDeleteSegmentsCommandDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to You can easily accidentally remove segments from your index so be careful! Always make a backup of your index first..
        /// </summary>
        public static string IndexDeleteSegmentsCommandExtendedHelpText {
            get {
                return ResourceManager.GetString("IndexDeleteSegmentsCommandExtendedHelpText", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to The segments to delete, separated by a space..
        /// </summary>
        public static string IndexDeleteSegmentsCommandSegmentsDescription {
            get {
                return ResourceManager.GetString("IndexDeleteSegmentsCommandSegmentsDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to The directory of the index..
        /// </summary>
        public static string IndexDirectoryArgumentDescription {
            get {
                return ResourceManager.GetString("IndexDirectoryArgumentDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to If omitted, it defaults to the current working directory..
        /// </summary>
        public static string IndexDirectoryOptionalArgumentDescription {
            get {
                return ResourceManager.GetString("IndexDirectoryOptionalArgumentDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to The .cfs compound file containing words to parse..
        /// </summary>
        public static string IndexExtractCfsCommandCFSFileNameDescription {
            get {
                return ResourceManager.GetString("IndexExtractCfsCommandCFSFileNameDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Extracts sub-files from a .cfs compound file..
        /// </summary>
        public static string IndexExtractCfsCommandDescription {
            get {
                return ResourceManager.GetString("IndexExtractCfsCommandDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Extracts `.cfs` compound files (that were created using the CompoundFileDirectory from Lucene.Net.Misc) to the current working directory.
        ///
        ///In order to make the extracted version of the index work, you have to copy the segments file from the compound index into the directory where the extracted files are stored..
        /// </summary>
        public static string IndexExtractCfsCommandExtendedHelpText {
            get {
                return ResourceManager.GetString("IndexExtractCfsCommandExtendedHelpText", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Fixes an index by removing problematic segments..
        /// </summary>
        public static string IndexFixCommandDescription {
            get {
                return ResourceManager.GetString("IndexFixCommandDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Doesn&apos;t change the index, but reports any actions that would be taken if this option were not supplied..
        /// </summary>
        public static string IndexFixCommandDryRunDescription {
            get {
                return ResourceManager.GetString("IndexFixCommandDryRunDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to  Basic tool to check and fix the health of an index and write a new segments file that removes reference to problematic segments.
        ///
        ///As this tool checks every byte in the index, on a large index it can take quite a long time to run.
        ///
        ///WARNING: This command should only be used on an emergency basis as it will cause documents (perhaps many) to be permanently removed from the index. Always make a backup copy of your index before running this! Do not run this tool on an index that is actively being written to. [rest of string was truncated]&quot;;.
        /// </summary>
        public static string IndexFixCommandExtendedHelpText {
            get {
                return ResourceManager.GetString("IndexFixCommandExtendedHelpText", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to The .cfs compound file containing words to parse..
        /// </summary>
        public static string IndexListCfsCommandCFSFileNameDescription {
            get {
                return ResourceManager.GetString("IndexListCfsCommandCFSFileNameDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Lists sub-files out of a .cfs compound file..
        /// </summary>
        public static string IndexListCfsCommandDescription {
            get {
                return ResourceManager.GetString("IndexListCfsCommandDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Prints the filename and size of each file within a given `.cfs` compound file. The .cfs compound file format is created using the CompoundFileDirectory from Lucene.Net.Misc..
        /// </summary>
        public static string IndexListCfsCommandExtendedHelpText {
            get {
                return ResourceManager.GetString("IndexListCfsCommandExtendedHelpText", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Lists the top N most frequent terms by document frequency..
        /// </summary>
        public static string IndexListHighFreqTermsCommandDescription {
            get {
                return ResourceManager.GetString("IndexListHighFreqTermsCommandDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Extracts the top N most frequent terms (by document frequency) from an index and reports thier document frequency..
        /// </summary>
        public static string IndexListHighFreqTermsCommandExtendedHelpText {
            get {
                return ResourceManager.GetString("IndexListHighFreqTermsCommandExtendedHelpText", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to The field to consider. If omitted, considers all fields..
        /// </summary>
        public static string IndexListHighFreqTermsCommandFieldDescription {
            get {
                return ResourceManager.GetString("IndexListHighFreqTermsCommandFieldDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to The number of terms to consider. If omitted, defaults to 100..
        /// </summary>
        public static string IndexListHighFreqTermsCommandNumberOfTermsDescription {
            get {
                return ResourceManager.GetString("IndexListHighFreqTermsCommandNumberOfTermsDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Specifies that both the document frequency &amp; term frequency are reported, ordered by descending total term frequency..
        /// </summary>
        public static string IndexListHighFreqTermsCommandTotalTermFrequencyDescription {
            get {
                return ResourceManager.GetString("IndexListHighFreqTermsCommandTotalTermFrequencyDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Lists segments in an index..
        /// </summary>
        public static string IndexListSegmentsCommandDescription {
            get {
                return ResourceManager.GetString("IndexListSegmentsCommandDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to After running this command to view segments, use copy-segments to copy segments from one index directory to another or delete-segments to remove segments from an index..
        /// </summary>
        public static string IndexListSegmentsExtendedHelpText {
            get {
                return ResourceManager.GetString("IndexListSegmentsExtendedHelpText", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Displays the taxonomy statistical information for a taxonomy index..
        /// </summary>
        public static string IndexListTaxonomyStatsCommandDescription {
            get {
                return ResourceManager.GetString("IndexListTaxonomyStatsCommandDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Prints how many ords are under each dimension..
        /// </summary>
        public static string IndexListTaxonomyStatsCommandExtendedHelpText {
            get {
                return ResourceManager.GetString("IndexListTaxonomyStatsCommandExtendedHelpText", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Recursively lists all descendant nodes..
        /// </summary>
        public static string IndexListTaxonomyStatsCommandShowTreeDescription {
            get {
                return ResourceManager.GetString("IndexListTaxonomyStatsCommandShowTreeDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Gets document frequency and total number of occurrences of a term..
        /// </summary>
        public static string IndexListTermInfoCommandDescription {
            get {
                return ResourceManager.GetString("IndexListTermInfoCommandDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Gets document frequency and total number of occurrences (sum of the term frequency for each document) of a term..
        /// </summary>
        public static string IndexListTermInfoCommandExtendedHelpText {
            get {
                return ResourceManager.GetString("IndexListTermInfoCommandExtendedHelpText", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to The field to consider..
        /// </summary>
        public static string IndexListTermInfoCommandFieldDescription {
            get {
                return ResourceManager.GetString("IndexListTermInfoCommandFieldDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to The directory of the index..
        /// </summary>
        public static string IndexListTermInfoCommandIndexDirectoryDescription {
            get {
                return ResourceManager.GetString("IndexListTermInfoCommandIndexDirectoryDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to The term to consider..
        /// </summary>
        public static string IndexListTermInfoCommandTermDescription {
            get {
                return ResourceManager.GetString("IndexListTermInfoCommandTermDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Merges multiple indexes into a single index..
        /// </summary>
        public static string IndexMergeCommandDescription {
            get {
                return ResourceManager.GetString("IndexMergeCommandDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Two or more source index directories separated by a space..
        /// </summary>
        public static string IndexMergeCommandInputDirectoryDescription {
            get {
                return ResourceManager.GetString("IndexMergeCommandInputDirectoryDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to The output directory to merge the input indexes into..
        /// </summary>
        public static string IndexMergeCommandOutputDirectoryDescription {
            get {
                return ResourceManager.GetString("IndexMergeCommandOutputDirectoryDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Splits an index into multiple parts..
        /// </summary>
        public static string IndexSplitCommandDescription {
            get {
                return ResourceManager.GetString("IndexSplitCommandDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to  Splits the input index into multiple equal parts. The method employed here uses IndexWriter.AddIndexes(IndexReader[]) where the input data comes from the input index with artificially applied deletes to the document ids that fall outside the selected partition.
        ///
        ///Deletes are only applied to a buffered list of deleted documents and don&apos;t affect the source index. This tool works also with read-only indexes.
        ///
        ///The disadvantage of this tool is that source index needs to be read as many times as there are part [rest of string was truncated]&quot;;.
        /// </summary>
        public static string IndexSplitCommandExtendedHelpText {
            get {
                return ResourceManager.GetString("IndexSplitCommandExtendedHelpText", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to The path of the source index, which can have deletions and can have multiple segments (or multiple readers). Multiple values can be supplied separated by a space..
        /// </summary>
        public static string IndexSplitCommandInputDirectoryDescription {
            get {
                return ResourceManager.GetString("IndexSplitCommandInputDirectoryDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to The number of parts (output indices) to produce. If omitted, defaults to 2..
        /// </summary>
        public static string IndexSplitCommandNumberOfPartsDescription {
            get {
                return ResourceManager.GetString("IndexSplitCommandNumberOfPartsDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Path to output directory to contain partial indexes..
        /// </summary>
        public static string IndexSplitCommandOutputDirectoryDescription {
            get {
                return ResourceManager.GetString("IndexSplitCommandOutputDirectoryDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Sequential doc-id range split (default is round-robin)..
        /// </summary>
        public static string IndexSplitCommandSequentialDescription {
            get {
                return ResourceManager.GetString("IndexSplitCommandSequentialDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Deletes prior commits..
        /// </summary>
        public static string IndexUpgradeCommandDeleteDescription {
            get {
                return ResourceManager.GetString("IndexUpgradeCommandDeleteDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Upgrades all segments of an index from previous Lucene.Net versions to the current segment file format..
        /// </summary>
        public static string IndexUpgradeCommandDescription {
            get {
                return ResourceManager.GetString("IndexUpgradeCommandDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to  This tool keeps only the last commit in an index; for this reason, if the incoming index has more than one commit, the tool refuses to run by default. Specify --delete-prior-commits to override this, allowing the tool to delete all but the last commit.
        ///
        ///Specify an FSDirectory implementation through the --directory-type option to force its use. If not qualified by an AssemblyName, the Lucene.Net.dll assembly will be used.
        ///
        ///WARNING: This tool may reorder document IDs! Be sure to make a backup of your in [rest of string was truncated]&quot;;.
        /// </summary>
        public static string IndexUpgradeCommandExtendedHelpText {
            get {
                return ResourceManager.GetString("IndexUpgradeCommandExtendedHelpText", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Utilities for verifying concurrent locking integrity..
        /// </summary>
        public static string LockCommandDescription {
            get {
                return ResourceManager.GetString("LockCommandDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Simple tool that forever acquires and releases a lock using a specific LockFactory..
        /// </summary>
        public static string LockStressTestCommandDescription {
            get {
                return ResourceManager.GetString("LockStressTestCommandDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to You should run multiple instances of this process, each with its own unique ID, and each pointing to the same lock directory, to verify that locking is working correctly. Make sure you are first running verify-server..
        /// </summary>
        public static string LockStressTestCommandExtendedHelpText {
            get {
                return ResourceManager.GetString("LockStressTestCommandExtendedHelpText", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to An integer from 0 - 255 (should be unique for test process)..
        /// </summary>
        public static string LockStressTestCommandIDDescription {
            get {
                return ResourceManager.GetString("LockStressTestCommandIDDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to The path to the lock directory (only utilized if LOCK_FACTORY_TYPE is set to SimpleFSLockFactory or NativeFSLockFactory)..
        /// </summary>
        public static string LockStressTestCommandLockDirectoryDescription {
            get {
                return ResourceManager.GetString("LockStressTestCommandLockDirectoryDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to The primary LockFactory implementation that we will use..
        /// </summary>
        public static string LockStressTestCommandLockFactoryTypeDescription {
            get {
                return ResourceManager.GetString("LockStressTestCommandLockFactoryTypeDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Milliseconds to pause between each lock obtain/release..
        /// </summary>
        public static string LockStressTestCommandSleepTimeMSDescription {
            get {
                return ResourceManager.GetString("LockStressTestCommandSleepTimeMSDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Number of locking tries..
        /// </summary>
        public static string LockStressTestCommandTriesDescription {
            get {
                return ResourceManager.GetString("LockStressTestCommandTriesDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Port that verify-server is listening on..
        /// </summary>
        public static string LockStressTestCommandVerfierPortDescription {
            get {
                return ResourceManager.GetString("LockStressTestCommandVerfierPortDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Hostname or IP address that verify-server is listening on..
        /// </summary>
        public static string LockStressTestCommandVerifierHostDescription {
            get {
                return ResourceManager.GetString("LockStressTestCommandVerifierHostDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Simple server that must be running when you use VerifyingLockFactory (or stress-test). This server verifies at most one process holds the lock at a time..
        /// </summary>
        public static string LockVerifyServerCommandDescription {
            get {
                return ResourceManager.GetString("LockVerifyServerCommandDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Hostname or IP address that verify-server will listen on..
        /// </summary>
        public static string LockVerifyServerCommandIPHostnameDescription {
            get {
                return ResourceManager.GetString("LockVerifyServerCommandIPHostnameDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to The maximum number of connected clients..
        /// </summary>
        public static string LockVerifyServerCommandMaxClientsDescription {
            get {
                return ResourceManager.GetString("LockVerifyServerCommandMaxClientsDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to {0} arguments are required..
        /// </summary>
        public static string NotEnoughArguments {
            get {
                return ResourceManager.GetString("NotEnoughArguments", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Output the source code of the demo to the specified directory..
        /// </summary>
        public static string OutputSourceCodeDescription {
            get {
                return ResourceManager.GetString("OutputSourceCodeDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Run &apos;demo {0} --view-source-code&apos; to see the C# code or &apos;demo {0} --output-source-code &lt;DIRECTORY&gt;&apos; to export the code to a local directory..
        /// </summary>
        public static string OutputSourceCodeMessage {
            get {
                return ResourceManager.GetString("OutputSourceCodeMessage", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Utilities and demos for Lucene.Net..
        /// </summary>
        public static string RootCommandDescription {
            get {
                return ResourceManager.GetString("RootCommandDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to One or more segments, separated by a space..
        /// </summary>
        public static string SegmentsArgumentDescription {
            get {
                return ResourceManager.GetString("SegmentsArgumentDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to An index segment..
        /// </summary>
        public static string SegmentsOptionDescription {
            get {
                return ResourceManager.GetString("SegmentsOptionDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Multiple segments are allowed..
        /// </summary>
        public static string SegmentsOptionMultipleDescription {
            get {
                return ResourceManager.GetString("SegmentsOptionMultipleDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to Verbose output..
        /// </summary>
        public static string VerboseOptionDescription {
            get {
                return ResourceManager.GetString("VerboseOptionDescription", resourceCulture);
            }
        }

        /// <summary>
        ///    Looks up a localized string similar to View the source code of the demo..
        /// </summary>
        public static string ViewSourceCodeDescription {
            get {
                return ResourceManager.GetString("ViewSourceCodeDescription", resourceCulture);
            }
        }
    }
}