//------------------------------------------------------------------------------
// <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.Packaging {
    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", "16.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.Packaging.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 An absolute URI is required..
        /// </summary>
        internal static string AnAbsoluteUriIsRequired {
            get {
                return ResourceManager.GetString("AnAbsoluteUriIsRequired", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The argument cannot be null or empty..
        /// </summary>
        internal static string ArgumentCannotBeNullOrEmpty {
            get {
                return ResourceManager.GetString("ArgumentCannotBeNullOrEmpty", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to author primary signature.
        /// </summary>
        internal static string AuthorPrimarySignatureFriendlyName {
            get {
                return ResourceManager.GetString("AuthorPrimarySignatureFriendlyName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A complete certificate chain could not be built for the signing certificate..
        /// </summary>
        internal static string CertificateChainBuildFailed {
            get {
                return ResourceManager.GetString("CertificateChainBuildFailed", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Certificate chain validation failed..
        /// </summary>
        internal static string CertificateChainValidationFailed {
            get {
                return ResourceManager.GetString("CertificateChainValidationFailed", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to {0} hash: {1}.
        /// </summary>
        internal static string CertUtilityCertificateHash {
            get {
                return ResourceManager.GetString("CertUtilityCertificateHash", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to SHA1 hash: {0}.
        /// </summary>
        internal static string CertUtilityCertificateHashSha1 {
            get {
                return ResourceManager.GetString("CertUtilityCertificateHashSha1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Issued by: {0}.
        /// </summary>
        internal static string CertUtilityCertificateIssuer {
            get {
                return ResourceManager.GetString("CertUtilityCertificateIssuer", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Subject Name: {0}.
        /// </summary>
        internal static string CertUtilityCertificateSubjectName {
            get {
                return ResourceManager.GetString("CertUtilityCertificateSubjectName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Valid from: {0} to {1}.
        /// </summary>
        internal static string CertUtilityCertificateValidity {
            get {
                return ResourceManager.GetString("CertUtilityCertificateValidity", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to ... {0} more..
        /// </summary>
        internal static string CertUtilityMultipleCertificatesFooter {
            get {
                return ResourceManager.GetString("CertUtilityMultipleCertificatesFooter", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The following certificates meet all given criteria:.
        /// </summary>
        internal static string CertUtilityMultipleCertificatesHeader {
            get {
                return ResourceManager.GetString("CertUtilityMultipleCertificatesHeader", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The commitment-type-indication attribute is invalid..
        /// </summary>
        internal static string CommitmentTypeIndicationAttributeInvalid {
            get {
                return ResourceManager.GetString("CommitmentTypeIndicationAttributeInvalid", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The commitment-type-indication attribute contains an invalid combination of values..
        /// </summary>
        internal static string CommitmentTypeIndicationAttributeInvalidCombination {
            get {
                return ResourceManager.GetString("CommitmentTypeIndicationAttributeInvalidCombination", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to There are two certificates with conflicting allowUntrustedRoot attributes in the computed settings. The allowUntrustedRoot attribute is going to be set to false. Certificate: {0}-{1}.
        /// </summary>
        internal static string ConflictingAllowUntrustedRoot {
            get {
                return ResourceManager.GetString("ConflictingAllowUntrustedRoot", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A list of trusted signers is required but none was found..
        /// </summary>
        internal static string DefaultError_EmptyAllowList {
            get {
                return ResourceManager.GetString("DefaultError_EmptyAllowList", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The package signature certificate fingerprint does not match any certificate fingerprint in the allow list..
        /// </summary>
        internal static string DefaultError_NoMatchInAllowList {
            get {
                return ResourceManager.GetString("DefaultError_NoMatchInAllowList", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unsupported targetFramework value &apos;{0}&apos;..
        /// </summary>
        internal static string Error_InvalidTargetFramework {
            get {
                return ResourceManager.GetString("Error_InvalidTargetFramework", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Error parsing nupkg metadata file {0} : {1}.
        /// </summary>
        internal static string Error_LoadingHashFile {
            get {
                return ResourceManager.GetString("Error_LoadingHashFile", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The package is missing the required nuspec file. .
        /// </summary>
        internal static string Error_MissingNuspecFile {
            get {
                return ResourceManager.GetString("Error_MissingNuspecFile", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to signatureValidationMode is set to require, so packages are allowed only if signed by trusted signers; however, no trusted signers were specified..
        /// </summary>
        internal static string Error_NoClientAllowList {
            get {
                return ResourceManager.GetString("Error_NoClientAllowList", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This package is signed but not by a trusted signer..
        /// </summary>
        internal static string Error_NoMatchingClientCertificate {
            get {
                return ResourceManager.GetString("Error_NoMatchingClientCertificate", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This package was not repository signed with a certificate listed by this repository..
        /// </summary>
        internal static string Error_NoMatchingRepositoryCertificate {
            get {
                return ResourceManager.GetString("Error_NoMatchingRepositoryCertificate", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This repository indicated that all its packages are repository signed; however, it listed no signing certificates..
        /// </summary>
        internal static string Error_NoRepoAllowList {
            get {
                return ResourceManager.GetString("Error_NoRepoAllowList", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The package signature file does not contain exactly one primary signature..
        /// </summary>
        internal static string Error_NotOnePrimarySignature {
            get {
                return ResourceManager.GetString("Error_NotOnePrimarySignature", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The package signature contains multiple repository countersignatures..
        /// </summary>
        internal static string Error_NotOneRepositoryCounterSignature {
            get {
                return ResourceManager.GetString("Error_NotOneRepositoryCounterSignature", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This repository indicated that all its packages are repository signed; however, this package is unsigned..
        /// </summary>
        internal static string Error_RepositorySettings_UnsignedPackage {
            get {
                return ResourceManager.GetString("Error_RepositorySettings_UnsignedPackage", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A repository primary signature must not have a repository countersignature..
        /// </summary>
        internal static string Error_RepositorySignatureMustNotHaveARepositoryCountersignature {
            get {
                return ResourceManager.GetString("Error_RepositorySignatureMustNotHaveARepositoryCountersignature", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to signatureValidationMode is set to require, so packages are allowed only if signed by trusted signers; however, this package is unsigned..
        /// </summary>
        internal static string Error_RequireMode_UnsignedPackage {
            get {
                return ResourceManager.GetString("Error_RequireMode_UnsignedPackage", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot target author signatures that are countersignatures..
        /// </summary>
        internal static string ErrorAuthorTargetCannotBeACountersignature {
            get {
                return ResourceManager.GetString("ErrorAuthorTargetCannotBeACountersignature", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Byte signature not found in package archive:  0x{0}.
        /// </summary>
        internal static string ErrorByteSignatureNotFound {
            get {
                return ResourceManager.GetString("ErrorByteSignatureNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Byte signature too big to seek in current stream position..
        /// </summary>
        internal static string ErrorByteSignatureTooBig {
            get {
                return ResourceManager.GetString("ErrorByteSignatureTooBig", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to There are duplicate packages: {0}.
        /// </summary>
        internal static string ErrorDuplicatePackages {
            get {
                return ResourceManager.GetString("ErrorDuplicatePackages", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid allowedVersions for package id &apos;{0}&apos;: &apos;{1}&apos;.
        /// </summary>
        internal static string ErrorInvalidAllowedVersions {
            get {
                return ResourceManager.GetString("ErrorInvalidAllowedVersions", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Certificate chain validation failed for an unspecified reason..
        /// </summary>
        internal static string ErrorInvalidCertificateChainUnspecifiedReason {
            get {
                return ResourceManager.GetString("ErrorInvalidCertificateChainUnspecifiedReason", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid minClientVersion: &apos;{0}&apos;.
        /// </summary>
        internal static string ErrorInvalidMinClientVersion {
            get {
                return ResourceManager.GetString("ErrorInvalidMinClientVersion", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid package archive..
        /// </summary>
        internal static string ErrorInvalidPackageArchive {
            get {
                return ResourceManager.GetString("ErrorInvalidPackageArchive", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid package version for package id &apos;{0}&apos;: &apos;{1}&apos;.
        /// </summary>
        internal static string ErrorInvalidPackageVersion {
            get {
                return ResourceManager.GetString("ErrorInvalidPackageVersion", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid package version for a dependency with id &apos;{0}&apos; in package &apos;{1}&apos;: &apos;{2}&apos;.
        /// </summary>
        internal static string ErrorInvalidPackageVersionForDependency {
            get {
                return ResourceManager.GetString("ErrorInvalidPackageVersionForDependency", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Manifest file not found at &apos;{0}&apos;.
        /// </summary>
        internal static string ErrorManifestFileNotFound {
            get {
                return ResourceManager.GetString("ErrorManifestFileNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Multiple timestamps are not accepted..
        /// </summary>
        internal static string ErrorMultipleTimestamps {
            get {
                return ResourceManager.GetString("ErrorMultipleTimestamps", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The signature should be timestamped to enable long-term signature validity after the certificate has expired..
        /// </summary>
        internal static string ErrorNoTimestamp {
            get {
                return ResourceManager.GetString("ErrorNoTimestamp", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Null or empty package id.
        /// </summary>
        internal static string ErrorNullOrEmptyPackageId {
            get {
                return ResourceManager.GetString("ErrorNullOrEmptyPackageId", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The package is not signed..
        /// </summary>
        internal static string ErrorPackageNotSigned {
            get {
                return ResourceManager.GetString("ErrorPackageNotSigned", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The package signature is invalid or cannot be verified on this platform..
        /// </summary>
        internal static string ErrorPackageSignatureInvalid {
            get {
                return ResourceManager.GetString("ErrorPackageSignatureInvalid", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to An unexpected error occurred while checking package entries..
        /// </summary>
        internal static string ErrorUnableCheckPackageEntries {
            get {
                return ResourceManager.GetString("ErrorUnableCheckPackageEntries", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unable to delete temporary file &apos;{0}&apos;. Error: &apos;{1}&apos;..
        /// </summary>
        internal static string ErrorUnableToDeleteFile {
            get {
                return ResourceManager.GetString("ErrorUnableToDeleteFile", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The package &apos;{0}&apos; contains an entry &apos;{1}&apos; which is unsafe for extraction..
        /// </summary>
        internal static string ErrorUnsafePackageEntry {
            get {
                return ResourceManager.GetString("ErrorUnsafePackageEntry", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Signed Zip64 packages are not supported..
        /// </summary>
        internal static string ErrorZip64NotSupported {
            get {
                return ResourceManager.GetString("ErrorZip64NotSupported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Exactly one {0} attribute is required..
        /// </summary>
        internal static string ExactlyOneAttributeRequired {
            get {
                return ResourceManager.GetString("ExactlyOneAttributeRequired", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The {0} attribute must have exactly one attribute value..
        /// </summary>
        internal static string ExactlyOneAttributeValueRequired {
            get {
                return ResourceManager.GetString("ExactlyOneAttributeValueRequired", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Package &apos;{0} {1}&apos; from source &apos;{2}&apos;: {3}.
        /// </summary>
        internal static string ExtractionLog_InformationPrefix {
            get {
                return ResourceManager.GetString("ExtractionLog_InformationPrefix", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Failed to update file time for {0}: {1}.
        /// </summary>
        internal static string FailedFileTime {
            get {
                return ResourceManager.GetString("FailedFileTime", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Fail to load packages.config as XML file. Please check it. .
        /// </summary>
        internal static string FailToLoadPackagesConfig {
            get {
                return ResourceManager.GetString("FailToLoadPackagesConfig", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Failed to write packages.config as XML file &apos;{0}&apos;. Error: &apos;{1}&apos;..
        /// </summary>
        internal static string FailToWritePackagesConfig {
            get {
                return ResourceManager.GetString("FailToWritePackagesConfig", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unable to find fallback package folder &apos;{0}&apos;..
        /// </summary>
        internal static string FallbackFolderNotFound {
            get {
                return ResourceManager.GetString("FallbackFolderNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to HTTP or HTTPS is required..
        /// </summary>
        internal static string HttpOrHttpsIsRequired {
            get {
                return ResourceManager.GetString("HttpOrHttpsIsRequired", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The argument is invalid..
        /// </summary>
        internal static string InvalidArgument {
            get {
                return ResourceManager.GetString("InvalidArgument", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid combination of arguments {0} and {1}..
        /// </summary>
        internal static string InvalidArgumentCombination {
            get {
                return ResourceManager.GetString("InvalidArgumentCombination", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The ASN.1 data is invalid..
        /// </summary>
        internal static string InvalidAsn1 {
            get {
                return ResourceManager.GetString("InvalidAsn1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The version string &apos;{0}&apos; is not supported by this toolset. The highest supported version is &apos;{1}&apos;. Either use a lower version or upgrade your toolset..
        /// </summary>
        internal static string InvalidLicenseExppressionVersion_VersionTooHigh {
            get {
                return ResourceManager.GetString("InvalidLicenseExppressionVersion_VersionTooHigh", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to {0} This validation error occurred in a &apos;{1}&apos; element..
        /// </summary>
        internal static string InvalidNuspecElement {
            get {
                return ResourceManager.GetString("InvalidNuspecElement", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The nuspec contains an invalid entry &apos;{0}&apos; in package &apos;{1}&apos; ..
        /// </summary>
        internal static string InvalidNuspecEntry {
            get {
                return ResourceManager.GetString("InvalidNuspecEntry", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The framework in the folder name of &apos;{0}&apos; in package &apos;{1}&apos; could not be parsed..
        /// </summary>
        internal static string InvalidPackageFrameworkFolderName {
            get {
                return ResourceManager.GetString("InvalidPackageFrameworkFolderName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The file is not a valid nupkg. File path: {0}.
        /// </summary>
        internal static string InvalidPackageNupkg {
            get {
                return ResourceManager.GetString("InvalidPackageNupkg", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Package {0} signature is invalid..
        /// </summary>
        internal static string InvalidPackageSignature {
            get {
                return ResourceManager.GetString("InvalidPackageSignature", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The package contains an invalid package signature file..
        /// </summary>
        internal static string InvalidPackageSignatureFile {
            get {
                return ResourceManager.GetString("InvalidPackageSignatureFile", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The package signature file entry is invalid. {0}.
        /// </summary>
        internal static string InvalidPackageSignatureFileEntry {
            get {
                return ResourceManager.GetString("InvalidPackageSignatureFileEntry", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The central directory header field &apos;{0}&apos; has an invalid value ({1})..
        /// </summary>
        internal static string InvalidPackageSignatureFileEntryCentralDirectoryHeader {
            get {
                return ResourceManager.GetString("InvalidPackageSignatureFileEntryCentralDirectoryHeader", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The local file header field &apos;{0}&apos; has an invalid value ({1})..
        /// </summary>
        internal static string InvalidPackageSignatureFileEntryLocalFileHeader {
            get {
                return ResourceManager.GetString("InvalidPackageSignatureFileEntryLocalFileHeader", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Nuspec file contains a package type with an invalid package version &apos;{0}&apos;..
        /// </summary>
        internal static string InvalidPackageTypeVersion {
            get {
                return ResourceManager.GetString("InvalidPackageTypeVersion", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The primary signature is invalid..
        /// </summary>
        internal static string InvalidPrimarySignature {
            get {
                return ResourceManager.GetString("InvalidPrimarySignature", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The repository countersignature is invalid..
        /// </summary>
        internal static string InvalidRepositoryCountersignature {
            get {
                return ResourceManager.GetString("InvalidRepositoryCountersignature", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The package signature content is invalid..
        /// </summary>
        internal static string InvalidSignatureContent {
            get {
                return ResourceManager.GetString("InvalidSignatureContent", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The timestamp signature is invalid..
        /// </summary>
        internal static string InvalidTimestampSignature {
            get {
                return ResourceManager.GetString("InvalidTimestampSignature", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The URL value is invalid..
        /// </summary>
        internal static string InvalidUrl {
            get {
                return ResourceManager.GetString("InvalidUrl", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Installed {0} {1} from {2} with content hash {3}..
        /// </summary>
        internal static string Log_InstalledPackage {
            get {
                return ResourceManager.GetString("Log_InstalledPackage", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Path: {0}.
        /// </summary>
        internal static string Message_Path {
            get {
                return ResourceManager.GetString("Message_Path", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to MinClientVersion already exists in packages.config.
        /// </summary>
        internal static string MinClientVersionAlreadyExist {
            get {
                return ResourceManager.GetString("MinClientVersionAlreadyExist", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Nuspec file does not contain the &apos;{0}&apos; node..
        /// </summary>
        internal static string MissingMetadataNode {
            get {
                return ResourceManager.GetString("MissingMetadataNode", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Nuspec file contains a package type that is missing the name attribute..
        /// </summary>
        internal static string MissingPackageTypeName {
            get {
                return ResourceManager.GetString("MissingPackageTypeName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Some dependency group TFMs are missing a platform version: {0}.
        /// </summary>
        internal static string MissingTargetPlatformVersionsFromDependencyGroups {
            get {
                return ResourceManager.GetString("MissingTargetPlatformVersionsFromDependencyGroups", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Some reference assembly group TFMs are missing a platform version: {0}.
        /// </summary>
        internal static string MissingTargetPlatformVersionsFromFrameworkAssemblyGroups {
            get {
                return ResourceManager.GetString("MissingTargetPlatformVersionsFromFrameworkAssemblyGroups", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Some framework assembly reference TFMs are missing a platform version: {0}.
        /// </summary>
        internal static string MissingTargetPlatformVersionsFromFrameworkAssemblyReferences {
            get {
                return ResourceManager.GetString("MissingTargetPlatformVersionsFromFrameworkAssemblyReferences", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Some included files are included under TFMs which are missing a platform version: {0}.
        /// </summary>
        internal static string MissingTargetPlatformVersionsFromIncludedFiles {
            get {
                return ResourceManager.GetString("MissingTargetPlatformVersionsFromIncludedFiles", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Some reference group TFMs are missing a platform version: {0}.
        /// </summary>
        internal static string MissingTargetPlatformVersionsFromReferenceGroups {
            get {
                return ResourceManager.GetString("MissingTargetPlatformVersionsFromReferenceGroups", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Multiple {0} attributes are not allowed..
        /// </summary>
        internal static string MultipleAttributesDisallowed {
            get {
                return ResourceManager.GetString("MultipleAttributesDisallowed", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Package contains multiple nuspec files..
        /// </summary>
        internal static string MultipleNuspecFiles {
            get {
                return ResourceManager.GetString("MultipleNuspecFiles", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The package contains multiple package signature files..
        /// </summary>
        internal static string MultiplePackageSignatureFiles {
            get {
                return ResourceManager.GetString("MultiplePackageSignatureFiles", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Nuspec file contains multiple package types. Zero or one package type nodes are allowed..
        /// </summary>
        internal static string MultiplePackageTypes {
            get {
                return ResourceManager.GetString("MultiplePackageTypes", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;{0}&apos; must contain an absolute path &apos;{1}&apos;..
        /// </summary>
        internal static string MustContainAbsolutePath {
            get {
                return ResourceManager.GetString("MustContainAbsolutePath", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The package does not contain a valid package signature file..
        /// </summary>
        internal static string NoPackageSignatureFile {
            get {
                return ResourceManager.GetString("NoPackageSignatureFile", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Verification settings require a repository countersignature, but the package does not have a repository countersignature..
        /// </summary>
        internal static string NoRepositoryCountersignature {
            get {
                return ResourceManager.GetString("NoRepositoryCountersignature", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The license expression &apos;{0}&apos; cannot be parsed succesfully..
        /// </summary>
        internal static string NuGetLicense_InvalidLicenseExpression {
            get {
                return ResourceManager.GetString("NuGetLicense_InvalidLicenseExpression", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The license version string &apos;{0}&apos;  is invalid..
        /// </summary>
        internal static string NuGetLicense_InvalidLicenseExpressionVersion {
            get {
                return ResourceManager.GetString("NuGetLicense_InvalidLicenseExpressionVersion", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unrecognized license type &apos;{0}&apos;.
        /// </summary>
        internal static string NuGetLicense_InvalidLicenseType {
            get {
                return ResourceManager.GetString("NuGetLicense_InvalidLicenseType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The license element value is empty. This is likely due to an authoring error. .
        /// </summary>
        internal static string NuGetLicense_LicenseElementMissingValue {
            get {
                return ResourceManager.GetString("NuGetLicense_LicenseElementMissingValue", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The license version string &apos;{0}&apos; is higher than the one supported by this toolset &apos;{1}&apos;..
        /// </summary>
        internal static string NuGetLicense_LicenseExpressionVersionTooHigh {
            get {
                return ResourceManager.GetString("NuGetLicense_LicenseExpressionVersionTooHigh", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The element &apos;license&apos; cannot be empty. .
        /// </summary>
        internal static string NuGetLicense_MissingRequiredValue {
            get {
                return ResourceManager.GetString("NuGetLicense_MissingRequiredValue", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The identifier &apos;{0}&apos; is deprecated..
        /// </summary>
        internal static string NuGetLicenseExpression_DeprecatedIdentifier {
            get {
                return ResourceManager.GetString("NuGetLicenseExpression_DeprecatedIdentifier", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The identifier &apos;{0}&apos; is a license. It cannot be used as an exception..
        /// </summary>
        internal static string NuGetLicenseExpression_ExceptionIdentifierIsLicense {
            get {
                return ResourceManager.GetString("NuGetLicenseExpression_ExceptionIdentifierIsLicense", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &apos;UNLICENSED&apos; license identifier cannot be combined with the &apos;+&apos; operator..
        /// </summary>
        internal static string NuGetLicenseExpression_IllegalUnlicensedOperator {
            get {
                return ResourceManager.GetString("NuGetLicenseExpression_IllegalUnlicensedOperator", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The license expression &apos;{0}&apos; contains invalid characters..
        /// </summary>
        internal static string NuGetLicenseExpression_InvalidCharacters {
            get {
                return ResourceManager.GetString("NuGetLicenseExpression_InvalidCharacters", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The identifier &apos;{0}&apos; is not a standard exception..
        /// </summary>
        internal static string NuGetLicenseExpression_InvalidExceptionIdentifier {
            get {
                return ResourceManager.GetString("NuGetLicenseExpression_InvalidExceptionIdentifier", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The license expression is invalid..
        /// </summary>
        internal static string NuGetLicenseExpression_InvalidExpression {
            get {
                return ResourceManager.GetString("NuGetLicenseExpression_InvalidExpression", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid element &apos;{0}&apos;..
        /// </summary>
        internal static string NuGetLicenseExpression_InvalidToken {
            get {
                return ResourceManager.GetString("NuGetLicenseExpression_InvalidToken", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The identifier &apos;{0}&apos; is an exception. It cannot be used as a license..
        /// </summary>
        internal static string NuGetLicenseExpression_LicenseIdentifierIsException {
            get {
                return ResourceManager.GetString("NuGetLicenseExpression_LicenseIdentifierIsException", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The license identifier &apos;{0}&apos; contains invalid characters..
        /// </summary>
        internal static string NuGetLicenseExpression_LicenseInvalidCharacters {
            get {
                return ResourceManager.GetString("NuGetLicenseExpression_LicenseInvalidCharacters", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Mismatched parentheses in the expression..
        /// </summary>
        internal static string NuGetLicenseExpression_MismatchedParentheses {
            get {
                return ResourceManager.GetString("NuGetLicenseExpression_MismatchedParentheses", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The license identifier(s) &apos;{0}&apos; is(are) not recognized by the current toolset..
        /// </summary>
        internal static string NuGetLicenseExpression_NonStandardIdentifier {
            get {
                return ResourceManager.GetString("NuGetLicenseExpression_NonStandardIdentifier", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unexpected license identifier &apos;{0}&apos;. The identifier is not allowed in this context..
        /// </summary>
        internal static string NuGetLicenseExpression_UnexpectedIdentifier {
            get {
                return ResourceManager.GetString("NuGetLicenseExpression_UnexpectedIdentifier", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The owner has marked this package as &apos;UNLICENSED&apos;. This means that there is no license that allows this package to be used outside of the copyright owner..
        /// </summary>
        internal static string NuGetLicenseExpression_UnlicensedPackageWarning {
            get {
                return ResourceManager.GetString("NuGetLicenseExpression_UnlicensedPackageWarning", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to nuget-package-owners: {0}.
        /// </summary>
        internal static string NuGetPackageOwners {
            get {
                return ResourceManager.GetString("NuGetPackageOwners", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The nuget-package-owners attribute is invalid..
        /// </summary>
        internal static string NuGetPackageOwnersInvalid {
            get {
                return ResourceManager.GetString("NuGetPackageOwnersInvalid", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to One or more package owner values are invalid..
        /// </summary>
        internal static string NuGetPackageOwnersInvalidValue {
            get {
                return ResourceManager.GetString("NuGetPackageOwnersInvalidValue", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to nuget-v3-service-index-url: {0}.
        /// </summary>
        internal static string NuGetV3ServiceIndexUrl {
            get {
                return ResourceManager.GetString("NuGetV3ServiceIndexUrl", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The nuget-v3-service-index-url attribute is invalid..
        /// </summary>
        internal static string NuGetV3ServiceIndexUrlInvalid {
            get {
                return ResourceManager.GetString("NuGetV3ServiceIndexUrlInvalid", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The nuget-v3-service-index-url attribute value is invalid..
        /// </summary>
        internal static string NuGetV3ServiceIndexUrlInvalidValue {
            get {
                return ResourceManager.GetString("NuGetV3ServiceIndexUrlInvalidValue", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Package entry already exists in packages.config. Id: {0}.
        /// </summary>
        internal static string PackageEntryAlreadyExist {
            get {
                return ResourceManager.GetString("PackageEntryAlreadyExist", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Package entry does not exists in packages.config. Id: {0}, Version: {1}.
        /// </summary>
        internal static string PackageEntryNotExist {
            get {
                return ResourceManager.GetString("PackageEntryNotExist", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &apos;{0}&apos; package requires NuGet client version &apos;{1}&apos; or above, but the current NuGet version is &apos;{2}&apos;. To upgrade NuGet, please go to https://docs.nuget.org/consume/installing-nuget.
        /// </summary>
        internal static string PackageMinVersionNotSatisfied {
            get {
                return ResourceManager.GetString("PackageMinVersionNotSatisfied", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to PackageSignatureVerificationLog: PackageIdentity: {0} Source: {1} PackageSignatureValidity: {2}.
        /// </summary>
        internal static string PackageSignatureVerificationLog {
            get {
                return ResourceManager.GetString("PackageSignatureVerificationLog", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Packages node does not exists in packages.config at {0}..
        /// </summary>
        internal static string PackagesNodeNotExist {
            get {
                return ResourceManager.GetString("PackagesNodeNotExist", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Package stream should be seekable.
        /// </summary>
        internal static string PackageStreamShouldBeSeekable {
            get {
                return ResourceManager.GetString("PackageStreamShouldBeSeekable", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to primary signature.
        /// </summary>
        internal static string PrimarySignatureFriendlyName {
            get {
                return ResourceManager.GetString("PrimarySignatureFriendlyName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The primary signature does not have a timestamp..
        /// </summary>
        internal static string PrimarySignatureHasNoTimestamp {
            get {
                return ResourceManager.GetString("PrimarySignatureHasNoTimestamp", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;{0}&apos; cannot be null..
        /// </summary>
        internal static string PropertyCannotBeNull {
            get {
                return ResourceManager.GetString("PropertyCannotBeNull", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Arguments {0} and {1} were out of bounds for the array..
        /// </summary>
        internal static string RangeOutOfBoundsForArray {
            get {
                return ResourceManager.GetString("RangeOutOfBoundsForArray", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to repository countersignature.
        /// </summary>
        internal static string RepositoryCountersignatureFriendlyName {
            get {
                return ResourceManager.GetString("RepositoryCountersignatureFriendlyName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The repository countersignature does not have a signing certificate..
        /// </summary>
        internal static string RepositoryCountersignatureHasNoCertificate {
            get {
                return ResourceManager.GetString("RepositoryCountersignatureHasNoCertificate", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The repository countersignature does not have a timestamp..
        /// </summary>
        internal static string RepositoryCountersignatureHasNoTimestamp {
            get {
                return ResourceManager.GetString("RepositoryCountersignatureHasNoTimestamp", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to repository primary signature.
        /// </summary>
        internal static string RepositoryPrimarySignatureFriendlyName {
            get {
                return ResourceManager.GetString("RepositoryPrimarySignatureFriendlyName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Package signature contains an invalid attribute: {0}.
        /// </summary>
        internal static string SignatureContainsInvalidAttribute {
            get {
                return ResourceManager.GetString("SignatureContainsInvalidAttribute", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Signature hash OID found: {0}.
        /// </summary>
        internal static string SignatureDebug_HashOidFound {
            get {
                return ResourceManager.GetString("SignatureDebug_HashOidFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The package hash uses an unsupported hash algorithm..
        /// </summary>
        internal static string SignatureFailureInvalidHashAlgorithmOid {
            get {
                return ResourceManager.GetString("SignatureFailureInvalidHashAlgorithmOid", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to signature.
        /// </summary>
        internal static string SignatureFriendlyName {
            get {
                return ResourceManager.GetString("SignatureFriendlyName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Signature Hash Algorithm: {0}.
        /// </summary>
        internal static string SignatureHashAlgorithm {
            get {
                return ResourceManager.GetString("SignatureHashAlgorithm", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid general purpose bit flags. Expected &apos;{0}&apos;, actual &apos;{1}&apos;..
        /// </summary>
        internal static string SignatureInvalidGeneralPurposeBits {
            get {
                return ResourceManager.GetString("SignatureInvalidGeneralPurposeBits", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The package integrity check failed..
        /// </summary>
        internal static string SignaturePackageIntegrityFailure {
            get {
                return ResourceManager.GetString("SignaturePackageIntegrityFailure", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Signature type: {0}.
        /// </summary>
        internal static string SignatureType {
            get {
                return ResourceManager.GetString("SignatureType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The package already contains a signature. Please remove the existing signature before adding a new signature..
        /// </summary>
        internal static string SignedPackageAlreadySigned {
            get {
                return ResourceManager.GetString("SignedPackageAlreadySigned", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Package stream read position cannot be longer than the length of the stream..
        /// </summary>
        internal static string SignedPackageArchiveIOExtraRead {
            get {
                return ResourceManager.GetString("SignedPackageArchiveIOExtraRead", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Package stream read position cannot be before the current position in the stream..
        /// </summary>
        internal static string SignedPackageArchiveIOInvalidRead {
            get {
                return ResourceManager.GetString("SignedPackageArchiveIOInvalidRead", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The package is not signed. Unable to remove signature from an unsigned package..
        /// </summary>
        internal static string SignedPackageNotSignedOnRemove {
            get {
                return ResourceManager.GetString("SignedPackageNotSignedOnRemove", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The package is not signed. Unable to verify signature from an unsigned package..
        /// </summary>
        internal static string SignedPackageNotSignedOnVerify {
            get {
                return ResourceManager.GetString("SignedPackageNotSignedOnVerify", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The package already contains a repository countersignature. Please remove the existing signature before adding a new repository countersignature..
        /// </summary>
        internal static string SignedPackagePackageAlreadyCountersigned {
            get {
                return ResourceManager.GetString("SignedPackagePackageAlreadyCountersigned", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The package was not opened correctly to perform signature operations. Please use a Stream-based constructor to have access to signature attributes of the package..
        /// </summary>
        internal static string SignedPackageUnableToAccessSignature {
            get {
                return ResourceManager.GetString("SignedPackageUnableToAccessSignature", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The timestamp certificate does not meet a minimum public key length requirement..
        /// </summary>
        internal static string SignError_TimestampCertificateFailsPublicKeyLengthRequirement {
            get {
                return ResourceManager.GetString("SignError_TimestampCertificateFailsPublicKeyLengthRequirement", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The timestamp&apos;s generalized time is outside the timestamping certificate&apos;s validity period..
        /// </summary>
        internal static string SignError_TimestampGeneralizedTimeInvalid {
            get {
                return ResourceManager.GetString("SignError_TimestampGeneralizedTimeInvalid", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The timestamp integrity check failed..
        /// </summary>
        internal static string SignError_TimestampIntegrityCheckFailed {
            get {
                return ResourceManager.GetString("SignError_TimestampIntegrityCheckFailed", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The timestamp does not have a signing certificate..
        /// </summary>
        internal static string SignError_TimestampNoCertificate {
            get {
                return ResourceManager.GetString("SignError_TimestampNoCertificate", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The timestamp signing certificate is not yet valid..
        /// </summary>
        internal static string SignError_TimestampNotYetValid {
            get {
                return ResourceManager.GetString("SignError_TimestampNotYetValid", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The timestamp signature validation failed..
        /// </summary>
        internal static string SignError_TimestampSignatureValidationFailed {
            get {
                return ResourceManager.GetString("SignError_TimestampSignatureValidationFailed", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The following certificate cannot be used for package signing as the private key provider is unsupported:.
        /// </summary>
        internal static string SignFailureCertificateInvalidProviderType {
            get {
                return ResourceManager.GetString("SignFailureCertificateInvalidProviderType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to {0} and {1} should be different. Package signing cannot be done in place..
        /// </summary>
        internal static string SigningCannotBeDoneInPlace {
            get {
                return ResourceManager.GetString("SigningCannotBeDoneInPlace", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The signing-certificate attribute is not allowed..
        /// </summary>
        internal static string SigningCertificateAttributeMustNotBePresent {
            get {
                return ResourceManager.GetString("SigningCertificateAttributeMustNotBePresent", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A certificate referenced by the signing-certificate attribute could not be found..
        /// </summary>
        internal static string SigningCertificateCertificateNotFound {
            get {
                return ResourceManager.GetString("SigningCertificateCertificateNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The signing-certificate attribute is invalid..
        /// </summary>
        internal static string SigningCertificateInvalid {
            get {
                return ResourceManager.GetString("SigningCertificateInvalid", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Either the signing-certificate or signing-certificate-v2 attribute must be present..
        /// </summary>
        internal static string SigningCertificateV1OrV2AttributeMustBePresent {
            get {
                return ResourceManager.GetString("SigningCertificateV1OrV2AttributeMustBePresent", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A certificate referenced by the signing-certificate-v2 attribute could not be found..
        /// </summary>
        internal static string SigningCertificateV2CertificateNotFound {
            get {
                return ResourceManager.GetString("SigningCertificateV2CertificateNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The signing-certificate-v2 attribute is invalid..
        /// </summary>
        internal static string SigningCertificateV2Invalid {
            get {
                return ResourceManager.GetString("SigningCertificateV2Invalid", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The signing-certificate-v2 attribute does not have exactly one attribute value..
        /// </summary>
        internal static string SigningCertificateV2NotExactlyOneAttributeValue {
            get {
                return ResourceManager.GetString("SigningCertificateV2NotExactlyOneAttributeValue", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The signing-certificate-v2 attribute uses an unsupported hash algorithm..
        /// </summary>
        internal static string SigningCertificateV2UnsupportedHashAlgorithm {
            get {
                return ResourceManager.GetString("SigningCertificateV2UnsupportedHashAlgorithm", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The signing certificate does not meet a minimum public key length requirement..
        /// </summary>
        internal static string SigningError_CertificateFailsPublicKeyLengthRequirement {
            get {
                return ResourceManager.GetString("SigningError_CertificateFailsPublicKeyLengthRequirement", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The lifetime signing EKU in the signing certificate is not supported..
        /// </summary>
        internal static string SigningError_CertificateHasLifetimeSigningEKU {
            get {
                return ResourceManager.GetString("SigningError_CertificateHasLifetimeSigningEKU", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The signing certificate has an unsupported signature algorithm..
        /// </summary>
        internal static string SigningError_CertificateHasUnsupportedSignatureAlgorithm {
            get {
                return ResourceManager.GetString("SigningError_CertificateHasUnsupportedSignatureAlgorithm", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The signing certificate is not yet valid..
        /// </summary>
        internal static string SigningError_NotYetValid {
            get {
                return ResourceManager.GetString("SigningError_NotYetValid", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The package cannot be signed as it would require the Zip64 format..
        /// </summary>
        internal static string SigningWouldRequireZip64 {
            get {
                return ResourceManager.GetString("SigningWouldRequireZip64", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The stream must be readable..
        /// </summary>
        internal static string StreamMustBeReadable {
            get {
                return ResourceManager.GetString("StreamMustBeReadable", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The stream must be seekable..
        /// </summary>
        internal static string StreamMustBeSeekable {
            get {
                return ResourceManager.GetString("StreamMustBeSeekable", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to String argument &apos;{0}&apos; cannot be null or empty.
        /// </summary>
        internal static string StringCannotBeNullOrEmpty {
            get {
                return ResourceManager.GetString("StringCannotBeNullOrEmpty", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The timestamp service&apos;s certificate has a valid time in the future: {0}.
        /// </summary>
        internal static string TimestampCertificateInvalid {
            get {
                return ResourceManager.GetString("TimestampCertificateInvalid", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The timestamp certificate has an unsupported signature algorithm ({0}). The following algorithms are supported: {1}..
        /// </summary>
        internal static string TimestampCertificateUnsupportedSignatureAlgorithm {
            get {
                return ResourceManager.GetString("TimestampCertificateUnsupportedSignatureAlgorithm", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The timestamper URL &apos;{0}&apos; has an invalid URI scheme. The supported schemes are &apos;{1}&apos; and &apos;{2}&apos;..
        /// </summary>
        internal static string TimestampFailureInvalidHttpScheme {
            get {
                return ResourceManager.GetString("TimestampFailureInvalidHttpScheme", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The timestamp response is invalid.  Nonces did not match..
        /// </summary>
        internal static string TimestampFailureNonceMismatch {
            get {
                return ResourceManager.GetString("TimestampFailureNonceMismatch", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Timestamp service&apos;s response does not meet the NuGet package signature specification: &apos;{0}&apos;..
        /// </summary>
        internal static string TimestampResponseExceptionGeneral {
            get {
                return ResourceManager.GetString("TimestampResponseExceptionGeneral", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The timestamp service responded with HTTP status code &apos;{0}&apos; (&apos;{1}&apos;)..
        /// </summary>
        internal static string TimestampServiceRespondedError {
            get {
                return ResourceManager.GetString("TimestampServiceRespondedError", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The timestamp signature has an unsupported digest algorithm ({0}). The following algorithms are supported: {1}..
        /// </summary>
        internal static string TimestampSignatureUnsupportedDigestAlgorithm {
            get {
                return ResourceManager.GetString("TimestampSignatureUnsupportedDigestAlgorithm", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Timestamp: {0}.
        /// </summary>
        internal static string TimestampValue {
            get {
                return ResourceManager.GetString("TimestampValue", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to An error occurred while updating packages.config. The file was closed before the entry could be added..
        /// </summary>
        internal static string UnableToAddEntry {
            get {
                return ResourceManager.GetString("UnableToAddEntry", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unable to parse the current NuGet client version..
        /// </summary>
        internal static string UnableToParseClientVersion {
            get {
                return ResourceManager.GetString("UnableToParseClientVersion", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Package hash information could not be read from the package signature..
        /// </summary>
        internal static string UnableToReadPackageHashInformation {
            get {
                return ResourceManager.GetString("UnableToReadPackageHashInformation", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to An unexpected error occurred while verifying a package signature..
        /// </summary>
        internal static string UnexpectedPackageSignatureVerificationError {
            get {
                return ResourceManager.GetString("UnexpectedPackageSignatureVerificationError", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The enum value &apos;{0}&apos; is unrecognized..
        /// </summary>
        internal static string UnrecognizedEnumValue {
            get {
                return ResourceManager.GetString("UnrecognizedEnumValue", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The primary signature and repository countersignature are unrelated..
        /// </summary>
        internal static string UnrelatedSignatures {
            get {
                return ResourceManager.GetString("UnrelatedSignatures", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The ASN.1 data is unsupported..
        /// </summary>
        internal static string UnsupportedAsn1 {
            get {
                return ResourceManager.GetString("UnsupportedAsn1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The package signature format version is not supported. Updating your client may solve this problem..
        /// </summary>
        internal static string UnsupportedSignatureFormatVersion {
            get {
                return ResourceManager.GetString("UnsupportedSignatureFormatVersion", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Verifying the {0} with certificate: {1}.
        /// </summary>
        internal static string VerificationCertDisplay {
            get {
                return ResourceManager.GetString("VerificationCertDisplay", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Verifying {0}&apos;s timestamp with timestamping service certificate: {1}.
        /// </summary>
        internal static string VerificationTimestamperCertDisplay {
            get {
                return ResourceManager.GetString("VerificationTimestamperCertDisplay", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The {0} does not have a signing certificate..
        /// </summary>
        internal static string Verify_ErrorNoCertificate {
            get {
                return ResourceManager.GetString("Verify_ErrorNoCertificate", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The revocation function was unable to check revocation because the certificate is not available in the cached certificate revocation list and NUGET_CERT_REVOCATION_MODE environment variable has been set to offline. For more information, visit https://aka.ms/certificateRevocationMode..
        /// </summary>
        internal static string VerifyCertTrustOfflineWhileRevocationModeOffline {
            get {
                return ResourceManager.GetString("VerifyCertTrustOfflineWhileRevocationModeOffline", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The revocation function was unable to check revocation because the revocation server could not be reached. For more information, visit https://aka.ms/certificateRevocationMode..
        /// </summary>
        internal static string VerifyCertTrustOfflineWhileRevocationModeOnline {
            get {
                return ResourceManager.GetString("VerifyCertTrustOfflineWhileRevocationModeOnline", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The {0} found a chain building issue: {1}.
        /// </summary>
        internal static string VerifyChainBuildingIssue {
            get {
                return ResourceManager.GetString("VerifyChainBuildingIssue", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The {0}&apos;s certificate does not meet a minimum public key length requirement..
        /// </summary>
        internal static string VerifyError_CertificateFailsPublicKeyLengthRequirement {
            get {
                return ResourceManager.GetString("VerifyError_CertificateFailsPublicKeyLengthRequirement", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The lifetime signing EKU in the {0}&apos;s certificate is not supported..
        /// </summary>
        internal static string VerifyError_CertificateHasLifetimeSigningEKU {
            get {
                return ResourceManager.GetString("VerifyError_CertificateHasLifetimeSigningEKU", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The {0}&apos;s certificate has an unsupported signature algorithm..
        /// </summary>
        internal static string VerifyError_CertificateHasUnsupportedSignatureAlgorithm {
            get {
                return ResourceManager.GetString("VerifyError_CertificateHasUnsupportedSignatureAlgorithm", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The {0}&apos;s certificate is not yet valid..
        /// </summary>
        internal static string VerifyError_CertificateNotYetValid {
            get {
                return ResourceManager.GetString("VerifyError_CertificateNotYetValid", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The {0}&apos;s certificate chain validation failed with error(s): {1}.
        /// </summary>
        internal static string VerifyError_InvalidCertificateChain {
            get {
                return ResourceManager.GetString("VerifyError_InvalidCertificateChain", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The {0} validity period has expired..
        /// </summary>
        internal static string VerifyError_SignatureNotTimeValid {
            get {
                return ResourceManager.GetString("VerifyError_SignatureNotTimeValid", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The {0} validation failed..
        /// </summary>
        internal static string VerifyError_SignatureVerificationFailed {
            get {
                return ResourceManager.GetString("VerifyError_SignatureVerificationFailed", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The {0}&apos;s timestamp certificate does not meet a minimum public key length requirement..
        /// </summary>
        internal static string VerifyError_TimestampCertificateFailsPublicKeyLengthRequirement {
            get {
                return ResourceManager.GetString("VerifyError_TimestampCertificateFailsPublicKeyLengthRequirement", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The {0}&apos;s timestamp&apos;s generalized time is outside the timestamping certificate&apos;s validity period..
        /// </summary>
        internal static string VerifyError_TimestampGeneralizedTimeInvalid {
            get {
                return ResourceManager.GetString("VerifyError_TimestampGeneralizedTimeInvalid", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The {0}&apos;s timestamp integrity check failed..
        /// </summary>
        internal static string VerifyError_TimestampIntegrityCheckFailed {
            get {
                return ResourceManager.GetString("VerifyError_TimestampIntegrityCheckFailed", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The {0} contains an invalid timestamp..
        /// </summary>
        internal static string VerifyError_TimestampInvalid {
            get {
                return ResourceManager.GetString("VerifyError_TimestampInvalid", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The {0} timestamp&apos;s message imprint uses an unsupported hash algorithm..
        /// </summary>
        internal static string VerifyError_TimestampMessageImprintUnsupportedHashAlgorithm {
            get {
                return ResourceManager.GetString("VerifyError_TimestampMessageImprintUnsupportedHashAlgorithm", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The {0}&apos;s timestamp does not have a signing certificate..
        /// </summary>
        internal static string VerifyError_TimestampNoCertificate {
            get {
                return ResourceManager.GetString("VerifyError_TimestampNoCertificate", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The {0}&apos;s timestamp signing certificate is not yet valid..
        /// </summary>
        internal static string VerifyError_TimestampNotYetValid {
            get {
                return ResourceManager.GetString("VerifyError_TimestampNotYetValid", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The {0}&apos;s timestamp signature has an unsupported digest algorithm..
        /// </summary>
        internal static string VerifyError_TimestampSignatureUnsupportedDigestAlgorithm {
            get {
                return ResourceManager.GetString("VerifyError_TimestampSignatureUnsupportedDigestAlgorithm", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The {0}&apos;s timestamp signature validation failed..
        /// </summary>
        internal static string VerifyError_TimestampSignatureValidationFailed {
            get {
                return ResourceManager.GetString("VerifyError_TimestampSignatureValidationFailed", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The {0}&apos;s timestamp certificate has an unsupported signature algorithm..
        /// </summary>
        internal static string VerifyError_TimestampUnsupportedSignatureAlgorithm {
            get {
                return ResourceManager.GetString("VerifyError_TimestampUnsupportedSignatureAlgorithm", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The {0}&apos;s timestamp found a chain building issue: {1}.
        /// </summary>
        internal static string VerifyError_TimestampVerifyChainBuildingIssue {
            get {
                return ResourceManager.GetString("VerifyError_TimestampVerifyChainBuildingIssue", resourceCulture);
            }
        }
    }
}
