Strings.Designer.cs

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

namespace NuGet.CommandLine.XPlat {
    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", "17.0.0.0")]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    internal class Strings {
        
        private static global::System.Resources.ResourceManager resourceMan;
        
        private static global::System.Globalization.CultureInfo resourceCulture;
        
        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal Strings() {
        }
        
        /// <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.XPlat.Strings", typeof(Strings).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 Add a NuGet source..
        /// </summary>
        internal static string Add_Description {
            get {
                return ResourceManager.GetString("Add_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Adds a client certificate configuration that matches the given package source name..
        /// </summary>
        internal static string AddClientCertCommandDescription {
            get {
                return ResourceManager.GetString("AddClientCertCommandDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to all.
        /// </summary>
        internal static string AddPkg_All {
            get {
                return ResourceManager.GetString("AddPkg_All", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Adds a package reference to a project..
        /// </summary>
        internal static string AddPkg_Description {
            get {
                return ResourceManager.GetString("AddPkg_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Path to the dependency graph file to be used to restore preview and compatibility check..
        /// </summary>
        internal static string AddPkg_DgFileDescription {
            get {
                return ResourceManager.GetString("AddPkg_DgFileDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Frameworks for which the package reference should be added..
        /// </summary>
        internal static string AddPkg_FrameworksDescription {
            get {
                return ResourceManager.GetString("AddPkg_FrameworksDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Allow the command to block and require manual action for operations like authentication..
        /// </summary>
        internal static string AddPkg_InteractiveDescription {
            get {
                return ResourceManager.GetString("AddPkg_InteractiveDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Do not perform restore preview and compatibility check. The added package reference will be unconditional..
        /// </summary>
        internal static string AddPkg_NoRestoreDescription {
            get {
                return ResourceManager.GetString("AddPkg_NoRestoreDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Directory to restore packages in..
        /// </summary>
        internal static string AddPkg_PackageDirectoryDescription {
            get {
                return ResourceManager.GetString("AddPkg_PackageDirectoryDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Id of the package to be added..
        /// </summary>
        internal static string AddPkg_PackageIdDescription {
            get {
                return ResourceManager.GetString("AddPkg_PackageIdDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Allows prerelease packages to be installed..
        /// </summary>
        internal static string AddPkg_PackagePrerelease {
            get {
                return ResourceManager.GetString("AddPkg_PackagePrerelease", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Version of the package to be added..
        /// </summary>
        internal static string AddPkg_PackageVersionDescription {
            get {
                return ResourceManager.GetString("AddPkg_PackageVersionDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Path to the project file..
        /// </summary>
        internal static string AddPkg_ProjectPathDescription {
            get {
                return ResourceManager.GetString("AddPkg_ProjectPathDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specifies NuGet package sources to use during the restore..
        /// </summary>
        internal static string AddPkg_SourcesDescription {
            get {
                return ResourceManager.GetString("AddPkg_SourcesDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to user specified.
        /// </summary>
        internal static string AddPkg_UserSpecified {
            get {
                return ResourceManager.GetString("AddPkg_UserSpecified", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Add a NuGet source..
        /// </summary>
        internal static string AddSourceCommandDescription {
            get {
                return ResourceManager.GetString("AddSourceCommandDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Allows pushing to HTTP sources (insecure)..
        /// </summary>
        internal static string AllowInsecureConnections_Description {
            get {
                return ResourceManager.GetString("AllowInsecureConnections_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The API key for the server..
        /// </summary>
        internal static string ApiKey_Description {
            get {
                return ResourceManager.GetString("ApiKey_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to NuGet Command Line.
        /// </summary>
        internal static string App_FullName {
            get {
                return ResourceManager.GetString("App_FullName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Argument cannot be null or empty..
        /// </summary>
        internal static string ArgumentNullOrEmpty {
            get {
                return ResourceManager.GetString("ArgumentNullOrEmpty", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to NuGet configuration CLI.
        /// </summary>
        internal static string Config_Description {
            get {
                return ResourceManager.GetString("Config_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Key &apos;{0}&apos; not found..
        /// </summary>
        internal static string ConfigCommandKeyNotFound {
            get {
                return ResourceManager.GetString("ConfigCommandKeyNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to ALL: Get all merged NuGet configuration settings from multiple NuGet configuration files that will be applied, when invoking NuGet command from the working directory path.  CONFIG_KEY: Get the effective value of the specified configuration settings of the config section..
        /// </summary>
        internal static string ConfigGetAllOrConfigKeyDescription {
            get {
                return ResourceManager.GetString("ConfigGetAllOrConfigKeyDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Gets the NuGet configuration settings that will be applied..
        /// </summary>
        internal static string ConfigGetCommandDescription {
            get {
                return ResourceManager.GetString("ConfigGetCommandDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Indicate that the NuGet configuration file path will be shown beside the configuration settings..
        /// </summary>
        internal static string ConfigGetShowPathDescription {
            get {
                return ResourceManager.GetString("ConfigGetShowPathDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Lists the paths to all NuGet configuration files that will be applied when invoking NuGet command in a specific directory.
        /// </summary>
        internal static string ConfigPathsCommandDescription {
            get {
                return ResourceManager.GetString("ConfigPathsCommandDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specifies the directory to start from when listing configuration files. If not specified, the current directory is used..
        /// </summary>
        internal static string ConfigPathsWorkingDirectoryDescription {
            get {
                return ResourceManager.GetString("ConfigPathsWorkingDirectoryDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Set the value of a specified NuGet configuration setting..
        /// </summary>
        internal static string ConfigSetCommandDescription {
            get {
                return ResourceManager.GetString("ConfigSetCommandDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The key of the settings that are to be set..
        /// </summary>
        internal static string ConfigSetConfigKeyDescription {
            get {
                return ResourceManager.GetString("ConfigSetConfigKeyDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The value of the settings that are to be set..
        /// </summary>
        internal static string ConfigSetConfigValueDescription {
            get {
                return ResourceManager.GetString("ConfigSetConfigValueDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Removes the key-value pair from a specified NuGet configuration setting..
        /// </summary>
        internal static string ConfigUnsetCommandDescription {
            get {
                return ResourceManager.GetString("ConfigUnsetCommandDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The key of the settings that are to be removed..
        /// </summary>
        internal static string ConfigUnsetConfigKeyDescription {
            get {
                return ResourceManager.GetString("ConfigUnsetConfigKeyDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The key &quot;{0}&quot; could not be found in config section, so it could not be unset..
        /// </summary>
        internal static string ConfigUnsetNonExistingKey {
            get {
                return ResourceManager.GetString("ConfigUnsetNonExistingKey", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to {0} (y/N).
        /// </summary>
        internal static string ConsoleConfirmMessage {
            get {
                return ResourceManager.GetString("ConsoleConfirmMessage", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to y.
        /// </summary>
        internal static string ConsoleConfirmMessageAccept {
            get {
                return ResourceManager.GetString("ConsoleConfirmMessageAccept", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to DefaultThreadCurrentUICulture value: {0}.
        /// </summary>
        internal static string Debug_CurrentUICulture {
            get {
                return ResourceManager.GetString("Debug_CurrentUICulture", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Deletes a package from the server..
        /// </summary>
        internal static string Delete_Description {
            get {
                return ResourceManager.GetString("Delete_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Please provide arguments for package id and package version..
        /// </summary>
        internal static string Delete_MissingArguments {
            get {
                return ResourceManager.GetString("Delete_MissingArguments", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The Package Id and version..
        /// </summary>
        internal static string Delete_PackageIdAndVersion_Description {
            get {
                return ResourceManager.GetString("Delete_PackageIdAndVersion_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Disable a NuGet source..
        /// </summary>
        internal static string Disable_Description {
            get {
                return ResourceManager.GetString("Disable_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Disable buffering when pushing to an HTTP(S) server to decrease memory usage..
        /// </summary>
        internal static string DisableBuffering_Description {
            get {
                return ResourceManager.GetString("DisableBuffering_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Disable a NuGet source..
        /// </summary>
        internal static string DisableSourceCommandDescription {
            get {
                return ResourceManager.GetString("DisableSourceCommandDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Enable a NuGet source..
        /// </summary>
        internal static string Enable_Description {
            get {
                return ResourceManager.GetString("Enable_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Enable a NuGet source..
        /// </summary>
        internal static string EnableSourceCommandDescription {
            get {
                return ResourceManager.GetString("EnableSourceCommandDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid value provided for &apos;{0}&apos;. The accepted values are {1}..
        /// </summary>
        internal static string Err_InvalidValue {
            get {
                return ResourceManager.GetString("Err_InvalidValue", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to VersionOverride for package &apos;{0}&apos; should not be empty..
        /// </summary>
        internal static string Error_AddPkg_CentralPackageVersions_EmptyVersionOverride {
            get {
                return ResourceManager.GetString("Error_AddPkg_CentralPackageVersions_EmptyVersionOverride", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Package reference for package &apos;{0}&apos; defined in incorrect location, PackageReference should be defined in project file..
        /// </summary>
        internal static string Error_AddPkg_CentralPackageVersions_PackageReference_WrongLocation {
            get {
                return ResourceManager.GetString("Error_AddPkg_CentralPackageVersions_PackageReference_WrongLocation", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to PackageVersion for package &apos;{0}&apos; defined in incorrect location, PackageVersion should be defined in Directory.Package.props..
        /// </summary>
        internal static string Error_AddPkg_CentralPackageVersions_PackageVersion_WrongLocation {
            get {
                return ResourceManager.GetString("Error_AddPkg_CentralPackageVersions_PackageVersion_WrongLocation", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Item &apos;{0}&apos; for &apos;{1}&apos; in Imported file &apos;{2}&apos;..
        /// </summary>
        internal static string Error_AddPkgErrorStringForImportedEdit {
            get {
                return ResourceManager.GetString("Error_AddPkgErrorStringForImportedEdit", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Error while performing {0} for package &apos;{1}&apos;. Cannot edit items in imported files - {2}{3}.
        /// </summary>
        internal static string Error_AddPkgFailOnImportEdit {
            get {
                return ResourceManager.GetString("Error_AddPkgFailOnImportEdit", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Package &apos;{0}&apos; is incompatible with &apos;{1}&apos; frameworks in project &apos;{2}&apos;..
        /// </summary>
        internal static string Error_AddPkgIncompatibleWithAllFrameworks {
            get {
                return ResourceManager.GetString("Error_AddPkgIncompatibleWithAllFrameworks", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Failed to add a PackageReference for &apos;{0}&apos;. A ProjectReference with the same name already exists and a package with the same name cannot be added to the project..
        /// </summary>
        internal static string Error_AddPkgProjectReference {
            get {
                return ResourceManager.GetString("Error_AddPkgProjectReference", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unable to find a resolved package for &apos;{0}&apos;. This is a tooling error. Please file an issue at https://github.com/NuGet/Home..
        /// </summary>
        internal static string Error_AddPkgUnresolved {
            get {
                return ResourceManager.GetString("Error_AddPkgUnresolved", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No assets file was found for `{0}`. Please run restore before running this command..
        /// </summary>
        internal static string Error_AssetsFileNotFound {
            get {
                return ResourceManager.GetString("Error_AssetsFileNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Failed to obtain a search resource..
        /// </summary>
        internal static string Error_CannotObtainSearchSource {
            get {
                return ResourceManager.GetString("Error_CannotObtainSearchSource", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to {0}: Package {1} is implicitly added by the SDK and cannot be upgraded independently.
        /// </summary>
        internal static string Error_CannotUpgradeAutoReferencedPackage {
            get {
                return ResourceManager.GetString("Error_CannotUpgradeAutoReferencedPackage", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The packages {0} are implicitly referenced. You do not typically need to reference them from your project or in your central package versions management file. For more information, see https://aka.ms/sdkimplicitrefs.
        /// </summary>
        internal static string Error_CentralPackageVersions_AutoreferencedReferencesNotAllowed {
            get {
                return ResourceManager.GetString("Error_CentralPackageVersions_AutoreferencedReferencesNotAllowed", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Centrally defined floating package versions are not allowed..
        /// </summary>
        internal static string Error_CentralPackageVersions_FloatingVersionsAreNotAllowed {
            get {
                return ResourceManager.GetString("Error_CentralPackageVersions_FloatingVersionsAreNotAllowed", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The PackageReference items {0} do not have corresponding PackageVersion..
        /// </summary>
        internal static string Error_CentralPackageVersions_MissingPackageVersion {
            get {
                return ResourceManager.GetString("Error_CentralPackageVersions_MissingPackageVersion", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The package reference {0} specifies a VersionOverride but the ability to override a centrally defined version is currently disabled..
        /// </summary>
        internal static string Error_CentralPackageVersions_VersionOverrideDisabled {
            get {
                return ResourceManager.GetString("Error_CentralPackageVersions_VersionOverrideDisabled", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Projects that use central package version management should not define the version on the PackageReference items but on the PackageVersion items: {0}.
        /// </summary>
        internal static string Error_CentralPackageVersions_VersionsNotAllowed {
            get {
                return ResourceManager.GetString("Error_CentralPackageVersions_VersionsNotAllowed", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;{0}&apos; is not a valid config key in config section..
        /// </summary>
        internal static string Error_ConfigSetInvalidKey {
            get {
                return ResourceManager.GetString("Error_ConfigSetInvalidKey", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Central Package Management configuration error: Could not find PackageVersion for package {0}.
        /// </summary>
        internal static string Error_CouldNotFindPackageVersionForCpmPackage {
            get {
                return ResourceManager.GetString("Error_CouldNotFindPackageVersionForCpmPackage", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You are running the &apos;{0}&apos; operation with an &apos;HTTP&apos; source, &apos;{1}&apos;. NuGet requires HTTPS sources. To use HTTP sources, you must explicitly set &apos;allowInsecureConnections&apos; to true in your NuGet.Config file. Refer to https://aka.ms/nuget-https-everywhere for more information..
        /// </summary>
        internal static string Error_HttpServerUsage {
            get {
                return ResourceManager.GetString("Error_HttpServerUsage", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You are running the &apos;{0}&apos; operation with &apos;HTTP&apos; sources: {1}
        ///NuGet requires HTTPS sources. To use HTTP sources, you must explicitly set &apos;allowInsecureConnections&apos; to true in your NuGet.Config file. Refer to https://aka.ms/nuget-https-everywhere for more information..
        /// </summary>
        internal static string Error_HttpServerUsage_MultipleSources {
            get {
                return ResourceManager.GetString("Error_HttpServerUsage_MultipleSources", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid culture identifier in {0} environment variable. Value read is &apos;{1}&apos;.
        /// </summary>
        internal static string Error_InvalidCultureInfo {
            get {
                return ResourceManager.GetString("Error_InvalidCultureInfo", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid value `{0}` for option {1}..
        /// </summary>
        internal static string Error_InvalidOptionValue {
            get {
                return ResourceManager.GetString("Error_InvalidOptionValue", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The specified source &apos;{0}&apos; is invalid. Provide a valid source..
        /// </summary>
        internal static string Error_InvalidSource {
            get {
                return ResourceManager.GetString("Error_InvalidSource", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid version value `{0}`..
        /// </summary>
        internal static string Error_InvalidVersion {
            get {
                return ResourceManager.GetString("Error_InvalidVersion", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid version range &apos;{0}&apos;.
        /// </summary>
        internal static string Error_InvalidVersionRange {
            get {
                return ResourceManager.GetString("Error_InvalidVersionRange", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Missing version from {0}.
        /// </summary>
        internal static string Error_MissingVersion {
            get {
                return ResourceManager.GetString("Error_MissingVersion", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to MsBuild was unable to open Project &apos;{0}&apos;..
        /// </summary>
        internal static string Error_MsBuildUnableToOpenProject {
            get {
                return ResourceManager.GetString("Error_MsBuildUnableToOpenProject", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The directory &apos;{0}&apos; contains multiple project or solution files. Please specify which project or solution file to use..
        /// </summary>
        internal static string Error_MultipleProjectOrSolutionFilesInDirectory {
            get {
                return ResourceManager.GetString("Error_MultipleProjectOrSolutionFilesInDirectory", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to None or invalid DgSpec was passed to NuGet add package command..
        /// </summary>
        internal static string Error_NoDgSpec {
            get {
                return ResourceManager.GetString("Error_NoDgSpec", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The directory &apos;{0}&apos; does not contain any project or solution files..
        /// </summary>
        internal static string Error_NoProjectOrSolutionFilesInDirectory {
            get {
                return ResourceManager.GetString("Error_NoProjectOrSolutionFilesInDirectory", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No package sources found..
        /// </summary>
        internal static string Error_NoSource {
            get {
                return ResourceManager.GetString("Error_NoSource", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The project `{0}` uses package.config for NuGet packages, while the command works only with package reference projects..
        /// </summary>
        internal static string Error_NotPRProject {
            get {
                return ResourceManager.GetString("Error_NotPRProject", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to There are no versions available for the package &apos;{0}&apos;..
        /// </summary>
        internal static string Error_NoVersionsAvailable {
            get {
                return ResourceManager.GetString("Error_NoVersionsAvailable", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Package source mapping is enabled, but no mapping for package {0} was found. See https://aka.ms/nuget/psm for more information..
        /// </summary>
        internal static string Error_PackageSourceMappingNotFound {
            get {
                return ResourceManager.GetString("Error_PackageSourceMappingNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Missing or invalid path &apos;{0}&apos;. Please provide a path to a project, solution file, or directory..
        /// </summary>
        internal static string Error_PathIsMissingOrInvalid {
            get {
                return ResourceManager.GetString("Error_PathIsMissingOrInvalid", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The specified path &apos;{0}&apos; does not exist..
        /// </summary>
        internal static string Error_PathNotFound {
            get {
                return ResourceManager.GetString("Error_PathNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unable to {0} package. Argument &apos;{1}&apos; not provided..
        /// </summary>
        internal static string Error_PkgMissingArgument {
            get {
                return ResourceManager.GetString("Error_PkgMissingArgument", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unable to {0} package. Missing or Invalid project file &apos;{1}&apos;..
        /// </summary>
        internal static string Error_PkgMissingOrInvalidProjectFile {
            get {
                return ResourceManager.GetString("Error_PkgMissingOrInvalidProjectFile", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The --prerelease and --version options are not supported in the same command..
        /// </summary>
        internal static string Error_PrereleaseWhenVersionSpecified {
            get {
                return ResourceManager.GetString("Error_PrereleaseWhenVersionSpecified", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Project &apos;{0}&apos; does not have MSBuild property ProjectAssetsFile defined. This may indicate that this project does not support NuGet PackageReference, or that project customization has prevented the .NET SDK setting default values..
        /// </summary>
        internal static string Error_ProjectAssetsFilePropertyNotFound {
            get {
                return ResourceManager.GetString("Error_ProjectAssetsFilePropertyNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A trusted repository with the service index &apos;{0}&apos; already exists..
        /// </summary>
        internal static string Error_TrustedRepoAlreadyExists {
            get {
                return ResourceManager.GetString("Error_TrustedRepoAlreadyExists", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A trusted signer &apos;{0}&apos; already exists..
        /// </summary>
        internal static string Error_TrustedSignerAlreadyExists {
            get {
                return ResourceManager.GetString("Error_TrustedSignerAlreadyExists", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The certificate finger you&apos;re trying to add is already in the certificate fingerprint list..
        /// </summary>
        internal static string Error_TrustFingerPrintAlreadyExist {
            get {
                return ResourceManager.GetString("Error_TrustFingerPrintAlreadyExist", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Error while adding package &apos;{0}&apos; to project &apos;{1}&apos;. The project does not support adding package references through the add package command..
        /// </summary>
        internal static string Error_UnsupportedProject {
            get {
                return ResourceManager.GetString("Error_UnsupportedProject", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Project &apos;{0}&apos; does not contain any PackageReference &apos;{1}&apos; to {2}..
        /// </summary>
        internal static string Error_UpdatePkgNoSuchPackage {
            get {
                return ResourceManager.GetString("Error_UpdatePkgNoSuchPackage", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Forces the application to run using an invariant, English-based culture..
        /// </summary>
        internal static string ForceEnglishOutput_Description {
            get {
                return ResourceManager.GetString("ForceEnglishOutput_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to PackageReference for package &apos;{0}&apos; version &apos;{1}&apos; added to file &apos;{2}&apos;..
        /// </summary>
        internal static string Info_AddPkgAdded {
            get {
                return ResourceManager.GetString("Info_AddPkgAdded", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Adding PackageReference for package &apos;{0}&apos; into project &apos;{1}&apos;..
        /// </summary>
        internal static string Info_AddPkgAddingReference {
            get {
                return ResourceManager.GetString("Info_AddPkgAddingReference", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Package &apos;{0}&apos; is compatible with all the specified frameworks in project &apos;{1}&apos;..
        /// </summary>
        internal static string Info_AddPkgCompatibleWithAllFrameworks {
            get {
                return ResourceManager.GetString("Info_AddPkgCompatibleWithAllFrameworks", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Package &apos;{0}&apos; is compatible with a subset of the specified frameworks in project &apos;{1}&apos;..
        /// </summary>
        internal static string Info_AddPkgCompatibleWithSubsetFrameworks {
            get {
                return ResourceManager.GetString("Info_AddPkgCompatibleWithSubsetFrameworks", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to PackageReference for package &apos;{0}&apos; added to &apos;{1}&apos; and PackageVersion added to central package management file &apos;{2}&apos;..
        /// </summary>
        internal static string Info_AddPkgCPM {
            get {
                return ResourceManager.GetString("Info_AddPkgCPM", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to PackageReference for package &apos;{0}&apos; version &apos;{1}&apos; updated in file &apos;{2}&apos;..
        /// </summary>
        internal static string Info_AddPkgUpdated {
            get {
                return ResourceManager.GetString("Info_AddPkgUpdated", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Removing PackageReference for package &apos;{0}&apos; from project &apos;{1}&apos;..
        /// </summary>
        internal static string Info_RemovePkgRemovingReference {
            get {
                return ResourceManager.GetString("Info_RemovePkgRemovingReference", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to List configured NuGet sources..
        /// </summary>
        internal static string List_Description {
            get {
                return ResourceManager.GetString("List_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Lists all the client certificates in the configuration..
        /// </summary>
        internal static string ListClientCertCommandDescription {
            get {
                return ResourceManager.GetString("ListClientCertCommandDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to (A) : Auto-referenced package..
        /// </summary>
        internal static string ListPkg_AutoReferenceDescription {
            get {
                return ResourceManager.GetString("ListPkg_AutoReferenceDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A path to a config file to specify sources. Works only with `--outdated`..
        /// </summary>
        internal static string ListPkg_ConfigDescription {
            get {
                return ResourceManager.GetString("ListPkg_ConfigDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Displays only the packages marked deprecated by the authors..
        /// </summary>
        internal static string ListPkg_DeprecatedDescription {
            get {
                return ResourceManager.GetString("ListPkg_DeprecatedDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Alternative.
        /// </summary>
        internal static string ListPkg_DeprecationAlternative {
            get {
                return ResourceManager.GetString("ListPkg_DeprecationAlternative", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Reason(s).
        /// </summary>
        internal static string ListPkg_DeprecationReasons {
            get {
                return ResourceManager.GetString("ListPkg_DeprecationReasons", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Lists all the packages used by the current project(s)..
        /// </summary>
        internal static string ListPkg_Description {
            get {
                return ResourceManager.GetString("ListPkg_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The given file `{0}` was not found.
        /// </summary>
        internal static string ListPkg_ErrorFileNotFound {
            get {
                return ResourceManager.GetString("ListPkg_ErrorFileNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unable to read the assets file `{0}`. Please make sure the file has the write format..
        /// </summary>
        internal static string ListPkg_ErrorReadingAssetsFile {
            get {
                return ResourceManager.GetString("ListPkg_ErrorReadingAssetsFile", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unable to read a package reference from the project `{0}`. Please make sure that your project file and project.assets.json file are in sync by running restore..
        /// </summary>
        internal static string ListPkg_ErrorReadingReferenceFromProject {
            get {
                return ResourceManager.GetString("ListPkg_ErrorReadingReferenceFromProject", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specifies the target framework for which the packages will be listed..
        /// </summary>
        internal static string ListPkg_FrameworkDescription {
            get {
                return ResourceManager.GetString("ListPkg_FrameworkDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Considers only the versions with matching major. Works only with `--outdated`..
        /// </summary>
        internal static string ListPkg_HighestMinorDescription {
            get {
                return ResourceManager.GetString("ListPkg_HighestMinorDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Considers only the versions with matching minor and major. Works only with `--outdated`..
        /// </summary>
        internal static string ListPkg_HighestPatchDescription {
            get {
                return ResourceManager.GetString("ListPkg_HighestPatchDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Failed to parse one of the given frameworks. Please make sure the given frameworks are valid..
        /// </summary>
        internal static string ListPkg_InvalidFramework {
            get {
                return ResourceManager.GetString("ListPkg_InvalidFramework", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Options &apos;--outdated&apos;, &apos;--deprecated&apos; and &apos;--vulnerable&apos; cannot be combined..
        /// </summary>
        internal static string ListPkg_InvalidOptions {
            get {
                return ResourceManager.GetString("ListPkg_InvalidOptions", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid value {0} provided for output format. The accepted values are {1}..
        /// </summary>
        internal static string ListPkg_InvalidOutputFormat {
            get {
                return ResourceManager.GetString("ListPkg_InvalidOutputFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unsupported output format version {0} was requested.  The accepted format version value is {1}..
        /// </summary>
        internal static string ListPkg_InvalidOutputVersion {
            get {
                return ResourceManager.GetString("ListPkg_InvalidOutputVersion", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Latest.
        /// </summary>
        internal static string ListPkg_Latest {
            get {
                return ResourceManager.GetString("ListPkg_Latest", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The given project `{0}` has no deprecated packages given the current sources..
        /// </summary>
        internal static string ListPkg_NoDeprecatedPackagesForProject {
            get {
                return ResourceManager.GetString("ListPkg_NoDeprecatedPackagesForProject", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No deprecated packages for this framework..
        /// </summary>
        internal static string ListPkg_NoDeprecationsForFramework {
            get {
                return ResourceManager.GetString("ListPkg_NoDeprecationsForFramework", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No packages were found for this framework..
        /// </summary>
        internal static string ListPkg_NoPackagesForFramework {
            get {
                return ResourceManager.GetString("ListPkg_NoPackagesForFramework", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No packages were found for the project `{0}` given the specified frameworks..
        /// </summary>
        internal static string ListPkg_NoPackagesFoundForFrameworks {
            get {
                return ResourceManager.GetString("ListPkg_NoPackagesFoundForFrameworks", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Not found at the sources.
        /// </summary>
        internal static string ListPkg_NotFoundAtSources {
            get {
                return ResourceManager.GetString("ListPkg_NotFoundAtSources", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No package updates available for this framework..
        /// </summary>
        internal static string ListPkg_NoUpdatesForFramework {
            get {
                return ResourceManager.GetString("ListPkg_NoUpdatesForFramework", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The given project `{0}` has no updates given the current sources..
        /// </summary>
        internal static string ListPkg_NoUpdatesForProject {
            get {
                return ResourceManager.GetString("ListPkg_NoUpdatesForProject", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No vulnerable packages for this framework..
        /// </summary>
        internal static string ListPkg_NoVulnerabilitiesForFramework {
            get {
                return ResourceManager.GetString("ListPkg_NoVulnerabilitiesForFramework", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The given project `{0}` has no vulnerable packages given the current sources..
        /// </summary>
        internal static string ListPkg_NoVulnerablePackagesForProject {
            get {
                return ResourceManager.GetString("ListPkg_NoVulnerablePackagesForProject", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Displays only the packages that need updates with the latest version from the sources..
        /// </summary>
        internal static string ListPkg_OutdatedDescription {
            get {
                return ResourceManager.GetString("ListPkg_OutdatedDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Set the report output format..
        /// </summary>
        internal static string ListPkg_OutputFormatDescription {
            get {
                return ResourceManager.GetString("ListPkg_OutputFormatDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The version of report output..
        /// </summary>
        internal static string ListPkg_OutputVersionDescription {
            get {
                return ResourceManager.GetString("ListPkg_OutputVersionDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;--output-version&apos; option not applicable for console output, it can only be used together with `--format json` option..
        /// </summary>
        internal static string ListPkg_OutputVersionNotApplicable {
            get {
                return ResourceManager.GetString("ListPkg_OutputVersionNotApplicable", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A path to a project, solution file or directory..
        /// </summary>
        internal static string ListPkg_PathDescription {
            get {
                return ResourceManager.GetString("ListPkg_PathDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Considers prerelease versions when looking for latest. Works only with `--outdated`..
        /// </summary>
        internal static string ListPkg_PrereleaseDescription {
            get {
                return ResourceManager.GetString("ListPkg_PrereleaseDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Project `{0}` has the following deprecated packages.
        /// </summary>
        internal static string ListPkg_ProjectDeprecationsHeaderLog {
            get {
                return ResourceManager.GetString("ListPkg_ProjectDeprecationsHeaderLog", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Project &apos;{0}&apos; has the following package references.
        /// </summary>
        internal static string ListPkg_ProjectHeaderLog {
            get {
                return ResourceManager.GetString("ListPkg_ProjectHeaderLog", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Project `{0}` has the following updates to its packages.
        /// </summary>
        internal static string ListPkg_ProjectUpdatesHeaderLog {
            get {
                return ResourceManager.GetString("ListPkg_ProjectUpdatesHeaderLog", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Project `{0}` has the following vulnerable packages.
        /// </summary>
        internal static string ListPkg_ProjectVulnerabilitiesHeaderLog {
            get {
                return ResourceManager.GetString("ListPkg_ProjectVulnerabilitiesHeaderLog", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Requested.
        /// </summary>
        internal static string ListPkg_Requested {
            get {
                return ResourceManager.GetString("ListPkg_Requested", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Resolved.
        /// </summary>
        internal static string ListPkg_Resolved {
            get {
                return ResourceManager.GetString("ListPkg_Resolved", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Sources to lookup for latest versions. Works only with `--outdated`..
        /// </summary>
        internal static string ListPkg_SourceDescription {
            get {
                return ResourceManager.GetString("ListPkg_SourceDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The following sources were used:.
        /// </summary>
        internal static string ListPkg_SourcesUsedDescription {
            get {
                return ResourceManager.GetString("ListPkg_SourcesUsedDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Top-level Package.
        /// </summary>
        internal static string ListPkg_TopLevelHeader {
            get {
                return ResourceManager.GetString("ListPkg_TopLevelHeader", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Includes transitive packages too in the result..
        /// </summary>
        internal static string ListPkg_TransitiveDescription {
            get {
                return ResourceManager.GetString("ListPkg_TransitiveDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Transitive Package.
        /// </summary>
        internal static string ListPkg_TransitiveHeader {
            get {
                return ResourceManager.GetString("ListPkg_TransitiveHeader", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Advisory URL.
        /// </summary>
        internal static string ListPkg_VulnerabilityAdvisoryUrl {
            get {
                return ResourceManager.GetString("ListPkg_VulnerabilityAdvisoryUrl", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Severity.
        /// </summary>
        internal static string ListPkg_VulnerabilitySeverity {
            get {
                return ResourceManager.GetString("ListPkg_VulnerabilitySeverity", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Displays only the packages flagged as vulnerable..
        /// </summary>
        internal static string ListPkg_VulnerableDescription {
            get {
                return ResourceManager.GetString("ListPkg_VulnerableDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The command option(s) &apos;--include-prerelease&apos;, &apos;--highest-minor&apos;, and &apos;--highest-patch&apos; are ignored by this command..
        /// </summary>
        internal static string ListPkg_VulnerableIgnoredOptions {
            get {
                return ResourceManager.GetString("ListPkg_VulnerableIgnoredOptions", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Lists all configured NuGet sources..
        /// </summary>
        internal static string ListSourceCommandDescription {
            get {
                return ResourceManager.GetString("ListSourceCommandDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specifies the cache location(s) to list or clear.
        ///&lt;all | http-cache | global-packages | temp&gt;.
        /// </summary>
        internal static string LocalsCommand_ArgumentDescription {
            get {
                return ResourceManager.GetString("LocalsCommand_ArgumentDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Clear the selected local resources or cache location(s)..
        /// </summary>
        internal static string LocalsCommand_ClearDescription {
            get {
                return ResourceManager.GetString("LocalsCommand_ClearDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Clears or lists local NuGet resources such as http requests cache, packages folder, plugin operations cache  or machine-wide global packages folder..
        /// </summary>
        internal static string LocalsCommand_Description {
            get {
                return ResourceManager.GetString("LocalsCommand_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to List the selected local resources or cache location(s)..
        /// </summary>
        internal static string LocalsCommand_ListDescription {
            get {
                return ResourceManager.GetString("LocalsCommand_ListDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Both operations, --list and --clear, are not supported in the same command. Please specify only one operation.
        ///usage: NuGet locals &lt;all | http-cache | global-packages | temp | plugins-cache&gt; [--clear | -c | --list | -l]
        ///For more information, visit https://docs.nuget.org/docs/reference/command-line-reference.
        /// </summary>
        internal static string LocalsCommand_MultipleOperations {
            get {
                return ResourceManager.GetString("LocalsCommand_MultipleOperations", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No Cache Type was specified.
        ///usage: NuGet locals &lt;all | http-cache | global-packages | temp | plugins-cache&gt; [--clear | -c | --list | -l]
        ///For more information, visit https://docs.nuget.org/docs/reference/command-line-reference.
        /// </summary>
        internal static string LocalsCommand_NoArguments {
            get {
                return ResourceManager.GetString("LocalsCommand_NoArguments", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Please specify an operation i.e. --list or --clear.
        ///usage: NuGet locals &lt;all | http-cache | global-packages | temp | plugins-cache&gt; [--clear | -c | --list | -l]
        ///For more information, visit https://docs.nuget.org/docs/reference/command-line-reference.
        /// </summary>
        internal static string LocalsCommand_NoOperation {
            get {
                return ResourceManager.GetString("LocalsCommand_NoOperation", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Do not prompt for user input or confirmations..
        /// </summary>
        internal static string NonInteractive_Description {
            get {
                return ResourceManager.GetString("NonInteractive_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Does not append &quot;api/v2/package&quot; to the source URL..
        /// </summary>
        internal static string NoServiceEndpoint_Description {
            get {
                return ResourceManager.GetString("NoServiceEndpoint_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to If a symbols package exists, it will not be pushed to a symbols server..
        /// </summary>
        internal static string NoSymbols_Description {
            get {
                return ResourceManager.GetString("NoSymbols_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Allow the command to block and require manual action for operations like authentication..
        /// </summary>
        internal static string NuGetXplatCommand_Interactive {
            get {
                return ResourceManager.GetString("NuGetXplatCommand_Interactive", 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. For more information, see https://docs.microsoft.com/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 Search method to find certificate in certificate store (see docs)..
        /// </summary>
        internal static string Option_FindBy {
            get {
                return ResourceManager.GetString("Option_FindBy", 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 Option_FindValue {
            get {
                return ResourceManager.GetString("Option_FindValue", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Skip certificate validation..
        /// </summary>
        internal static string Option_Force {
            get {
                return ResourceManager.GetString("Option_Force", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Package source name..
        /// </summary>
        internal static string Option_PackageSource {
            get {
                return ResourceManager.GetString("Option_PackageSource", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Password for the certificate, if needed..
        /// </summary>
        internal static string Option_Password {
            get {
                return ResourceManager.GetString("Option_Password", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Path to certificate file..
        /// </summary>
        internal static string Option_Path {
            get {
                return ResourceManager.GetString("Option_Path", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Certificate store location (see docs)..
        /// </summary>
        internal static string Option_StoreLocation {
            get {
                return ResourceManager.GetString("Option_StoreLocation", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Certificate store name (see docs)..
        /// </summary>
        internal static string Option_StoreName {
            get {
                return ResourceManager.GetString("Option_StoreName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Enables storing password for the certificate by disabling password encryption..
        /// </summary>
        internal static string Option_StorePasswordInClearText {
            get {
                return ResourceManager.GetString("Option_StorePasswordInClearText", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to {0} Version: {1}.
        /// </summary>
        internal static string OutputNuGetVersion {
            get {
                return ResourceManager.GetString("OutputNuGetVersion", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to All packages are already up to date..
        /// </summary>
        internal static string PackageUpdate_AllPackagesAlreadyUpToDate {
            get {
                return ResourceManager.GetString("PackageUpdate_AllPackagesAlreadyUpToDate", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to All versions of package {0} have security advisories. Unable to find a non-vulnerable version to update to..
        /// </summary>
        internal static string PackageUpdate_AllVersionsHaveAdvisories {
            get {
                return ResourceManager.GetString("PackageUpdate_AllVersionsHaveAdvisories", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to All packages are up to date.
        /// </summary>
        internal static string PackageUpdate_AlreadyUpToDate {
            get {
                return ResourceManager.GetString("PackageUpdate_AlreadyUpToDate", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This command requires NuGetAudit to be enabled at this time. See https://aka.ms/nuget/audit for more information..
        /// </summary>
        internal static string PackageUpdate_AuditDisabled {
            get {
                return ResourceManager.GetString("PackageUpdate_AuditDisabled", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to NuGetAuditMode is set to direct, which means that transitive packages with known vulnerabilities will not be updated. See https://aka.ms/nuget/audit for more information..
        /// </summary>
        internal static string PackageUpdate_AuditModeIsDirect {
            get {
                return ResourceManager.GetString("PackageUpdate_AuditModeIsDirect", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Updated {0} packages in {1} scanned packages..
        /// </summary>
        internal static string PackageUpdate_FinalSummary {
            get {
                return ResourceManager.GetString("PackageUpdate_FinalSummary", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Finding versions of packages to update..
        /// </summary>
        internal static string PackageUpdate_FindingUpdateVersions {
            get {
                return ResourceManager.GetString("PackageUpdate_FindingUpdateVersions", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Loading Project(s)..
        /// </summary>
        internal static string PackageUpdate_LoadingDGSpec {
            get {
                return ResourceManager.GetString("PackageUpdate_LoadingDGSpec", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No upgradable packages have known vulnerabilities..
        /// </summary>
        internal static string PackageUpdate_NoVulnerablePackages {
            get {
                return ResourceManager.GetString("PackageUpdate_NoVulnerablePackages", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Package reference in the form of a package identifier like &apos;Newtonsoft.Json&apos; or package identifier and version separated by &apos;@&apos; like &apos;Newtonsoft.Json@13.0.3&apos;..
        /// </summary>
        internal static string PackageUpdate_PackageArgumentDescription {
            get {
                return ResourceManager.GetString("PackageUpdate_PackageArgumentDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Running preview restore to check package compatibility..
        /// </summary>
        internal static string PackageUpdate_PreviewRestore {
            get {
                return ResourceManager.GetString("PackageUpdate_PreviewRestore", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Preview restore with updated packages was not successful. Force mode is not yet available..
        /// </summary>
        internal static string PackageUpdate_PreviewRestoreFailed {
            get {
                return ResourceManager.GetString("PackageUpdate_PreviewRestoreFailed", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Updating {0} {1} to {2}..
        /// </summary>
        internal static string PackageUpdate_UpdatedMessage {
            get {
                return ResourceManager.GetString("PackageUpdate_UpdatedMessage", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Updating outdated packages in {0}..
        /// </summary>
        internal static string PackageUpdate_UpdatingOutdatedPackages {
            get {
                return ResourceManager.GetString("PackageUpdate_UpdatingOutdatedPackages", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Updating packages with security advisories in {0}.
        /// </summary>
        internal static string PackageUpdate_UpdatingVulnerablePackages {
            get {
                return ResourceManager.GetString("PackageUpdate_UpdatingVulnerablePackages", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Update referenced packages in a project or solution..
        /// </summary>
        internal static string PackageUpdateCommand_Description {
            get {
                return ResourceManager.GetString("PackageUpdateCommand_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Path to a project or solution file, or a directory..
        /// </summary>
        internal static string PackageUpdateCommand_ProjectOptionDescription {
            get {
                return ResourceManager.GetString("PackageUpdateCommand_ProjectOptionDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Upgrade packages with known vulnerabilities..
        /// </summary>
        internal static string PackageUpdateCommand_VulnerableOptionDescription {
            get {
                return ResourceManager.GetString("PackageUpdateCommand_VulnerableOptionDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Searches one or more package sources for packages that match a search term. If no sources are specified, all sources defined in the NuGet.Config are used..
        /// </summary>
        internal static string pkgSearch_Description {
            get {
                return ResourceManager.GetString("pkgSearch_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Require that the search term exactly match the name of the package. Causes `--take` and `--skip` options to be ignored..
        /// </summary>
        internal static string pkgSearch_ExactMatchDescription {
            get {
                return ResourceManager.GetString("pkgSearch_ExactMatchDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Format the output accordingly. Either `table`, or `json`. The default value is `table`..
        /// </summary>
        internal static string pkgSearch_FormatDescription {
            get {
                return ResourceManager.GetString("pkgSearch_FormatDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Stop and wait for user input or action (for example to complete authentication)..
        /// </summary>
        internal static string pkgSearch_InteractiveDescription {
            get {
                return ResourceManager.GetString("pkgSearch_InteractiveDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Include prerelease packages..
        /// </summary>
        internal static string pkgSearch_PrereleaseDescription {
            get {
                return ResourceManager.GetString("pkgSearch_PrereleaseDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Number of results to skip, to allow pagination. Default 0..
        /// </summary>
        internal static string pkgSearch_SkipDescription {
            get {
                return ResourceManager.GetString("pkgSearch_SkipDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Package source to search. You can pass multiple `--source` options to search multiple package sources. Example: `--source https://api.nuget.org/v3/index.json`..
        /// </summary>
        internal static string pkgSearch_SourceDescription {
            get {
                return ResourceManager.GetString("pkgSearch_SourceDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Number of results to return. Default 20..
        /// </summary>
        internal static string pkgSearch_TakeDescription {
            get {
                return ResourceManager.GetString("pkgSearch_TakeDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Search term to filter package names, descriptions, and tags. Used as a literal value. Example: `dotnet package search some.package`. See also `--exact-match`..
        /// </summary>
        internal static string pkgSearch_termDescription {
            get {
                return ResourceManager.GetString("pkgSearch_termDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Display this amount of details in the output: `normal`, `minimal`, `detailed`. The default is `normal`..
        /// </summary>
        internal static string pkgSearch_VerbosityDescription {
            get {
                return ResourceManager.GetString("pkgSearch_VerbosityDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to There are no stable versions available, {0} is the best available. Consider adding the --prerelease option.
        /// </summary>
        internal static string PrereleaseVersionsAvailable {
            get {
                return ResourceManager.GetString("PrereleaseVersionsAvailable", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Pushes a package to the server and publishes it..
        /// </summary>
        internal static string Push_Description {
            get {
                return ResourceManager.GetString("Push_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid timeout parameter value..
        /// </summary>
        internal static string Push_InvalidTimeout {
            get {
                return ResourceManager.GetString("Push_InvalidTimeout", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Please specify the path to the package..
        /// </summary>
        internal static string Push_MissingArguments {
            get {
                return ResourceManager.GetString("Push_MissingArguments", 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 Push_Package_ApiKey_Description {
            get {
                return ResourceManager.GetString("Push_Package_ApiKey_Description", 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 Push_Timeout_Description {
            get {
                return ResourceManager.GetString("Push_Timeout_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Pushing took too long. You can change the default timeout of 300 seconds by using the --timeout &lt;seconds&gt; option with the push command..
        /// </summary>
        internal static string Push_Timeout_Error {
            get {
                return ResourceManager.GetString("Push_Timeout_Error", 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 Remove a NuGet source..
        /// </summary>
        internal static string Remove_Description {
            get {
                return ResourceManager.GetString("Remove_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Removes the client certificate configuration that matches the given package source name..
        /// </summary>
        internal static string RemoveClientCertCommandDescription {
            get {
                return ResourceManager.GetString("RemoveClientCertCommandDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Removes a package reference from a project..
        /// </summary>
        internal static string RemovePkg_Description {
            get {
                return ResourceManager.GetString("RemovePkg_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Id of the package to be removed..
        /// </summary>
        internal static string RemovePkg_PackageIdDescription {
            get {
                return ResourceManager.GetString("RemovePkg_PackageIdDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Path to the project file..
        /// </summary>
        internal static string RemovePkg_ProjectPathDescription {
            get {
                return ResourceManager.GetString("RemovePkg_ProjectPathDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Remove a NuGet source..
        /// </summary>
        internal static string RemoveSourceCommandDescription {
            get {
                return ResourceManager.GetString("RemoveSourceCommandDescription", 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 --certificate-store-name and --certificate-store-location 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. The command will throw an error message if certificate is password protected but password is not provided as input..
        /// </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 --certificate-subject-name or --certificate-fingerprint 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 --certificate-subject-name or --certificate-fingerprint 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 --certificate-store-name and --certificate-store-location options..
        /// </summary>
        internal static string SignCommandCertificateSubjectNameDescription {
            get {
                return ResourceManager.GetString("SignCommandCertificateSubjectNameDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Signs NuGet package(s) at &lt;package-paths&gt; with the specified certificate..
        /// </summary>
        internal static string SignCommandDescription {
            get {
                return ResourceManager.GetString("SignCommandDescription", 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;--certificate-fingerprint&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 Multiple options were used to specify a certificate..
        /// </summary>
        internal static string SignCommandMultipleCertificateException {
            get {
                return ResourceManager.GetString("SignCommandMultipleCertificateException", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No certificate was provided..
        /// </summary>
        internal static string SignCommandNoCertificateException {
            get {
                return ResourceManager.GetString("SignCommandNoCertificateException", 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.microsoft.com/dotnet/core/tools.
        /// </summary>
        internal static string SignCommandNoTimestamperWarning {
            get {
                return ResourceManager.GetString("SignCommandNoTimestamperWarning", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Directory where the signed package(s) 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 Signs NuGet packages at &lt;package-paths&gt; with the specified certificate..
        /// </summary>
        internal static string SignCommandPackagePathDescription {
            get {
                return ResourceManager.GetString("SignCommandPackagePathDescription", 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 Package source (URL, UNC/folder path or package source name) to use. Defaults to DefaultPushSource if specified in NuGet.Config..
        /// </summary>
        internal static string Source_Description {
            get {
                return ResourceManager.GetString("Source_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The proper command is &apos;{0}&apos;..
        /// </summary>
        internal static string Sources_Redirect {
            get {
                return ResourceManager.GetString("Sources_Redirect", 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 The format of the list command output: `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 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 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. Set this to basic if the server advertises NTLM or Negotiate and your credentials must be sent using the Basic mechanism, for instance when using a PAT with on-premises Azure DevOps Server. Other valid values include negotiate, kerberos, ntlm, and digest, but these values are unlikely to be useful..
        /// </summary>
        internal static string SourcesCommandValidAuthenticationTypesDescription {
            get {
                return ResourceManager.GetString("SourcesCommandValidAuthenticationTypesDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The protocol version specified is invalid. Provide a valid protocol version..
        /// </summary>
        internal static string SourcesCommandValidProtocolVersion {
            get {
                return ResourceManager.GetString("SourcesCommandValidProtocolVersion", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The API key for the symbol server..
        /// </summary>
        internal static string SymbolApiKey_Description {
            get {
                return ResourceManager.GetString("SymbolApiKey_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Symbol server URL to use..
        /// </summary>
        internal static string SymbolSource_Description {
            get {
                return ResourceManager.GetString("SymbolSource_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Adds a trusted signer with the given name, based on the author signature of the package..
        /// </summary>
        internal static string TrustAuthorCommandDescription {
            get {
                return ResourceManager.GetString("TrustAuthorCommandDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The fingerprint of the certificate..
        /// </summary>
        internal static string TrustCertificateFingerprint {
            get {
                return ResourceManager.GetString("TrustCertificateFingerprint", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specifies the hash algorithm used to calculate the certificate fingerprint. Defaults to SHA256. Values supported are SHA256, SHA384 and SHA512..
        /// </summary>
        internal static string TrustCommandAlgorithm {
            get {
                return ResourceManager.GetString("TrustCommandAlgorithm", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specifies if the certificate for the trusted signer should be allowed to chain to an untrusted root. This is not recommended..
        /// </summary>
        internal static string TrustCommandAllowUntrustedRoot {
            get {
                return ResourceManager.GetString("TrustCommandAllowUntrustedRoot", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Manage the trusted signers..
        /// </summary>
        internal static string TrustCommandDescription {
            get {
                return ResourceManager.GetString("TrustCommandDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Semi-colon separated list of trusted owners to further restrict the trust of a repository..
        /// </summary>
        internal static string TrustCommandOwners {
            get {
                return ResourceManager.GetString("TrustCommandOwners", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the trusted signer to add. If a trusted signer with the given name already exists, the certificate item is added to that signer. Otherwise a trusted author is created with a certificate item from the given certificate information..
        /// </summary>
        internal static string TrustedCertificateSignerNameToAdd {
            get {
                return ResourceManager.GetString("TrustedCertificateSignerNameToAdd", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the existing trusted signer to sync..
        /// </summary>
        internal static string TrustedSignerNameExists {
            get {
                return ResourceManager.GetString("TrustedSignerNameExists", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the trusted signer to add. If name already exists in the configuration, the signature is appended..
        /// </summary>
        internal static string TrustedSignerNameToAdd {
            get {
                return ResourceManager.GetString("TrustedSignerNameToAdd", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The name of the existing trusted signer to remove..
        /// </summary>
        internal static string TrustedSignerNameToRemove {
            get {
                return ResourceManager.GetString("TrustedSignerNameToRemove", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Lists all the trusted signers in the configuration..
        /// </summary>
        internal static string TrustListCommandDescription {
            get {
                return ResourceManager.GetString("TrustListCommandDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The given package should be a local path to the signed .nupkg file..
        /// </summary>
        internal static string TrustLocalSignedNupkgPath {
            get {
                return ResourceManager.GetString("TrustLocalSignedNupkgPath", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Removes any trusted signers that match the given name..
        /// </summary>
        internal static string TrustRemoveCommandDescription {
            get {
                return ResourceManager.GetString("TrustRemoveCommandDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Adds a trusted signer with the given name, based on the repository signature or countersignature of a signed package..
        /// </summary>
        internal static string TrustRepositoryCommandDescription {
            get {
                return ResourceManager.GetString("TrustRepositoryCommandDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Adds a trusted signer based on a given package source..
        /// </summary>
        internal static string TrustSourceCommandDescription {
            get {
                return ResourceManager.GetString("TrustSourceCommandDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &quot;The name of the trusted signer to add. If only &lt;NAME&gt; is provided without --&lt;source-url&gt;, the package source from your NuGet configuration files with the same name is added to the trusted list. If &lt;NAME&gt; already exists in the configuration, the package source is appended to it.&quot;.
        /// </summary>
        internal static string TrustSourceSignerName {
            get {
                return ResourceManager.GetString("TrustSourceSignerName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to If a source-url is provided, it must be a v3 package source URL (like https://api.nuget.org/v3/index.json). Other package source types are not supported..
        /// </summary>
        internal static string TrustSourceUrl {
            get {
                return ResourceManager.GetString("TrustSourceUrl", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Deletes the current list of certificates and replaces them with an up-to-date list from the repository..
        /// </summary>
        internal static string TrustSyncCommandDescription {
            get {
                return ResourceManager.GetString("TrustSyncCommandDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The package {0} references different versions of the package for different target frameworks. This is not supported by this command. Please edit the project file directly. ({1}).
        /// </summary>
        internal static string Unsupported_UpdatePackageWithDifferentPerTfmVersions {
            get {
                return ResourceManager.GetString("Unsupported_UpdatePackageWithDifferentPerTfmVersions", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unsupported: Updating more than one project is not yet supported.
        /// </summary>
        internal static string Unsupported_UpdatingMoreThanOneProject {
            get {
                return ResourceManager.GetString("Unsupported_UpdatingMoreThanOneProject", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unsupported: Upgrading all packages in a project is not yet supported.
        /// </summary>
        internal static string Unsupported_UpgradeAllPackages {
            get {
                return ResourceManager.GetString("Unsupported_UpgradeAllPackages", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Update a NuGet source..
        /// </summary>
        internal static string Update_Description {
            get {
                return ResourceManager.GetString("Update_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Updates the client certificate configuration that matches the given package source name..
        /// </summary>
        internal static string UpdateClientCertCommandDescription {
            get {
                return ResourceManager.GetString("UpdateClientCertCommandDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Update a NuGet source..
        /// </summary>
        internal static string UpdateSourceCommandDescription {
            get {
                return ResourceManager.GetString("UpdateSourceCommandDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Set the verbosity level of the command. Allowed values are q[uiet], m[inimal], n[ormal], d[etailed], and diag[nostic]..
        /// </summary>
        internal static string Verbosity_Description {
            get {
                return ResourceManager.GetString("Verbosity_Description", 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 separated by space..
        /// </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 Specify the path to the package.
        /// </summary>
        internal static string VerifyCommandPackagePathDescription {
            get {
                return ResourceManager.GetString("VerifyCommandPackagePathDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to --no-restore|-n flag was used. No compatibility check will be done and the added package reference will be unconditional..
        /// </summary>
        internal static string Warn_AddPkgWithoutRestore {
            get {
                return ResourceManager.GetString("Warn_AddPkgWithoutRestore", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The package {0} is already referencing the highest version {1} in project {2}.
        /// </summary>
        internal static string Warning_AlreadyHighestVersion {
            get {
                return ResourceManager.GetString("Warning_AlreadyHighestVersion", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Package {0} is already referencing version {1}.
        /// </summary>
        internal static string Warning_AlreadyUsingSameVersion {
            get {
                return ResourceManager.GetString("Warning_AlreadyUsingSameVersion", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Audit source &apos;{0}&apos; did not provide any vulnerability data..
        /// </summary>
        internal static string Warning_AuditSourceWithoutData {
            get {
                return ResourceManager.GetString("Warning_AuditSourceWithoutData", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Shows the dependency graph for a particular package for a given project or solution..
        /// </summary>
        internal static string WhyCommand_Description {
            get {
                return ResourceManager.GetString("WhyCommand_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unable to run &apos;dotnet nuget why&apos;. The &apos;{0}&apos; argument cannot be empty..
        /// </summary>
        internal static string WhyCommand_Error_ArgumentCannotBeEmpty {
            get {
                return ResourceManager.GetString("WhyCommand_Error_ArgumentCannotBeEmpty", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unable to run &apos;dotnet nuget why&apos;. {0}.
        /// </summary>
        internal static string WhyCommand_Error_ArgumentExceptionThrown {
            get {
                return ResourceManager.GetString("WhyCommand_Error_ArgumentExceptionThrown", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The file &apos;{0}&apos; does not appear to be a NuGet assets file. For more information, see https://aka.ms/dotnet/nuget/why#older-project-format.
        /// </summary>
        internal static string WhyCommand_Error_InvalidAssetsFile_WithoutProject {
            get {
                return ResourceManager.GetString("WhyCommand_Error_InvalidAssetsFile_WithoutProject", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The file &apos;{0}&apos; does not appear to be a NuGet assets file. Please run restore for project &apos;{1}&apos; before running this command..
        /// </summary>
        internal static string WhyCommand_Error_InvalidAssetsFile_WithProject {
            get {
                return ResourceManager.GetString("WhyCommand_Error_InvalidAssetsFile_WithProject", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The target framework(s) for which dependency graphs are shown..
        /// </summary>
        internal static string WhyCommand_FrameworksOption_Description {
            get {
                return ResourceManager.GetString("WhyCommand_FrameworksOption_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Project &apos;{0}&apos; has the following dependency graph(s) for &apos;{1}&apos;:.
        /// </summary>
        internal static string WhyCommand_Message_DependencyGraphsFoundInProject {
            get {
                return ResourceManager.GetString("WhyCommand_Message_DependencyGraphsFoundInProject", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No dependency graph(s) found for this target framework..
        /// </summary>
        internal static string WhyCommand_Message_NoDependencyGraphsFoundForFramework {
            get {
                return ResourceManager.GetString("WhyCommand_Message_NoDependencyGraphsFoundForFramework", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Project &apos;{0}&apos; does not have a dependency on &apos;{1}&apos;..
        /// </summary>
        internal static string WhyCommand_Message_NoDependencyGraphsFoundInProject {
            get {
                return ResourceManager.GetString("WhyCommand_Message_NoDependencyGraphsFoundInProject", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unable to run &apos;dotnet nuget why&apos; for project &apos;{0}&apos;. See https://aka.ms/dotnet/nuget/why#older-project-format.
        /// </summary>
        internal static string WhyCommand_Message_NonSDKStyleProjectsAreNotSupported {
            get {
                return ResourceManager.GetString("WhyCommand_Message_NonSDKStyleProjectsAreNotSupported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The package name to lookup in the dependency graph..
        /// </summary>
        internal static string WhyCommand_PackageArgument_Description {
            get {
                return ResourceManager.GetString("WhyCommand_PackageArgument_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A path to a project, solution file, or directory..
        /// </summary>
        internal static string WhyCommand_PathArgument_Description {
            get {
                return ResourceManager.GetString("WhyCommand_PathArgument_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The assets file &apos;{0}&apos; for project &apos;{1}&apos; does not contain a target for the specified input framework &apos;{2}&apos;..
        /// </summary>
        internal static string WhyCommand_Warning_AssetsFileDoesNotContainSpecifiedTarget {
            get {
                return ResourceManager.GetString("WhyCommand_Warning_AssetsFileDoesNotContainSpecifiedTarget", resourceCulture);
            }
        }
    }
}