path: root/Duplicati/Library/Main/Strings/Options.Designer.cs

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

namespace Duplicati.Library.Main.Strings {
    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", "4.0.0.0")]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    internal class Options {
        
        private static global::System.Resources.ResourceManager resourceMan;
        
        private static global::System.Globalization.CultureInfo resourceCulture;
        
        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal Options() {
        }
        
        /// <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("Duplicati.Library.Main.Strings.Options", typeof(Options).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 Use this option to continue even if some source entries are missing..
        /// </summary>
        internal static string AllowmissingsourceLong {
            get {
                return ResourceManager.GetString("AllowmissingsourceLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Ignore missing source elements.
        /// </summary>
        internal static string AllowmissingsourceShort {
            get {
                return ResourceManager.GetString("AllowmissingsourceShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Allow system to enter sleep power modes for inactivity during backup/restore operations (Windows only).
        /// </summary>
        internal static string AllowsleepShort {
            get {
                return ResourceManager.GetString("AllowsleepShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to When searching for files, only the most recent backup is searched. Use this option to show all previous versions too..
        /// </summary>
        internal static string AllversionsLong {
            get {
                return ResourceManager.GetString("AllversionsLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Show all versions.
        /// </summary>
        internal static string AllversionsShort {
            get {
                return ResourceManager.GetString("AllversionsShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The pre-generated volumes will be placed into the temporary folder by default, this option can set a different folder for placing the temporary volumes, despite the name, this also works for synchronous runs.
        /// </summary>
        internal static string AsynchronousuploadfolderLong {
            get {
                return ResourceManager.GetString("AsynchronousuploadfolderLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The path where ready volumes are placed until uploaded.
        /// </summary>
        internal static string AsynchronousuploadfolderShort {
            get {
                return ResourceManager.GetString("AsynchronousuploadfolderShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to When performing asynchronous uploads, Duplicati will create volumes that can be uploaded. To prevent Duplicati from generating too many volumes, this option limits the number of pending uploads. Set to zero to disable the limit.
        /// </summary>
        internal static string AsynchronousuploadlimitLong {
            get {
                return ResourceManager.GetString("AsynchronousuploadlimitLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The number of volumes to create ahead of time.
        /// </summary>
        internal static string AsynchronousuploadlimitShort {
            get {
                return ResourceManager.GetString("AsynchronousuploadlimitShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to If a backup is interrupted there will likely be partial files present on the backend. Using this flag, Duplicati will automatically remove such files when encountered..
        /// </summary>
        internal static string AutocleanupLong {
            get {
                return ResourceManager.GetString("AutocleanupLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A flag indicating that Duplicati should remove unused files.
        /// </summary>
        internal static string AutocleanupShort {
            get {
                return ResourceManager.GetString("AutocleanupShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A display name that is attached to this backup. Can be used to identify the backup when sending mail or running scripts..
        /// </summary>
        internal static string BackupnameLong {
            get {
                return ResourceManager.GetString("BackupnameLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name of the backup.
        /// </summary>
        internal static string BackupnameShort {
            get {
                return ResourceManager.GetString("BackupnameShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This is a very advanced option! This option can be used to select a block hash algorithm with smaller or larger hash size, for performance or storage space reasons..
        /// </summary>
        internal static string BlockhashalgorithmLong {
            get {
                return ResourceManager.GetString("BlockhashalgorithmLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The hash algorithm used on blocks.
        /// </summary>
        internal static string BlockhashalgorithmShort {
            get {
                return ResourceManager.GetString("BlockhashalgorithmShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A fragment of memory is used to reduce database lookups. You should not change this value unless you get warnings in the log..
        /// </summary>
        internal static string BlockhashlookupsizeLong {
            get {
                return ResourceManager.GetString("BlockhashlookupsizeLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Memory used by the block hash.
        /// </summary>
        internal static string BlockhashlookupsizeShort {
            get {
                return ResourceManager.GetString("BlockhashlookupsizeShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The blocksize determines how files are fragmented. Choosing a large value will cause a larger overhead on file changes, choosing a small value will cause a large overhead on storage of file lists. Note that the value cannot be changed after remote files are created..
        /// </summary>
        internal static string BlocksizeLong {
            get {
                return ResourceManager.GetString("BlocksizeLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Blocksize used in hashing.
        /// </summary>
        internal static string BlocksizeShort {
            get {
                return ResourceManager.GetString("BlocksizeShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This option can be used to limit the scan to only files that are known to have changed. This is usually only activated in combination with a filesystem watcher that keeps track of file changes..
        /// </summary>
        internal static string ChangedfilesLong {
            get {
                return ResourceManager.GetString("ChangedfilesLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to List of files to examine for changes.
        /// </summary>
        internal static string ChangedfilesShort {
            get {
                return ResourceManager.GetString("ChangedfilesShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This property can be used to point to a text file where each line contains a file extension that indicates a non-compressible file. Files that have an extension found in the file will not be compressed, but simply stored in the archive. The file format ignores any lines that do not start with a period, and considers a space to indicate the end of the extension. A default file is supplied, that also serves as an example. The default file is placed in {0}..
        /// </summary>
        internal static string CompressionextensionfileLong {
            get {
                return ResourceManager.GetString("CompressionextensionfileLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Manage non-compressible file extensions.
        /// </summary>
        internal static string CompressionextensionfileShort {
            get {
                return ResourceManager.GetString("CompressionextensionfileShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Duplicati supports plugable compression modules. Use this option to select a module to use for compression. This is only applied when creating new volumes, when reading an existing file, the filename is used to select the compression module..
        /// </summary>
        internal static string CompressionmoduleLong {
            get {
                return ResourceManager.GetString("CompressionmoduleLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Select what module to use for compression.
        /// </summary>
        internal static string CompressionmoduleShort {
            get {
                return ResourceManager.GetString("CompressionmoduleShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use this option to attach extra files to the newly uploaded filelists..
        /// </summary>
        internal static string ControlfilesLong {
            get {
                return ResourceManager.GetString("ControlfilesLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Set control files.
        /// </summary>
        internal static string ControlfilesShort {
            get {
                return ResourceManager.GetString("ControlfilesShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This option can change the maximum size of dblock files. Changing the size can be useful if the backend has a limit on the size of each individual file.
        /// </summary>
        internal static string DblocksizeLong {
            get {
                return ResourceManager.GetString("DblocksizeLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Limit the size of the volumes.
        /// </summary>
        internal static string DblocksizeShort {
            get {
                return ResourceManager.GetString("DblocksizeShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Path to the file containing the local cache of the remote file database.
        /// </summary>
        internal static string DbpathLong {
            get {
                return ResourceManager.GetString("DbpathLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Path to the local state database.
        /// </summary>
        internal static string DbpathShort {
            get {
                return ResourceManager.GetString("DbpathShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Activating this option will make some error messages more verbose, which may help you track down a particular issue.
        /// </summary>
        internal static string DebugoutputLong {
            get {
                return ResourceManager.GetString("DebugoutputLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Enables debugging output.
        /// </summary>
        internal static string DebugoutputShort {
            get {
                return ResourceManager.GetString("DebugoutputShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to When an error occurs, Duplicati will silently retry, and only report the number of retries. Enable this option to have the error messages displayed when a retry is performed..
        /// </summary>
        internal static string DebugretryerrorsLong {
            get {
                return ResourceManager.GetString("DebugretryerrorsLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Show error messages when a retry is performed.
        /// </summary>
        internal static string DebugretryerrorsShort {
            get {
                return ResourceManager.GetString("DebugretryerrorsShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This option can be used to supply a list of deleted files. This option will be ignored unless the option --{0} is also set..
        /// </summary>
        internal static string DeletedfilesLong {
            get {
                return ResourceManager.GetString("DeletedfilesLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to List of deleted files.
        /// </summary>
        internal static string DeletedfilesShort {
            get {
                return ResourceManager.GetString("DeletedfilesShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to If Duplicati detects that the target folder is missing, it will create it automatically. Activate this option to prevent automatic folder creation..
        /// </summary>
        internal static string DisableautocreatefolderLong {
            get {
                return ResourceManager.GetString("DisableautocreatefolderLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Disables automatic folder creation.
        /// </summary>
        internal static string DisableautocreatefolderShort {
            get {
                return ResourceManager.GetString("DisableautocreatefolderShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The operating system keeps track of the last time a file was written. Using this information, Duplicati can quickly determine if the file has been modified. If some application deliberately modifies this information, Duplicati won&#39;t work correctly unless this flag is set..
        /// </summary>
        internal static string DisablefiletimecheckLong {
            get {
                return ResourceManager.GetString("DisablefiletimecheckLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Disable checks based on file time.
        /// </summary>
        internal static string DisablefiletimecheckShort {
            get {
                return ResourceManager.GetString("DisablefiletimecheckShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Supply one or more module names, separated by commas to unload them.
        /// </summary>
        internal static string DisablemoduleLong {
            get {
                return ResourceManager.GetString("DisablemoduleLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Disabled one or more modules.
        /// </summary>
        internal static string DisablemoduleShort {
            get {
                return ResourceManager.GetString("DisablemoduleShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Enabling this option will disallow usage of the streaming interface, which means that transfer progress bars will not show, and bandwidth throttle settings will be ignored..
        /// </summary>
        internal static string DisableStreamingLong {
            get {
                return ResourceManager.GetString("DisableStreamingLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Disables use of the streaming transfer method.
        /// </summary>
        internal static string DisableStreamingShort {
            get {
                return ResourceManager.GetString("DisableStreamingShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to When deciding if a full backup should be made or an old backup should be deleted, Duplicati will adjust the times by a small fraction to ensure that minor time differences do not interfer with expected operation. If the backup is set to produce a full backup each day, and a full backup is made at, say 12:00:01, and the backup is executed again at 12:00:00, a full day has not passed and thus an incremental backup is performed. To avoid this, Duplicati inserts a 1% tolerance (max 1 hour). Use this option to disable the tolerance, and use strict time checking.
        /// </summary>
        internal static string DisabletimetoleranceLong {
            get {
                return ResourceManager.GetString("DisabletimetoleranceLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Deactivates tolerance when comparing times.
        /// </summary>
        internal static string DisabletimetoleranceShort {
            get {
                return ResourceManager.GetString("DisabletimetoleranceShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to If USN is enabled the USN numbers are used to find all changed files since last backup. Use this option to disable the use of USN numbers, which will make Duplicati investigate all source files. This option is primarily intended for testing and should not be disabled in a production environment. If USN is not enabled, this option has no effect..
        /// </summary>
        internal static string DisableusndiffcheckLong {
            get {
                return ResourceManager.GetString("DisableusndiffcheckLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Disables changelist by USN numbers.
        /// </summary>
        internal static string DisableusndiffcheckShort {
            get {
                return ResourceManager.GetString("DisableusndiffcheckShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This option will make sure the contents of the manifest file are not read. This also implies that file hashes are not checked either. Use only for disaster recovery..
        /// </summary>
        internal static string DontreadmanifestsLong {
            get {
                return ResourceManager.GetString("DontreadmanifestsLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to An option that prevents verifying the manifests.
        /// </summary>
        internal static string DontreadmanifestsShort {
            get {
                return ResourceManager.GetString("DontreadmanifestsShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The file {0} was downloaded and had size {1} but the size was expected to be {2}.
        /// </summary>
        internal static string DownloadedFileSizeError {
            get {
                return ResourceManager.GetString("DownloadedFileSizeError", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This option can be used to experiment with different settings and observe the outcome without changing actual files..
        /// </summary>
        internal static string DryrunLong {
            get {
                return ResourceManager.GetString("DryrunLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Does not perform any modifications.
        /// </summary>
        internal static string DryrunShort {
            get {
                return ResourceManager.GetString("DryrunShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Supply one or more module names, separated by commas to load them.
        /// </summary>
        internal static string EnablemoduleLong {
            get {
                return ResourceManager.GetString("EnablemoduleLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Enables one or more modules.
        /// </summary>
        internal static string EnablemoduleShort {
            get {
                return ResourceManager.GetString("EnablemoduleShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Duplicati supports plugable encryption modules. Use this option to select a module to use for encryption. This is only applied when creating new volumes, when reading an existing file, the filename is used to select the encryption module..
        /// </summary>
        internal static string EncryptionmoduleLong {
            get {
                return ResourceManager.GetString("EncryptionmoduleLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Select what module to use for encryption.
        /// </summary>
        internal static string EncryptionmoduleShort {
            get {
                return ResourceManager.GetString("EncryptionmoduleShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use this option to exclude files with certain attributes. Use a comma separated list of attribute names to specify more that one. Possible values are: {0}.
        /// </summary>
        internal static string ExcludefilesattributesLong {
            get {
                return ResourceManager.GetString("ExcludefilesattributesLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Exclude files by attribute.
        /// </summary>
        internal static string ExcludefilesattributesShort {
            get {
                return ResourceManager.GetString("ExcludefilesattributesShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This is a very advanced option! This option can be used to select a file hash algorithm with smaller or larger hash size, for performance or storage space reasons..
        /// </summary>
        internal static string FilehashalgorithmLong {
            get {
                return ResourceManager.GetString("FilehashalgorithmLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The hash algorithm used on files.
        /// </summary>
        internal static string FilehashalgorithmShort {
            get {
                return ResourceManager.GetString("FilehashalgorithmShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A fragment of memory is used to reduce database lookups. You should not change this value unless you get warnings in the log..
        /// </summary>
        internal static string FilehashlookupsizeLong {
            get {
                return ResourceManager.GetString("FilehashlookupsizeLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Memory used by the file hash.
        /// </summary>
        internal static string FilehashlookupsizeShort {
            get {
                return ResourceManager.GetString("FilehashlookupsizeShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This option can be used to speed up backup operations by keeping scantimes and other path related data in memory.
        /// </summary>
        internal static string FilepathlookupsizeLong {
            get {
                return ResourceManager.GetString("FilepathlookupsizeLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Memory used to keep paths cached.
        /// </summary>
        internal static string FilepathlookupsizeShort {
            get {
                return ResourceManager.GetString("FilepathlookupsizeShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use this option to set the timespan in which backups are kept..
        /// </summary>
        internal static string KeeptimeLong {
            get {
                return ResourceManager.GetString("KeeptimeLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Keep all versions within a timespan.
        /// </summary>
        internal static string KeeptimeShort {
            get {
                return ResourceManager.GetString("KeeptimeShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use this option to set number of versions to keep, supply -1 to keep all versions.
        /// </summary>
        internal static string KeepversionsLong {
            get {
                return ResourceManager.GetString("KeepversionsLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Keep a number of versions.
        /// </summary>
        internal static string KeepversionsShort {
            get {
                return ResourceManager.GetString("KeepversionsShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Some protocols, like FTP, and some servers have problems detecting an interrupted transfer and will assume that the transfer completed, even if it did not. If this option is enabled Duplicati will list the contents of the backend after each upload and verify that the file exists and has the expected size..
        /// </summary>
        internal static string ListverifyuploadsLong {
            get {
                return ResourceManager.GetString("ListverifyuploadsLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Verify uploads by listing contents.
        /// </summary>
        internal static string ListverifyuploadsShort {
            get {
                return ResourceManager.GetString("ListverifyuploadsShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specifies the name of a while into which internal log information is written.
        /// </summary>
        internal static string LogfileLong {
            get {
                return ResourceManager.GetString("LogfileLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Log internal information.
        /// </summary>
        internal static string LogfileShort {
            get {
                return ResourceManager.GetString("LogfileShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specifies the amount of log information to write into the file specified by --log-file.
        /// </summary>
        internal static string LoglevelLong {
            get {
                return ResourceManager.GetString("LoglevelLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Log information level.
        /// </summary>
        internal static string LoglevelShort {
            get {
                return ResourceManager.GetString("LoglevelShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A fragment of memory is used to reduce database lookups. You should not change this value unless you get warnings in the log..
        /// </summary>
        internal static string MetadatahashlookupsizeLong {
            get {
                return ResourceManager.GetString("MetadatahashlookupsizeLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Memory used by the metadata hash.
        /// </summary>
        internal static string MetadatahashlookupsizeShort {
            get {
                return ResourceManager.GetString("MetadatahashlookupsizeShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to If a large number of small files are detected during a backup, or wasted space is found after deleting backups, the remote data will be compacted. Use this option to disable such automatic compacting and only compact when running the compact command..
        /// </summary>
        internal static string NoautocompactLong {
            get {
                return ResourceManager.GetString("NoautocompactLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Disable automatic compating.
        /// </summary>
        internal static string NoautocompactShort {
            get {
                return ResourceManager.GetString("NoautocompactShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to If this flag is set, the local database is not compared to the remote filelist on startup. The intended usage for this option is to work correctly in cases where the filelisting is broken or unavailable..
        /// </summary>
        internal static string NobackendverificationLong {
            get {
                return ResourceManager.GetString("NobackendverificationLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Do not query backend at startup.
        /// </summary>
        internal static string NobackendverificationShort {
            get {
                return ResourceManager.GetString("NobackendverificationShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Duplicati will attempt to perform multiple operations on a single connection, as this avoids repeated login attempts, and thus speeds up the process. This option can be used to ensure that each operation is performed on a seperate connection.
        /// </summary>
        internal static string NoconnectionreuseLong {
            get {
                return ResourceManager.GetString("NoconnectionreuseLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Do not re-use connections.
        /// </summary>
        internal static string NoconnectionreuseShort {
            get {
                return ResourceManager.GetString("NoconnectionreuseShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to If you store the backups on a local disk, and prefer that they are kept unencrypted, you can turn of encryption completely by using this switch..
        /// </summary>
        internal static string NoencryptionLong {
            get {
                return ResourceManager.GetString("NoencryptionLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Disable encryption.
        /// </summary>
        internal static string NoencryptionShort {
            get {
                return ResourceManager.GetString("NoencryptionShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to If this flag is set, no index files are uploaded to the remote destination. This reduces the required storage as well as the required transfer, but makes restoring slower as more volumes must be downloaded..
        /// </summary>
        internal static string NoindexfilesLong {
            get {
                return ResourceManager.GetString("NoindexfilesLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Do not upload index files.
        /// </summary>
        internal static string NoindexfilesShort {
            get {
                return ResourceManager.GetString("NoindexfilesShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to When listing contents or when restoring files, the local database can be skipped. This is usually slower, but can be used to verify the actual contents of the remote store.
        /// </summary>
        internal static string NolocaldbLong {
            get {
                return ResourceManager.GetString("NolocaldbLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Disables the local database.
        /// </summary>
        internal static string NolocaldbShort {
            get {
                return ResourceManager.GetString("NolocaldbShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to If an upload or download fails, Duplicati will retry a number of times before failing. Use this to handle unstable network connections better..
        /// </summary>
        internal static string NumberofretriesLong {
            get {
                return ResourceManager.GetString("NumberofretriesLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Number of times to retry a failed transmission.
        /// </summary>
        internal static string NumberofretriesShort {
            get {
                return ResourceManager.GetString("NumberofretriesShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use this option to overwrite target files when restoring, if this option is not set the files will be restored with a timestamp and a number appended..
        /// </summary>
        internal static string OverwriteLong {
            get {
                return ResourceManager.GetString("OverwriteLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Overwrite files when restoring.
        /// </summary>
        internal static string OverwriteShort {
            get {
                return ResourceManager.GetString("OverwriteShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Supply a passphrase that Duplicati will use to encrypt the backup volumes, making them unreadable without the passphrase. This variable can also be supplied through the environment variable PASSPHRASE..
        /// </summary>
        internal static string PassphraseLong {
            get {
                return ResourceManager.GetString("PassphraseLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Passphrase used to encrypt backups.
        /// </summary>
        internal static string PassphraseShort {
            get {
                return ResourceManager.GetString("PassphraseShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Enable this option to look into other files on this machine to find existing blocks. This is a fairly slow operation but can limit the size of downloads..
        /// </summary>
        internal static string PatchwithlocalblocksLong {
            get {
                return ResourceManager.GetString("PatchwithlocalblocksLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use local file data when restoring.
        /// </summary>
        internal static string PatchwithlocalblocksShort {
            get {
                return ResourceManager.GetString("PatchwithlocalblocksShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A string used to prefix the filenames of the remote volumes, can be used to store multiple backups in the same remote folder..
        /// </summary>
        internal static string PrefixLong {
            get {
                return ResourceManager.GetString("PrefixLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Remote filename prefix.
        /// </summary>
        internal static string PrefixShort {
            get {
                return ResourceManager.GetString("PrefixShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to If this option is set, progress reports and other messages that would normally go to the console will be redirected to the log..
        /// </summary>
        internal static string QuietconsoleLong {
            get {
                return ResourceManager.GetString("QuietconsoleLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Disable console output.
        /// </summary>
        internal static string QuietconsoleShort {
            get {
                return ResourceManager.GetString("QuietconsoleShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This value can be used to set a known upper limit on the amount of space a backend has. If the backend reports the size itself, this value is ignored.
        /// </summary>
        internal static string QuotasizeLong {
            get {
                return ResourceManager.GetString("QuotasizeLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A reported maximum storage.
        /// </summary>
        internal static string QuotasizeShort {
            get {
                return ResourceManager.GetString("QuotasizeShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to By default, files will be restored in the source folders, use this option to restore to another folder.
        /// </summary>
        internal static string RestorepathLong {
            get {
                return ResourceManager.GetString("RestorepathLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Restore to another folder.
        /// </summary>
        internal static string RestorepathShort {
            get {
                return ResourceManager.GetString("RestorepathShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to After a failed transmission, Duplicati will wait a short period before attempting again. This is usefull if the network drops out occasionally during transmissions..
        /// </summary>
        internal static string RetrydelayLong {
            get {
                return ResourceManager.GetString("RetrydelayLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Time to wait between retries.
        /// </summary>
        internal static string RetrydelayShort {
            get {
                return ResourceManager.GetString("RetrydelayShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to If the hash for the volume does not match, Duplicati will refuse to use the backup. Supply this flag to allow Duplicati to proceed anyway..
        /// </summary>
        internal static string SkipfilehashchecksLong {
            get {
                return ResourceManager.GetString("SkipfilehashchecksLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Set this flag to skip hash checks.
        /// </summary>
        internal static string SkipfilehashchecksShort {
            get {
                return ResourceManager.GetString("SkipfilehashchecksShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This option allows you to exclude files that are larger than the given value. Use this to prevent backups becoming extremely large..
        /// </summary>
        internal static string SkipfileslargerthanLong {
            get {
                return ResourceManager.GetString("SkipfileslargerthanLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Limit the size of files being backed up.
        /// </summary>
        internal static string SkipfileslargerthanShort {
            get {
                return ResourceManager.GetString("SkipfileslargerthanShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To avoid filling the remote storage with small files, this value can force grouping small files. The small volumes will always be combined when they can fill an entire volume..
        /// </summary>
        internal static string SmallfilemaxcountLong {
            get {
                return ResourceManager.GetString("SmallfilemaxcountLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Maximum number of small volumes.
        /// </summary>
        internal static string SmallfilemaxcountShort {
            get {
                return ResourceManager.GetString("SmallfilemaxcountShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to When examining the size of a volume in consideration for compating, a small tolerance value is used, by default 20 percent of the volume size. This ensures that large volumes which may have a few bytes wasted space are not downloaded and rewritten..
        /// </summary>
        internal static string SmallfilesizeLong {
            get {
                return ResourceManager.GetString("SmallfilesizeLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Volume size threshold.
        /// </summary>
        internal static string SmallfilesizeShort {
            get {
                return ResourceManager.GetString("SmallfilesizeShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This settings controls the usage of snapshots, which allows Duplicati to backup files that are locked by other programs. If this is set to &quot;off&quot;, Duplicati will not attempt to create a disk snapshot. Setting this to &quot;auto&quot; makes Duplicati attempt to create a snapshot, and fail silently if that was not allowed or supported. A setting of &quot;on&quot; will also make Duplicati attempt to create a snapshot, but will produce a warning message in the log if it fails. Setting it to &quot;required&quot; will make Duplicati abort the backup if the snapshot creation fails. On windows this uses the Volume Shadow Copy Services (VSS) and requires administrative privileges. On linux this uses Logical Volume Management (LVM) and requires root privileges..
        /// </summary>
        internal static string SnapshotpolicyLong {
            get {
                return ResourceManager.GetString("SnapshotpolicyLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Controls the use of disk snapshots.
        /// </summary>
        internal static string SnapshotpolicyShort {
            get {
                return ResourceManager.GetString("SnapshotpolicyShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Stores metadata, such as file timestamps and attributes. This increases the required storage space as well as the processing time..
        /// </summary>
        internal static string StoremetadataLong {
            get {
                return ResourceManager.GetString("StoremetadataLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Enables storing file metadata.
        /// </summary>
        internal static string StoremetadataShort {
            get {
                return ResourceManager.GetString("StoremetadataShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Using this option to handle symlinks different. The &quot;{0}&quot; option will simply record a symlink with its name and destination, and a restore will recreate the symlink as a link. Use the option &quot;{1}&quot; to ignore all symlinks and not store any information about them. Previous versions of Duplicati used the setting &quot;{2}&quot;, which will cause symlinked files to be included and restore as normal files..
        /// </summary>
        internal static string SymlinkpolicyLong {
            get {
                return ResourceManager.GetString("SymlinkpolicyLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Symlink handling.
        /// </summary>
        internal static string SymlinkpolicyShort {
            get {
                return ResourceManager.GetString("SymlinkpolicyShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Duplicati will upload files while scanning the disk and producing volumes, which usually makes the backup faster. Use this flag to turn the behavior off, so that Duplicati will wait for each volume to complete..
        /// </summary>
        internal static string SynchronousuploadLong {
            get {
                return ResourceManager.GetString("SynchronousuploadLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Upload files synchronously.
        /// </summary>
        internal static string SynchronousuploadShort {
            get {
                return ResourceManager.GetString("SynchronousuploadShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Duplicati will use the system default temporary folder. This option can be used to supply an alternative folder for temporary storage..
        /// </summary>
        internal static string TempdirLong {
            get {
                return ResourceManager.GetString("TempdirLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Temporary storage folder.
        /// </summary>
        internal static string TempdirShort {
            get {
                return ResourceManager.GetString("TempdirShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Selects another thread priority for the process. Use this to set Duplicati to be more or less CPU intensive..
        /// </summary>
        internal static string ThreadpriorityLong {
            get {
                return ResourceManager.GetString("ThreadpriorityLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Thread priority.
        /// </summary>
        internal static string ThreadpriorityShort {
            get {
                return ResourceManager.GetString("ThreadpriorityShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to As files are changed, some data stored at the remote destination may not be required. This option controls how much wasted space the destination can contain before being reclaimed. This value is a percentage used on each volume and the total storage..
        /// </summary>
        internal static string ThresholdLong {
            get {
                return ResourceManager.GetString("ThresholdLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The maximum wasted space in percent.
        /// </summary>
        internal static string ThresholdShort {
            get {
                return ResourceManager.GetString("ThresholdShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to By setting this value you can limit how much bandwidth Duplicati consumes for downloads. Setting this limit can make the backups take longer, but will make Duplicati less intrusive..
        /// </summary>
        internal static string ThrottledownloadLong {
            get {
                return ResourceManager.GetString("ThrottledownloadLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Max number of bytes to download pr. second.
        /// </summary>
        internal static string ThrottledownloadShort {
            get {
                return ResourceManager.GetString("ThrottledownloadShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to By setting this value you can limit how much bandwidth Duplicati consumes for uploads. Setting this limit can make the backups take longer, but will make Duplicati less intrusive..
        /// </summary>
        internal static string ThrottleuploadLong {
            get {
                return ResourceManager.GetString("ThrottleuploadLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Max number of bytes to upload pr. second.
        /// </summary>
        internal static string ThrottleuploadShort {
            get {
                return ResourceManager.GetString("ThrottleuploadShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to By default, Duplicati will list and restore files from the most recent backup, use this option to select another item. You may use relative times, like &quot;-2M&quot; for a backup from two months ago..
        /// </summary>
        internal static string TimeLong {
            get {
                return ResourceManager.GetString("TimeLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The time to list/restore files.
        /// </summary>
        internal static string TimeShort {
            get {
                return ResourceManager.GetString("TimeShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to If no files have changed, Duplicati will not upload a backup set. If the backup data is used to verify that a backup was executed, this option will make Duplicati upload a backupset even if it is empty.
        /// </summary>
        internal static string UploadUnchangedBackupsLong {
            get {
                return ResourceManager.GetString("UploadUnchangedBackupsLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Upload empty backup files.
        /// </summary>
        internal static string UploadUnchangedBackupsShort {
            get {
                return ResourceManager.GetString("UploadUnchangedBackupsShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This settings controls the usage of NTFS USN numbers, which allows Duplicati to obtain a list of files and folders much faster. If this is set to &quot;off&quot;, Duplicati will not attempt to use USN. Setting this to &quot;auto&quot; makes Duplicati attempt to use USN, and fail silently if that was not allowed or supported. A setting of &quot;on&quot; will also make Duplicati attempt to use USN, but will produce a warning message in the log if it fails. Setting it to &quot;required&quot; will make Duplicati abort the backup if the USN usage fails. This feature is only supported on Windows and requires administrative privileges..
        /// </summary>
        internal static string UsnpolicyLong {
            get {
                return ResourceManager.GetString("UsnpolicyLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Controls the use of NTFS Update Sequence Numbers.
        /// </summary>
        internal static string UsnpolicyShort {
            get {
                return ResourceManager.GetString("UsnpolicyShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use this option to increase the amount of output generated when running an option. Generally this option will produce a line for each file processed..
        /// </summary>
        internal static string VerboseLong {
            get {
                return ResourceManager.GetString("VerboseLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Output more progress information.
        /// </summary>
        internal static string VerboseShort {
            get {
                return ResourceManager.GetString("VerboseShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to By default, Duplicati will list and restore files from the most recent backup, use this option to select another item. You may enter multiple values separated with comma, and ranges using -, e.g. &quot;0,2-4,7&quot; ..
        /// </summary>
        internal static string VersionLong {
            get {
                return ResourceManager.GetString("VersionLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The version to list/restore files.
        /// </summary>
        internal static string VersionShort {
            get {
                return ResourceManager.GetString("VersionShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use this option to exclude faulty writers from a snapshot. This is equivalent to the -wx flag of the vshadow.exe tool, except that it only accepts writer class GUIDs, and not component names or instance GUIDs. Multiple GUIDs must be separated with a semicolon, and most forms of GUIDs are allowed, including with and without curly braces..
        /// </summary>
        internal static string VssexcludewritersLong {
            get {
                return ResourceManager.GetString("VssexcludewritersLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A semicolon separated list of guids of VSS writers to exclude (Windows only).
        /// </summary>
        internal static string VssexcludewritersShort {
            get {
                return ResourceManager.GetString("VssexcludewritersShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Activate this option to map VSS snapshots to a drive (similar to SUBST, using Win32 DefineDosDevice). This will create temporary drives that are then used to access the contents of a snapshot. This workaround can speed up file access on Windows XP..
        /// </summary>
        internal static string VssusemappingLong {
            get {
                return ResourceManager.GetString("VssusemappingLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Map snapshots to a drive (Windows only).
        /// </summary>
        internal static string VssusemappingShort {
            get {
                return ResourceManager.GetString("VssusemappingShort", resourceCulture);
            }
        }
    }
}