NuGetCommand.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 NuGet.CommandLine {
    using System;
    
    
    /// <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.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "18.0.0.0")]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    internal class NuGetCommand {
        
        private static global::System.Resources.ResourceManager resourceMan;
        
        private static global::System.Globalization.CultureInfo resourceCulture;
        
        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal NuGetCommand() {
        }
        
        /// <summary>
        ///   Returns the cached ResourceManager instance used by this class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Resources.ResourceManager ResourceManager {
            get {
                if (object.ReferenceEquals(resourceMan, null)) {
                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("NuGet.CommandLine.NuGetCommand", typeof(NuGetCommand).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)]
        internal static global::System.Globalization.CultureInfo Culture {
            get {
                return resourceCulture;
            }
            set {
                resourceCulture = value;
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Adds the given package to a hierarchical source. http sources are not supported. For more info, goto https://docs.nuget.org/consume/command-line-reference#add-command..
        /// </summary>
        internal static string AddCommandDescription {
            get {
                return ResourceManager.GetString("AddCommandDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specifies the package source, which is a folder or UNC share, to which the nupkg will be added. Http sources are not supported..
        /// </summary>
        internal static string AddCommandSourceDescription {
            get {
                return ResourceManager.GetString("AddCommandSourceDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specifies the path to the package to be added and the package source, which is a folder or UNC share, to which the nupkg will be added. Http sources are not supported..
        /// </summary>
        internal static string AddCommandUsageDescription {
            get {
                return ResourceManager.GetString("AddCommandUsageDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to nuget add foo.nupkg  -Source c:\bar\
        ///
        ///nuget add foo.nupkg -Source \\bar\packages\.
        /// </summary>
        internal static string AddCommandUsageExamples {
            get {
                return ResourceManager.GetString("AddCommandUsageExamples", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;packagePath&gt; -Source &lt;folderBasedPackageSource&gt; [options].
        /// </summary>
        internal static string AddCommandUsageSummary {
            get {
                return ResourceManager.GetString("AddCommandUsageSummary", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Path to certificate file..
        /// </summary>
        internal static string ClientCertificatesCommandFilePathDescription {
            get {
                return ResourceManager.GetString("ClientCertificatesCommandFilePathDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Search method to find certificate in certificate store (see docs)..
        /// </summary>
        internal static string ClientCertificatesCommandFindByDescription {
            get {
                return ResourceManager.GetString("ClientCertificatesCommandFindByDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Search the certificate store for the supplied value. Used with FindValue (see docs)..
        /// </summary>
        internal static string ClientCertificatesCommandFindValueDescription {
            get {
                return ResourceManager.GetString("ClientCertificatesCommandFindValueDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Skip certificate validation..
        /// </summary>
        internal static string ClientCertificatesCommandForceDescription {
            get {
                return ResourceManager.GetString("ClientCertificatesCommandForceDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Package source name..
        /// </summary>
        internal static string ClientCertificatesCommandPackageSourceDescription {
            get {
                return ResourceManager.GetString("ClientCertificatesCommandPackageSourceDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Password for the certificate, if needed..
        /// </summary>
        internal static string ClientCertificatesCommandPasswordDescription {
            get {
                return ResourceManager.GetString("ClientCertificatesCommandPasswordDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Certificate store location (see docs)..
        /// </summary>
        internal static string ClientCertificatesCommandStoreLocationDescription {
            get {
                return ResourceManager.GetString("ClientCertificatesCommandStoreLocationDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Certificate store name (see docs)..
        /// </summary>
        internal static string ClientCertificatesCommandStoreNameDescription {
            get {
                return ResourceManager.GetString("ClientCertificatesCommandStoreNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Enables storing portable certificate password by disabling password encryption..
        /// </summary>
        internal static string ClientCertificatesCommandStorePasswordInClearTextDescription {
            get {
                return ResourceManager.GetString("ClientCertificatesCommandStorePasswordInClearTextDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to nuget client-certs Add -PackageSource Foo -Path .\MyCertificate.pfx
        ///
        ///nuget client-certs Add -PackageSource Contoso -Path c:\MyCertificate.pfx -Password 42
        ///
        ///nuget client-certs Add -PackageSource Foo -FindValue ca4e7b265780fc87f3cb90b6b89c54bf4341e755
        ///
        ///nuget client-certs Add -PackageSource Contoso -StoreLocation LocalMachine -StoreName My -FindBy Thumbprint -FindValue ca4e7b265780fc87f3cb90b6b89c54bf4341e755
        ///
        ///nuget client-certs Update -PackageSource Foo -FindValue ca4e7b265780fc87f3cb90b6b89c54bf4341e [rest of string was truncated]&quot;;.
        /// </summary>
        internal static string ClientCertificatesCommandUsageExamples {
            get {
                return ResourceManager.GetString("ClientCertificatesCommandUsageExamples", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;List|Add|Update|Remove&gt; [options].
        /// </summary>
        internal static string ClientCertificatesCommandUsageSummary {
            get {
                return ResourceManager.GetString("ClientCertificatesCommandUsageSummary", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Provides the ability to manage list of client certificates located in NuGet.config files.
        /// </summary>
        internal static string ClientCertificatesDescription {
            get {
                return ResourceManager.GetString("ClientCertificatesDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The API key for the server. If not set, the NUGET_API_KEY environment variable is read..
        /// </summary>
        internal static string CommandApiKey {
            get {
                return ResourceManager.GetString("CommandApiKey", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Download directly without populating any caches with metadata or binaries..
        /// </summary>
        internal static string CommandDirectDownload {
            get {
                return ResourceManager.GetString("CommandDirectDownload", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Disable parallel processing of packages for this command..
        /// </summary>
        internal static string CommandDisableParallelProcessing {
            get {
                return ResourceManager.GetString("CommandDisableParallelProcessing", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A list of package sources to use as fallbacks for this command..
        /// </summary>
        internal static string CommandFallbackSourceDescription {
            get {
                return ResourceManager.GetString("CommandFallbackSourceDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid value provided for &apos;{0}&apos;. For a list of accepted values, please visit https://docs.nuget.org/docs/reference/command-line-reference.
        /// </summary>
        internal static string CommandInvalidArgumentException {
            get {
                return ResourceManager.GetString("CommandInvalidArgumentException", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specifies the path of MSBuild to be used with this command. This command will takes precedence over MSbuildVersion, nuget will always pick MSbuild from this specified path..
        /// </summary>
        internal static string CommandMSBuildPath {
            get {
                return ResourceManager.GetString("CommandMSBuildPath", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specifies the version of MSBuild to be used with this command. Supported values are 4, 12, 14, 15.1, 15.3, 15.4, 15.5, 15.6, 15.7, 15.8, 15.9, 16.0. By default the MSBuild in your path is picked, otherwise it defaults to the highest installed version of MSBuild..
        /// </summary>
        internal static string CommandMSBuildVersion {
            get {
                return ResourceManager.GetString("CommandMSBuildVersion", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Disable using the machine cache as the first package source..
        /// </summary>
        internal static string CommandNoCache {
            get {
                return ResourceManager.GetString("CommandNoCache", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Disable the use of the HTTP cache and contact all configured package sources for live information..
        /// </summary>
        internal static string CommandNoHttpCache {
            get {
                return ResourceManager.GetString("CommandNoHttpCache", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Does not append &quot;api/v2/packages&quot; to the source URL..
        /// </summary>
        internal static string CommandNoServiceEndpointDescription {
            get {
                return ResourceManager.GetString("CommandNoServiceEndpointDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specifies types of files to save after package installation: nuspec, nupkg, nuspec;nupkg..
        /// </summary>
        internal static string CommandPackageSaveMode {
            get {
                return ResourceManager.GetString("CommandPackageSaveMode", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A list of packages sources to use for this command..
        /// </summary>
        internal static string CommandSourceDescription {
            get {
                return ResourceManager.GetString("CommandSourceDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Returns the config value as a path. This option is ignored when -Set is specified..
        /// </summary>
        internal static string ConfigCommandAsPathDesc {
            get {
                return ResourceManager.GetString("ConfigCommandAsPathDesc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Gets or sets NuGet config values..
        /// </summary>
        internal static string ConfigCommandDesc {
            get {
                return ResourceManager.GetString("ConfigCommandDesc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to nuget config -Set HTTP_PROXY=http://127.0.0.1 -Set HTTP_PROXY.USER=domain\user
        ///nuget config HTTP_PROXY.
        /// </summary>
        internal static string ConfigCommandExamples {
            get {
                return ResourceManager.GetString("ConfigCommandExamples", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to One on more key-value pairs to be set in config..
        /// </summary>
        internal static string ConfigCommandSetDesc {
            get {
                return ResourceManager.GetString("ConfigCommandSetDesc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;-Set name=value | name&gt;.
        /// </summary>
        internal static string ConfigCommandSummary {
            get {
                return ResourceManager.GetString("ConfigCommandSummary", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to NuGet&apos;s default configuration is obtained by loading %AppData%\NuGet\NuGet.config, then loading any nuget.config or .nuget\nuget.config starting from root of drive and ending in current directory..
        /// </summary>
        internal static string DefaultConfigDescription {
            get {
                return ResourceManager.GetString("DefaultConfigDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Deletes a package from the server..
        /// </summary>
        internal static string DeleteCommandDescription {
            get {
                return ResourceManager.GetString("DeleteCommandDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Do not prompt when deleting..
        /// </summary>
        internal static string DeleteCommandNoPromptDescription {
            get {
                return ResourceManager.GetString("DeleteCommandNoPromptDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Package source (URL, UNC/folder path or package source name) to delete from. Defaults to DefaultPushSource if specified in NuGet.Config..
        /// </summary>
        internal static string DeleteCommandSourceDescription {
            get {
                return ResourceManager.GetString("DeleteCommandSourceDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specify the Id and version of the package to delete from the server..
        /// </summary>
        internal static string DeleteCommandUsageDescription {
            get {
                return ResourceManager.GetString("DeleteCommandUsageDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to nuget delete MyPackage 1.0
        ///    
        ///nuget delete MyPackage 1.0 -NoPrompt.
        /// </summary>
        internal static string DeleteCommandUsageExamples {
            get {
                return ResourceManager.GetString("DeleteCommandUsageExamples", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;package Id&gt; &lt;package version&gt; [API Key] [options].
        /// </summary>
        internal static string DeleteCommandUsageSummary {
            get {
                return ResourceManager.GetString("DeleteCommandUsageSummary", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Display NuGet.exe&apos;s End User Liscence Agreement (EULA).
        /// </summary>
        internal static string EulaDescription {
            get {
                return ResourceManager.GetString("EulaDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to If provided, a package added to offline feed is also expanded..
        /// </summary>
        internal static string ExpandDescription {
            get {
                return ResourceManager.GetString("ExpandDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Forces all dependencies to be resolved even if the last restore was successful. This is equivalent to deleting project.assets.json. (Does not apply to packages.config).
        /// </summary>
        internal static string ForceRestoreCommand {
            get {
                return ResourceManager.GetString("ForceRestoreCommand", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to alias: {0}.
        /// </summary>
        internal static string HelpCommand_Alias {
            get {
                return ResourceManager.GetString("HelpCommand_Alias", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to  ({0}).
        /// </summary>
        internal static string HelpCommand_AltText {
            get {
                return ResourceManager.GetString("HelpCommand_AltText", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Available commands:.
        /// </summary>
        internal static string HelpCommand_AvailableCommands {
            get {
                return ResourceManager.GetString("HelpCommand_AvailableCommands", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to examples:.
        /// </summary>
        internal static string HelpCommand_Examples {
            get {
                return ResourceManager.GetString("HelpCommand_Examples", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to options:.
        /// </summary>
        internal static string HelpCommand_Options {
            get {
                return ResourceManager.GetString("HelpCommand_Options", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type &apos;{0} help &lt;command&gt;&apos; for help on a specific command..
        /// </summary>
        internal static string HelpCommand_Suggestion {
            get {
                return ResourceManager.GetString("HelpCommand_Suggestion", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to {0} Command.
        /// </summary>
        internal static string HelpCommand_Title {
            get {
                return ResourceManager.GetString("HelpCommand_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to usage: {0} &lt;command&gt; [args] [options].
        /// </summary>
        internal static string HelpCommand_Usage {
            get {
                return ResourceManager.GetString("HelpCommand_Usage", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to usage: {0} {1} {2}.
        /// </summary>
        internal static string HelpCommand_UsageDetail {
            get {
                return ResourceManager.GetString("HelpCommand_UsageDetail", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Print detailed help for all available commands..
        /// </summary>
        internal static string HelpCommandAll {
            get {
                return ResourceManager.GetString("HelpCommandAll", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Displays general help information and help information about other commands..
        /// </summary>
        internal static string HelpCommandDescription {
            get {
                return ResourceManager.GetString("HelpCommandDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Print detailed all help in markdown format..
        /// </summary>
        internal static string HelpCommandMarkdown {
            get {
                return ResourceManager.GetString("HelpCommandMarkdown", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Pass a command name to display help information for that command..
        /// </summary>
        internal static string HelpCommandUsageDescription {
            get {
                return ResourceManager.GetString("HelpCommandUsageDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to nuget help
        ///
        ///nuget help push
        ///
        ///nuget ?
        ///
        ///nuget push -?.
        /// </summary>
        internal static string HelpCommandUsageExamples {
            get {
                return ResourceManager.GetString("HelpCommandUsageExamples", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to [command].
        /// </summary>
        internal static string HelpCommandUsageSummary {
            get {
                return ResourceManager.GetString("HelpCommandUsageSummary", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Adds all the packages from the &lt;srcPackageSourcePath&gt; to the hierarchical &lt;destPackageSourcePath&gt;. http feeds are not supported. For more info, goto https://docs.nuget.org/consume/command-line-reference#init-command..
        /// </summary>
        internal static string InitCommandDescription {
            get {
                return ResourceManager.GetString("InitCommandDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specify the path to source package source to be copied from and the path to the destination package source to be copied to..
        /// </summary>
        internal static string InitCommandUsageDescription {
            get {
                return ResourceManager.GetString("InitCommandUsageDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to nuget init c:\foo c:\bar
        ///
        ///nuget init \\foo\packages \\bar\packages.
        /// </summary>
        internal static string InitCommandUsageExamples {
            get {
                return ResourceManager.GetString("InitCommandUsageExamples", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;srcPackageSourcePath&gt; &lt;destPackageSourcePath&gt; [options].
        /// </summary>
        internal static string InitCommandUsageSummary {
            get {
                return ResourceManager.GetString("InitCommandUsageSummary", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Overrides the default dependency resolution behavior..
        /// </summary>
        internal static string InstallCommandDependencyVersion {
            get {
                return ResourceManager.GetString("InstallCommandDependencyVersion", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Installs a package using the specified sources. If no sources are specified, all sources defined in the NuGet configuration file are used. If the configuration file specifies no sources, uses the default NuGet feed..
        /// </summary>
        internal static string InstallCommandDescription {
            get {
                return ResourceManager.GetString("InstallCommandDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to If set, the destination folder will contain only the package name, not the version number.
        /// </summary>
        internal static string InstallCommandExcludeVersionDescription {
            get {
                return ResourceManager.GetString("InstallCommandExcludeVersionDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Target framework used for selecting dependencies. Defaults to &apos;Any&apos; if not specified..
        /// </summary>
        internal static string InstallCommandFrameworkDescription {
            get {
                return ResourceManager.GetString("InstallCommandFrameworkDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specifies the directory in which packages will be installed. If none specified, uses the current directory..
        /// </summary>
        internal static string InstallCommandOutputDirDescription {
            get {
                return ResourceManager.GetString("InstallCommandOutputDirDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Allows prerelease packages to be installed. This flag is not required when restoring packages by installing from packages.config..
        /// </summary>
        internal static string InstallCommandPrerelease {
            get {
                return ResourceManager.GetString("InstallCommandPrerelease", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Checks if package restore consent is granted before installing a package..
        /// </summary>
        internal static string InstallCommandRequireConsent {
            get {
                return ResourceManager.GetString("InstallCommandRequireConsent", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Solution root for package restore..
        /// </summary>
        internal static string InstallCommandSolutionDirectory {
            get {
                return ResourceManager.GetString("InstallCommandSolutionDirectory", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specify the id and optionally the version of the package to install. If a path to a packages.config file is used instead of an id, all the packages it contains are installed..
        /// </summary>
        internal static string InstallCommandUsageDescription {
            get {
                return ResourceManager.GetString("InstallCommandUsageDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to nuget install elmah
        ///
        ///nuget install packages.config
        ///
        ///nuget install ninject -o c:\foo.
        /// </summary>
        internal static string InstallCommandUsageExamples {
            get {
                return ResourceManager.GetString("InstallCommandUsageExamples", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to packageId|pathToPackagesConfig [options].
        /// </summary>
        internal static string InstallCommandUsageSummary {
            get {
                return ResourceManager.GetString("InstallCommandUsageSummary", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The version of the package to install..
        /// </summary>
        internal static string InstallCommandVersionDescription {
            get {
                return ResourceManager.GetString("InstallCommandVersionDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to List all versions of a package. By default, only the latest package version is displayed..
        /// </summary>
        internal static string ListCommandAllVersionsDescription {
            get {
                return ResourceManager.GetString("ListCommandAllVersionsDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Displays a list of packages from a given source. If no sources are specified, all sources defined in %AppData%\NuGet\NuGet.config are used. If NuGet.config specifies no sources, uses the default NuGet feed..
        /// </summary>
        internal static string ListCommandDescription {
            get {
                return ResourceManager.GetString("ListCommandDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Allow unlisted packages to be shown..
        /// </summary>
        internal static string ListCommandIncludeDelisted {
            get {
                return ResourceManager.GetString("ListCommandIncludeDelisted", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Allow prerelease packages to be shown..
        /// </summary>
        internal static string ListCommandPrerelease {
            get {
                return ResourceManager.GetString("ListCommandPrerelease", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A list of packages sources to search..
        /// </summary>
        internal static string ListCommandSourceDescription {
            get {
                return ResourceManager.GetString("ListCommandSourceDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specify optional search terms..
        /// </summary>
        internal static string ListCommandUsageDescription {
            get {
                return ResourceManager.GetString("ListCommandUsageDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to nuget list
        ///
        ///nuget list -verbose -allversions.
        /// </summary>
        internal static string ListCommandUsageExamples {
            get {
                return ResourceManager.GetString("ListCommandUsageExamples", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to [search terms] [options].
        /// </summary>
        internal static string ListCommandUsageSummary {
            get {
                return ResourceManager.GetString("ListCommandUsageSummary", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Displays a detailed list of information for each package..
        /// </summary>
        internal static string ListCommandVerboseListDescription {
            get {
                return ResourceManager.GetString("ListCommandVerboseListDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Clear the selected local resources or cache location(s)..
        /// </summary>
        internal static string LocalsCommandClearDescription {
            get {
                return ResourceManager.GetString("LocalsCommandClearDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Clears or lists local NuGet resources such as http requests cache, temp cache or machine-wide global packages folder..
        /// </summary>
        internal static string LocalsCommandDescription {
            get {
                return ResourceManager.GetString("LocalsCommandDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to nuget locals all -clear
        ///
        ///nuget locals http-cache -clear
        ///
        ///nuget locals temp -list
        ///
        ///nuget locals global-packages -list.
        /// </summary>
        internal static string LocalsCommandExamples {
            get {
                return ResourceManager.GetString("LocalsCommandExamples", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to List the selected local resources or cache location(s)..
        /// </summary>
        internal static string LocalsCommandListDescription {
            get {
                return ResourceManager.GetString("LocalsCommandListDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;all | http-cache | global-packages | temp | plugins-cache&gt; [-clear | -list].
        /// </summary>
        internal static string LocalsCommandSummary {
            get {
                return ResourceManager.GetString("LocalsCommandSummary", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to NoCache is deprecated and has been renamed to NoHttpCache. Please use NoHttpCache instead..
        /// </summary>
        internal static string Log_RestoreNoCacheInformation {
            get {
                return ResourceManager.GetString("Log_RestoreNoCacheInformation", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The NuGet configuration file. If specified, only the settings from this file will be used. If not specified, the hierarchy of configuration files from the current directory will be used. To learn more about NuGet configuration go to https://docs.microsoft.com/en-us/nuget/consume-packages/configuring-nuget-behavior..
        /// </summary>
        internal static string Option_ConfigFile {
            get {
                return ResourceManager.GetString("Option_ConfigFile", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Forces the application to run using an invariant, English-based culture..
        /// </summary>
        internal static string Option_ForceEnglishOutput {
            get {
                return ResourceManager.GetString("Option_ForceEnglishOutput", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Show command help and usage information..
        /// </summary>
        internal static string Option_Help {
            get {
                return ResourceManager.GetString("Option_Help", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Do not prompt for user input or confirmations..
        /// </summary>
        internal static string Option_NonInteractive {
            get {
                return ResourceManager.GetString("Option_NonInteractive", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Display this amount of details in the output: normal, quiet, detailed..
        /// </summary>
        internal static string Option_Verbosity {
            get {
                return ResourceManager.GetString("Option_Verbosity", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The base path of the files defined in the nuspec file..
        /// </summary>
        internal static string PackageCommandBasePathDescription {
            get {
                return ResourceManager.GetString("PackageCommandBasePathDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Determines if the project should be built before building the package..
        /// </summary>
        internal static string PackageCommandBuildDescription {
            get {
                return ResourceManager.GetString("PackageCommandBuildDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specify the configuration file for the pack command..
        /// </summary>
        internal static string PackageCommandConfigFile {
            get {
                return ResourceManager.GetString("PackageCommandConfigFile", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Creates a NuGet package based on the specified nuspec or project file..
        /// </summary>
        internal static string PackageCommandDescription {
            get {
                return ResourceManager.GetString("PackageCommandDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specify if the command should create a deterministic package. Multiple invocations of the pack command will create the exact same package..
        /// </summary>
        internal static string PackageCommandDeterministic {
            get {
                return ResourceManager.GetString("PackageCommandDeterministic", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Specify the timestamps this command should use when creating a deterministic package. Multiple invocations of the pack command will create the exact same package..
        /// </summary>
        internal static string PackageCommandDeterministicTimestamp {
            get {
                return ResourceManager.GetString("PackageCommandDeterministicTimestamp", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specifies one or more wildcard patterns to exclude when creating a package..
        /// </summary>
        internal static string PackageCommandExcludeDescription {
            get {
                return ResourceManager.GetString("PackageCommandExcludeDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Prevent inclusion of empty directories when building the package..
        /// </summary>
        internal static string PackageCommandExcludeEmptyDirectories {
            get {
                return ResourceManager.GetString("PackageCommandExcludeEmptyDirectories", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Include referenced projects either as dependencies or as part of the package..
        /// </summary>
        internal static string PackageCommandIncludeReferencedProjects {
            get {
                return ResourceManager.GetString("PackageCommandIncludeReferencedProjects", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specify if the command should prepare the package output directory to support share as feed..
        /// </summary>
        internal static string PackageCommandInstallPackageToOutputPath {
            get {
                return ResourceManager.GetString("PackageCommandInstallPackageToOutputPath", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Set the minClientVersion attribute for the created package..
        /// </summary>
        internal static string PackageCommandMinClientVersion {
            get {
                return ResourceManager.GetString("PackageCommandMinClientVersion", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Prevent default exclusion of NuGet package files and files and folders starting with a dot e.g. .svn..
        /// </summary>
        internal static string PackageCommandNoDefaultExcludes {
            get {
                return ResourceManager.GetString("PackageCommandNoDefaultExcludes", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specify if the command should not run package analysis after building the package..
        /// </summary>
        internal static string PackageCommandNoRunAnalysis {
            get {
                return ResourceManager.GetString("PackageCommandNoRunAnalysis", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specifies the directory for the created NuGet package file. If not specified, uses the current directory..
        /// </summary>
        internal static string PackageCommandOutputDirDescription {
            get {
                return ResourceManager.GetString("PackageCommandOutputDirDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specify if the command should prepare the package output name without the version..
        /// </summary>
        internal static string PackageCommandOutputFileNamesWithoutVersion {
            get {
                return ResourceManager.GetString("PackageCommandOutputFileNamesWithoutVersion", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specifies the packages folder..
        /// </summary>
        internal static string PackageCommandPackagesDirectory {
            get {
                return ResourceManager.GetString("PackageCommandPackagesDirectory", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Provides the ability to specify a semicolon &quot;;&quot; delimited list of properties when creating a package..
        /// </summary>
        internal static string PackageCommandPropertiesDescription {
            get {
                return ResourceManager.GetString("PackageCommandPropertiesDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specifies the solution directory..
        /// </summary>
        internal static string PackageCommandSolutionDirectory {
            get {
                return ResourceManager.GetString("PackageCommandSolutionDirectory", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Appends a pre-release suffix to the internally generated version number..
        /// </summary>
        internal static string PackageCommandSuffixDescription {
            get {
                return ResourceManager.GetString("PackageCommandSuffixDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to When creating a symbols package, allows to choose between the &apos;snupkg&apos; and &apos;symbols.nupkg&apos; format..
        /// </summary>
        internal static string PackageCommandSymbolPackageFormat {
            get {
                return ResourceManager.GetString("PackageCommandSymbolPackageFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Determines if a package containing sources and symbols should be created. When specified with a nuspec, creates a regular NuGet package file and the corresponding symbols package..
        /// </summary>
        internal static string PackageCommandSymbolsDescription {
            get {
                return ResourceManager.GetString("PackageCommandSymbolsDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Determines if the output files of the project should be in the tool folder. .
        /// </summary>
        internal static string PackageCommandToolDescription {
            get {
                return ResourceManager.GetString("PackageCommandToolDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specify the location of the nuspec or project file to create a package..
        /// </summary>
        internal static string PackageCommandUsageDescription {
            get {
                return ResourceManager.GetString("PackageCommandUsageDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;nuspec | project&gt; [options].
        /// </summary>
        internal static string PackageCommandUsageSummary {
            get {
                return ResourceManager.GetString("PackageCommandUsageSummary", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Shows verbose output for package building..
        /// </summary>
        internal static string PackageCommandVerboseDescription {
            get {
                return ResourceManager.GetString("PackageCommandVerboseDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Overrides the version number from the nuspec file..
        /// </summary>
        internal static string PackageCommandVersionDescription {
            get {
                return ResourceManager.GetString("PackageCommandVersionDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to nuget pack
        ///
        ///nuget pack foo.nuspec
        ///
        ///nuget pack foo.csproj
        ///
        ///nuget pack foo.csproj -Build -Symbols -Properties Configuration=Release
        ///
        ///nuget pack foo.nuspec -Version 2.1.0.
        /// </summary>
        internal static string PackCommandUsageExamples {
            get {
                return ResourceManager.GetString("PackCommandUsageExamples", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Allows pushing to HTTP sources (insecure)..
        /// </summary>
        internal static string PushCommandAllowInsecureConnectionsDescription {
            get {
                return ResourceManager.GetString("PushCommandAllowInsecureConnectionsDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Pushes a package to the server and publishes it..
        /// </summary>
        internal static string PushCommandDescription {
            get {
                return ResourceManager.GetString("PushCommandDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Disable buffering when pushing to an HTTP(S) server to decrease memory usage. Note that when this option is enabled, integrated windows authentication might not work..
        /// </summary>
        internal static string PushCommandDisableBufferingDescription {
            get {
                return ResourceManager.GetString("PushCommandDisableBufferingDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to If a symbols package exists, it will not be pushed to a symbol server..
        /// </summary>
        internal static string PushCommandNoSymbolsDescription {
            get {
                return ResourceManager.GetString("PushCommandNoSymbolsDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to If a package and version already exists, skip it and continue with the next package in the push, if any..
        /// </summary>
        internal static string PushCommandSkipDuplicateDescription {
            get {
                return ResourceManager.GetString("PushCommandSkipDuplicateDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Package source (URL, UNC/folder path or package source name) to push to. Defaults to DefaultPushSource if specified in NuGet.Config..
        /// </summary>
        internal static string PushCommandSourceDescription {
            get {
                return ResourceManager.GetString("PushCommandSourceDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Symbol server URL to push to..
        /// </summary>
        internal static string PushCommandSymbolSourceDescription {
            get {
                return ResourceManager.GetString("PushCommandSymbolSourceDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Timeout for pushing to a server in seconds. Defaults to 300 seconds (5 minutes)..
        /// </summary>
        internal static string PushCommandTimeoutDescription {
            get {
                return ResourceManager.GetString("PushCommandTimeoutDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specify the path to the package and your API key to push the package to the server..
        /// </summary>
        internal static string PushCommandUsageDescription {
            get {
                return ResourceManager.GetString("PushCommandUsageDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to nuget push foo.nupkg 4003d786-cc37-4004-bfdf-c4f3e8ef9b3a
        ///
        ///nuget push foo.nupkg 4003d786-cc37-4004-bfdf-c4f3e8ef9b3a -src http://customsource/
        ///
        ///nuget push foo.nupkg
        ///
        ///nuget push foo.nupkg.symbols
        ///
        ///nuget push foo.nupkg -Timeout 360.
        /// </summary>
        internal static string PushCommandUsageExamples {
            get {
                return ResourceManager.GetString("PushCommandUsageExamples", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;package path&gt; [API key] [options].
        /// </summary>
        internal static string PushCommandUsageSummary {
            get {
                return ResourceManager.GetString("PushCommandUsageSummary", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Restores NuGet packages..
        /// </summary>
        internal static string RestoreCommandDescription {
            get {
                return ResourceManager.GetString("RestoreCommandDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Forces restore to reevaluate all dependencies even if a lock file already exists..
        /// </summary>
        internal static string RestoreCommandForceEvaluate {
            get {
                return ResourceManager.GetString("RestoreCommandForceEvaluate", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Don&apos;t allow updating project lock file..
        /// </summary>
        internal static string RestoreCommandLockedMode {
            get {
                return ResourceManager.GetString("RestoreCommandLockedMode", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Output location where project lock file is written. By default, this is &apos;PROJECT_ROOT\packages.lock.json&apos;..
        /// </summary>
        internal static string RestoreCommandLockFilePath {
            get {
                return ResourceManager.GetString("RestoreCommandLockFilePath", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Timeout in seconds for resolving project to project references..
        /// </summary>
        internal static string RestoreCommandP2PTimeOut {
            get {
                return ResourceManager.GetString("RestoreCommandP2PTimeOut", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specifies the packages folder..
        /// </summary>
        internal static string RestoreCommandPackagesDirectory {
            get {
                return ResourceManager.GetString("RestoreCommandPackagesDirectory", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Restore all referenced projects for UWP and NETCore projects. This does not include packages.config projects..
        /// </summary>
        internal static string RestoreCommandRecursive {
            get {
                return ResourceManager.GetString("RestoreCommandRecursive", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Checks if package restore consent is granted before installing a package..
        /// </summary>
        internal static string RestoreCommandRequireConsent {
            get {
                return ResourceManager.GetString("RestoreCommandRequireConsent", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specifies the solution directory. Not valid when restoring packages for a solution..
        /// </summary>
        internal static string RestoreCommandSolutionDirectory {
            get {
                return ResourceManager.GetString("RestoreCommandSolutionDirectory", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to If a solution is specified, this command restores NuGet packages that are installed in the solution and in projects contained in the solution. Otherwise, the command restores packages listed in the specified packages.config file, Microsoft Build project, or project.json file..
        /// </summary>
        internal static string RestoreCommandUsageDescription {
            get {
                return ResourceManager.GetString("RestoreCommandUsageDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to nuget restore MySolution.sln.
        /// </summary>
        internal static string RestoreCommandUsageExamples {
            get {
                return ResourceManager.GetString("RestoreCommandUsageExamples", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to [&lt;solution&gt; | &lt;packages.config file&gt; | &lt;Microsoft Build project&gt;] [options].
        /// </summary>
        internal static string RestoreCommandUsageSummary {
            get {
                return ResourceManager.GetString("RestoreCommandUsageSummary", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Enables project lock file to be generated and used with restore..
        /// </summary>
        internal static string RestoreCommandUseLockFile {
            get {
                return ResourceManager.GetString("RestoreCommandUseLockFile", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Searches a given source using the query string provided. If no sources are specified, all sources defined in %AppData%\NuGet\NuGet.config are used..
        /// </summary>
        internal static string SearchCommandDescription {
            get {
                return ResourceManager.GetString("SearchCommandDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Include prerelease packages..
        /// </summary>
        internal static string SearchCommandPreRelease {
            get {
                return ResourceManager.GetString("SearchCommandPreRelease", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The package source to search. You can pass multiple -Source options to search multiple package sources..
        /// </summary>
        internal static string SearchCommandSourceDescription {
            get {
                return ResourceManager.GetString("SearchCommandSourceDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The number of results to return. The default value is 20..
        /// </summary>
        internal static string SearchCommandTake {
            get {
                return ResourceManager.GetString("SearchCommandTake", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specify search terms..
        /// </summary>
        internal static string SearchCommandUsageDescription {
            get {
                return ResourceManager.GetString("SearchCommandUsageDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to nuget search foo
        ///
        ///nuget search foo -Verbosity detailed
        ///
        ///nuget search foo -PreRelease -Take 5.
        /// </summary>
        internal static string SearchCommandUsageExamples {
            get {
                return ResourceManager.GetString("SearchCommandUsageExamples", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to [search terms] [options].
        /// </summary>
        internal static string SearchCommandUsageSummary {
            get {
                return ResourceManager.GetString("SearchCommandUsageSummary", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Saves an API key for a given server URL. When no URL is provided API key is saved for the NuGet gallery..
        /// </summary>
        internal static string SetApiKeyCommandDescription {
            get {
                return ResourceManager.GetString("SetApiKeyCommandDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Server URL where the API key is valid..
        /// </summary>
        internal static string SetApiKeyCommandSourceDescription {
            get {
                return ResourceManager.GetString("SetApiKeyCommandSourceDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specify the API key to save and an optional URL to the server that provided the API key..
        /// </summary>
        internal static string SetApiKeyCommandUsageDescription {
            get {
                return ResourceManager.GetString("SetApiKeyCommandUsageDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to nuget setapikey 4003d786-cc37-4004-bfdf-c4f3e8ef9b3a
        ///
        ///nuget setapikey 4003d786-cc37-4004-bfdf-c4f3e8ef9b3a -Source http://example.com/nugetfeed.
        /// </summary>
        internal static string SetApiKeyCommandUsageExamples {
            get {
                return ResourceManager.GetString("SetApiKeyCommandUsageExamples", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;API key&gt; [options].
        /// </summary>
        internal static string SetApiKeyCommandUsageSummary {
            get {
                return ResourceManager.GetString("SetApiKeyCommandUsageSummary", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to SHA-256, SHA-384 or SHA-512 fingerprint of the certificate used to search a local certificate store for the certificate.
        ///The certificate store can be specified by -CertificateStoreName and -CertificateStoreLocation options..
        /// </summary>
        internal static string SignCommandCertificateFingerprintDescription {
            get {
                return ResourceManager.GetString("SignCommandCertificateFingerprintDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Password for the certificate, if needed.
        ///This option can be used to specify the password for the certificate. If no password is provided, the command will prompt for a password at run time, unless the -NonInteractive option is passed..
        /// </summary>
        internal static string SignCommandCertificatePasswordDescription {
            get {
                return ResourceManager.GetString("SignCommandCertificatePasswordDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to File path to the certificate to be used while signing the package..
        /// </summary>
        internal static string SignCommandCertificatePathDescription {
            get {
                return ResourceManager.GetString("SignCommandCertificatePathDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name of the X.509 certificate store use to search for the certificate. Defaults to &quot;CurrentUser&quot;, the X.509 certificate store used by the current user.
        ///This option should be used when specifying the certificate via -CertificateSubjectName or -CertificateFingerprint options..
        /// </summary>
        internal static string SignCommandCertificateStoreLocationDescription {
            get {
                return ResourceManager.GetString("SignCommandCertificateStoreLocationDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name of the X.509 certificate store to use to search for the certificate. Defaults to &quot;My&quot;, the X.509 certificate store for personal certificates.
        ///This option should be used when specifying the certificate via -CertificateSubjectName or -CertificateFingerprint options..
        /// </summary>
        internal static string SignCommandCertificateStoreNameDescription {
            get {
                return ResourceManager.GetString("SignCommandCertificateStoreNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Subject name of the certificate used to search a local certificate store for the certificate. 
        ///The search is a case-insensitive string comparison using the supplied value, which will find all certificates with the subject name containing that string, regardless of other subject values.
        ///The certificate store can be specified by -CertificateStoreName and -CertificateStoreLocation options..
        /// </summary>
        internal static string SignCommandCertificateSubjectNameDescription {
            get {
                return ResourceManager.GetString("SignCommandCertificateSubjectNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Signs a NuGet package with the specified certificate..
        /// </summary>
        internal static string SignCommandDescription {
            get {
                return ResourceManager.GetString("SignCommandDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to nuget sign MyPackage.nupkg -CertificatePath C:\certificate.pfx
        ///nuget sign MyPackage.nupkg -CertificatePath \\path\to\certificate.pfx
        ///nuget sign MyPackage.nupkg -CertificateFingerprint certificate_fingerprint -OutputDirectory .\signed\.
        /// </summary>
        internal static string SignCommandExamples {
            get {
                return ResourceManager.GetString("SignCommandExamples", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Hash algorithm to be used to sign the package. Defaults to SHA256..
        /// </summary>
        internal static string SignCommandHashAlgorithmDescription {
            get {
                return ResourceManager.GetString("SignCommandHashAlgorithmDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to {0}: Invalid value for &apos;CertificateFingerprint&apos; option. The value must be a SHA-256, SHA-384, or SHA-512 certificate fingerprint (in hexadecimal)..
        /// </summary>
        internal static string SignCommandInvalidCertificateFingerprint {
            get {
                return ResourceManager.GetString("SignCommandInvalidCertificateFingerprint", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No value provided for &apos;{0}&apos;, which is needed when using the &apos;{1}&apos; option. For a list of accepted values, please visit https://docs.nuget.org/docs/reference/command-line-reference.
        /// </summary>
        internal static string SignCommandMissingArgumentException {
            get {
                return ResourceManager.GetString("SignCommandMissingArgumentException", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Multiple options were used to specify a certificate. For a list of accepted ways to provide a certificate, please visit https://docs.nuget.org/docs/reference/command-line-reference.
        /// </summary>
        internal static string SignCommandMultipleCertificateException {
            get {
                return ResourceManager.GetString("SignCommandMultipleCertificateException", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No value provided for &apos;{0}&apos;. For a list of accepted values, please visit https://docs.nuget.org/docs/reference/command-line-reference.
        /// </summary>
        internal static string SignCommandNoArgumentException {
            get {
                return ResourceManager.GetString("SignCommandNoArgumentException", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No certificate was provided. For a list of accepted ways to provide a certificate, please visit https://docs.nuget.org/docs/reference/command-line-reference.
        /// </summary>
        internal static string SignCommandNoCertificateException {
            get {
                return ResourceManager.GetString("SignCommandNoCertificateException", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No package was provided. For a list of accepted ways to provide a package, please visit https://docs.nuget.org/docs/reference/command-line-reference.
        /// </summary>
        internal static string SignCommandNoPackageException {
            get {
                return ResourceManager.GetString("SignCommandNoPackageException", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &apos;-Timestamper&apos; option was not provided. The signed package will not be timestamped. To learn more about this option, please visit https://docs.nuget.org/docs/reference/command-line-reference.
        /// </summary>
        internal static string SignCommandNoTimestamperWarning {
            get {
                return ResourceManager.GetString("SignCommandNoTimestamperWarning", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Directory where the signed package should be saved. By default the original package is overwritten by the signed package..
        /// </summary>
        internal static string SignCommandOutputDirectoryDescription {
            get {
                return ResourceManager.GetString("SignCommandOutputDirectoryDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Switch to indicate if the current signature should be overwritten. By default the command will fail if the package already has a signature..
        /// </summary>
        internal static string SignCommandOverwriteDescription {
            get {
                return ResourceManager.GetString("SignCommandOverwriteDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Allow signing with certificates whose root certificate is not in a trusted root store...
        /// </summary>
        internal static string SignCommandAllowUntrustedRootDescription {
            get {
                return ResourceManager.GetString("SignCommandAllowUntrustedRootDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Signs a NuGet package..
        /// </summary>
        internal static string SignCommandSummary {
            get {
                return ResourceManager.GetString("SignCommandSummary", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to URL to an RFC 3161 timestamping server..
        /// </summary>
        internal static string SignCommandTimestamperDescription {
            get {
                return ResourceManager.GetString("SignCommandTimestamperDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Hash algorithm to be used by the RFC 3161 timestamp server. Defaults to SHA256..
        /// </summary>
        internal static string SignCommandTimestampHashAlgorithmDescription {
            get {
                return ResourceManager.GetString("SignCommandTimestampHashAlgorithmDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Signs a NuGet package..
        /// </summary>
        internal static string SignCommandUsageDescription {
            get {
                return ResourceManager.GetString("SignCommandUsageDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to nuget sign MyPackage.nupkg -Timestamper https://foo.bar
        ///
        ///nuget sign .\..\MyPackage.nupkg -Timestamper https://foo.bar -OutputDirectory .\..\Signed
        ///.
        /// </summary>
        internal static string SignCommandUsageExamples {
            get {
                return ResourceManager.GetString("SignCommandUsageExamples", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;package_path&gt; -Timestamper &lt;timestamp_server_url&gt; [-CertificatePath &lt;certificate_path&gt; | [ -CertificateStoreName &lt;certificate_store_name&gt; -CertificateStoreLocation &lt;certificate_store_location&gt; [-CertificateSubjectName &lt;certificate_subject_name&gt; | -CertificateFingerprint &lt;certificate_fingerprint&gt;]]] [options].
        /// </summary>
        internal static string SignCommandUsageSummary {
            get {
                return ResourceManager.GetString("SignCommandUsageSummary", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Allows HTTP connections for adding or updating packages. Note: This method is not secure. For secure options, see https://aka.ms/nuget-https-everywhere for more information..
        /// </summary>
        internal static string SourcesCommandAllowInsecureConnectionsDescription {
            get {
                return ResourceManager.GetString("SourcesCommandAllowInsecureConnectionsDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Provides the ability to manage list of sources located in NuGet.config files..
        /// </summary>
        internal static string SourcesCommandDescription {
            get {
                return ResourceManager.GetString("SourcesCommandDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Applies to the list action. Accepts two values: Detailed (the default) and Short..
        /// </summary>
        internal static string SourcesCommandFormatDescription {
            get {
                return ResourceManager.GetString("SourcesCommandFormatDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name of the source..
        /// </summary>
        internal static string SourcesCommandNameDescription {
            get {
                return ResourceManager.GetString("SourcesCommandNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Password to be used when connecting to an authenticated source..
        /// </summary>
        internal static string SourcesCommandPasswordDescription {
            get {
                return ResourceManager.GetString("SourcesCommandPasswordDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The NuGet server protocol version to be used. Currently supported versions are 2 and 3. See https://learn.microsoft.com/nuget/api/overview for information about the version 3 protocol. Defaults to 2 if not specified..
        /// </summary>
        internal static string SourcesCommandProtocolVersionDescription {
            get {
                return ResourceManager.GetString("SourcesCommandProtocolVersionDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Path to the package(s) source..
        /// </summary>
        internal static string SourcesCommandSourceDescription {
            get {
                return ResourceManager.GetString("SourcesCommandSourceDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Enables storing portable package source credentials by disabling password encryption..
        /// </summary>
        internal static string SourcesCommandStorePasswordInClearTextDescription {
            get {
                return ResourceManager.GetString("SourcesCommandStorePasswordInClearTextDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Make a source a trusted repository for repository signature verification..
        /// </summary>
        internal static string SourcesCommandTrustDescription {
            get {
                return ResourceManager.GetString("SourcesCommandTrustDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;List|Add|Remove|Enable|Disable|Update&gt; -Name [name] -Source [source].
        /// </summary>
        internal static string SourcesCommandUsageSummary {
            get {
                return ResourceManager.GetString("SourcesCommandUsageSummary", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Username to be used when connecting to an authenticated source..
        /// </summary>
        internal static string SourcesCommandUserNameDescription {
            get {
                return ResourceManager.GetString("SourcesCommandUserNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Comma-separated list of valid authentication types for this source. By default, all authentication types are valid. Example: basic,negotiate.
        /// </summary>
        internal static string SourcesCommandValidAuthenticationTypesDescription {
            get {
                return ResourceManager.GetString("SourcesCommandValidAuthenticationTypesDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Assembly to use for metadata..
        /// </summary>
        internal static string SpecCommandAssemblyPathDescription {
            get {
                return ResourceManager.GetString("SpecCommandAssemblyPathDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Generates a nuspec for a new package. If this command is run in the same folder as a project file (.csproj, .vbproj, .fsproj), it will create a tokenized nuspec file..
        /// </summary>
        internal static string SpecCommandDescription {
            get {
                return ResourceManager.GetString("SpecCommandDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Overwrite nuspec file if it exists..
        /// </summary>
        internal static string SpecCommandForceDescription {
            get {
                return ResourceManager.GetString("SpecCommandForceDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to nuget spec
        ///
        ///nuget spec MyPackage
        ///
        ///nuget spec -a MyAssembly.dll.
        /// </summary>
        internal static string SpecCommandUsageExamples {
            get {
                return ResourceManager.GetString("SpecCommandUsageExamples", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to [package id].
        /// </summary>
        internal static string SpecCommandUsageSummary {
            get {
                return ResourceManager.GetString("SpecCommandUsageSummary", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The API key for the symbol server. If not set, the NUGET_SYMBOL_API_KEY environment variable is read..
        /// </summary>
        internal static string SymbolApiKey {
            get {
                return ResourceManager.GetString("SymbolApiKey", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Set allowUntrustedRoot to true for the trusted signer&apos;s certificate to be added..
        /// </summary>
        internal static string TrustedSignersCommandAllowUntrustedRootDescription {
            get {
                return ResourceManager.GetString("TrustedSignersCommandAllowUntrustedRootDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Add the author signature of the package as a trusted author..
        /// </summary>
        internal static string TrustedSignersCommandAuthorDescription {
            get {
                return ResourceManager.GetString("TrustedSignersCommandAuthorDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Fingerprint of the certificate to trust..
        /// </summary>
        internal static string TrustedSignersCommandCertificateFingerprintDescription {
            get {
                return ResourceManager.GetString("TrustedSignersCommandCertificateFingerprintDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Provides the ability to manage the list of trusted signers..
        /// </summary>
        internal static string TrustedSignersCommandDescription {
            get {
                return ResourceManager.GetString("TrustedSignersCommandDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Hash algorithm used to calculate the certificate fingerprint. Defaults to SHA256..
        /// </summary>
        internal static string TrustedSignersCommandFingerprintAlgorithmDescription {
            get {
                return ResourceManager.GetString("TrustedSignersCommandFingerprintAlgorithmDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name of the trusted signer..
        /// </summary>
        internal static string TrustedSignersCommandNameDescription {
            get {
                return ResourceManager.GetString("TrustedSignersCommandNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to List of owners allowed for a package signed with the trusted repository..
        /// </summary>
        internal static string TrustedSignersCommandOwnersDescription {
            get {
                return ResourceManager.GetString("TrustedSignersCommandOwnersDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Add the repository signature or countersignature of the package as a trusted repository..
        /// </summary>
        internal static string TrustedSignersCommandRepositoryDescription {
            get {
                return ResourceManager.GetString("TrustedSignersCommandRepositoryDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Service index for a repository to be trusted..
        /// </summary>
        internal static string TrustedSignersCommandServiceIndexDescription {
            get {
                return ResourceManager.GetString("TrustedSignersCommandServiceIndexDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to nuget trusted-signers
        ///
        ///nuget trusted-signers Add -Name existingSource
        ///
        ///nuget trusted-signers Add -Name trustedRepo -ServiceIndex https://trustedRepo.test/v3ServiceIndex
        ///
        ///nuget trusted-signers Add -Name author1 -CertificateFingerprint CE40881FF5F0AD3E58965DA20A9F571EF1651A56933748E1BF1C99E537C4E039 -FingerprintAlgorithm SHA256
        ///
        ///nuget trusted-signers Add -Repository .\..\MyRepositorySignedPackage.nupkg -Name TrustedRepo
        ///
        ///nuget trusted-signers Remove -Name TrustedRepo.
        /// </summary>
        internal static string TrustedSignersCommandUsageExamples {
            get {
                return ResourceManager.GetString("TrustedSignersCommandUsageExamples", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;List|Add|Remove|Sync&gt; [options].
        /// </summary>
        internal static string TrustedSignersCommandUsageSummary {
            get {
                return ResourceManager.GetString("TrustedSignersCommandUsageSummary", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Overrides the default dependency resolution behavior..
        /// </summary>
        internal static string UpdateCommandDependencyVersion {
            get {
                return ResourceManager.GetString("UpdateCommandDependencyVersion", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Update packages to latest available versions. This command also updates NuGet.exe itself..
        /// </summary>
        internal static string UpdateCommandDescription {
            get {
                return ResourceManager.GetString("UpdateCommandDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Set default action when a file from a package already exists in the target project. Set to Overwrite to always overwrite files. Set to Ignore to skip files. If not specified, it will prompt for each conflicting file..
        /// </summary>
        internal static string UpdateCommandFileConflictAction {
            get {
                return ResourceManager.GetString("UpdateCommandFileConflictAction", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Package ids to update..
        /// </summary>
        internal static string UpdateCommandIdDescription {
            get {
                return ResourceManager.GetString("UpdateCommandIdDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Allows updating to prerelease versions. This flag is not required when updating prerelease packages that are already installed..
        /// </summary>
        internal static string UpdateCommandPrerelease {
            get {
                return ResourceManager.GetString("UpdateCommandPrerelease", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Path to the local packages folder (location where packages are installed)..
        /// </summary>
        internal static string UpdateCommandRepositoryPathDescription {
            get {
                return ResourceManager.GetString("UpdateCommandRepositoryPathDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Looks for updates with the highest version available within the same major and minor version as the installed package..
        /// </summary>
        internal static string UpdateCommandSafeDescription {
            get {
                return ResourceManager.GetString("UpdateCommandSafeDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Update the running NuGet.exe to the newest version available from the server..
        /// </summary>
        internal static string UpdateCommandSelfDescription {
            get {
                return ResourceManager.GetString("UpdateCommandSelfDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A list of package sources to search for updates..
        /// </summary>
        internal static string UpdateCommandSourceDescription {
            get {
                return ResourceManager.GetString("UpdateCommandSourceDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to nuget update
        ///    
        ///nuget update -Safe
        ///
        ///nuget update -Self.
        /// </summary>
        internal static string UpdateCommandUsageExamples {
            get {
                return ResourceManager.GetString("UpdateCommandUsageExamples", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Show verbose output while updating..
        /// </summary>
        internal static string UpdateCommandVerboseDescription {
            get {
                return ResourceManager.GetString("UpdateCommandVerboseDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Updates the package in -Id to the version indicated.  Requires -Id to contain exactly one package id..
        /// </summary>
        internal static string UpdateCommandVersionDescription {
            get {
                return ResourceManager.GetString("UpdateCommandVersionDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specifies that all verifications possible should be performed to the package(s)..
        /// </summary>
        internal static string VerifyCommandAllDescription {
            get {
                return ResourceManager.GetString("VerifyCommandAllDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Verify that the signer certificate matches with one of the specified SHA256 fingerprints. A certificate SHA256 fingerprint is a SHA256 hash of the certificate used to identify the certificate. Multiple inputs should be semicolon separated..
        /// </summary>
        internal static string VerifyCommandCertificateFingerprintDescription {
            get {
                return ResourceManager.GetString("VerifyCommandCertificateFingerprintDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Verifies a signed NuGet package..
        /// </summary>
        internal static string VerifyCommandDescription {
            get {
                return ResourceManager.GetString("VerifyCommandDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specifies that package signature verification should be performed..
        /// </summary>
        internal static string VerifyCommandSignaturesDescription {
            get {
                return ResourceManager.GetString("VerifyCommandSignaturesDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to nuget verify -Signatures .\..\MyPackage.nupkg -CertificateFingerprint &quot;CE40881FF5F0AD3E58965DA20A9F571EF1651A56933748E1BF1C99E537C4E039;5F874AAF47BCB268A19357364E7FBB09D6BF9E8A93E1229909AC5CAC865802E2&quot; -Verbosity detailed
        ///
        ///nuget verify -Signatures C:\packages\MyPackage.nupkg -CertificateFingerprint CE40881FF5F0AD3E58965DA20A9F571EF1651A56933748E1BF1C99E537C4E039
        ///
        ///nuget verify -Signatures MyPackage.nupkg -Verbosity quiet
        ///
        ///nuget verify -Signatures .\*.nupkg.
        /// </summary>
        internal static string VerifyCommandUsageExamples {
            get {
                return ResourceManager.GetString("VerifyCommandUsageExamples", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;verification_type&gt; &lt;package_path&gt;  [options].
        /// </summary>
        internal static string VerifyCommandUsageSummary {
            get {
                return ResourceManager.GetString("VerifyCommandUsageSummary", resourceCulture);
            }
        }
    }
}