duplicati/Duplicati/Library/Main/Strings/Options.Designer.cs

//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:4.0.30319.544
//
//     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 As a precaution, the last full backup will never be removed, even if using the &quot;delete-all-but-n-full 0&quot; command. Set this option to allow removing the last backup..
        /// </summary>
        internal static string AllowfullremoveLong {
            get {
                return ResourceManager.GetString("AllowfullremoveLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Allow removal of the all backups.
        /// </summary>
        internal static string AllowfullremoveShort {
            get {
                return ResourceManager.GetString("AllowfullremoveShort", 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 This option can be used to disable the check for the same source folders. It is used in unittests, and is NOT intended for everyday use. Do not use this option unless you know what you are doing..
        /// </summary>
        internal static string AllowsourcefolderchangeLong {
            get {
                return ResourceManager.GetString("AllowsourcefolderchangeLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Skip verifying the source folders.
        /// </summary>
        internal static string AllowsourcefolderchangeShort {
            get {
                return ResourceManager.GetString("AllowsourcefolderchangeShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Asynchronous upload is now default, you can turn it off by using the flag --{0}.
        /// </summary>
        internal static string AsynchronousuploadDeprecated {
            get {
                return ResourceManager.GetString("AsynchronousuploadDeprecated", 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 By supplying this option, Duplicati will transmit files, while building volumes. This can shorten the time it takes to perform a backup, but requires more diskspace..
        /// </summary>
        internal static string AsynchronousuploadLong {
            get {
                return ResourceManager.GetString("AsynchronousuploadLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Transmit files on a separate thread.
        /// </summary>
        internal static string AsynchronousuploadShort {
            get {
                return ResourceManager.GetString("AsynchronousuploadShort", 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 Use this option to specify a path to a file that will store information about backend operations. This option can be used to track down errors by comparing the backend state with the expected backend state..
        /// </summary>
        internal static string BackendlogdatabaseLong {
            get {
                return ResourceManager.GetString("BackendlogdatabaseLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Database log of remote operations.
        /// </summary>
        internal static string BackendlogdatabaseShort {
            get {
                return ResourceManager.GetString("BackendlogdatabaseShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Any string used to prefix the filenames generated by Duplicati..
        /// </summary>
        internal static string BackupprefixLong {
            get {
                return ResourceManager.GetString("BackupprefixLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Backup volume filename prefix.
        /// </summary>
        internal static string BackupprefixShort {
            get {
                return ResourceManager.GetString("BackupprefixShort", 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 If the backup is encrypted, the remote backend cannot verify the backup contents without the password. If this option is activated, Duplicati stores an unencrypted file on the backend. The file is never read by Duplicati, but allows the remote server to verify the backup integrity without requiring a password. The file contains no sensitive information, only a list of files that are expected to exist on the backend and their respective hashes. This option only has an effect when creating a backup and when v [rest of string was truncated]&quot;;.
        /// </summary>
        internal static string CreateverificationfileLong {
            get {
                return ResourceManager.GetString("CreateverificationfileLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Create verification file on server.
        /// </summary>
        internal static string CreateverificationfileShort {
            get {
                return ResourceManager.GetString("CreateverificationfileShort", 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 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&apos;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 d [rest of string was truncated]&quot;;.
        /// </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 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 By setting this option to true, a folder which has no files that match the filter will be excluded from the backup.
        /// </summary>
        internal static string ExcludeemptyfoldersLong {
            get {
                return ResourceManager.GetString("ExcludeemptyfoldersLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Controls empty folder actions.
        /// </summary>
        internal static string ExcludeemptyfoldersShort {
            get {
                return ResourceManager.GetString("ExcludeemptyfoldersShort", 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 Exclude files that match this filter. The filter is a &quot;file-globbing&quot; filter, much like commandline options. You can use &quot;*.txt&quot; to exclude all text files..
        /// </summary>
        internal static string ExcludeLong {
            get {
                return ResourceManager.GetString("ExcludeLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Exclude files that match this filter. The filter is a regular expression filter. You can use &quot;(.*)\.txt&quot; to exclude all text files..
        /// </summary>
        internal static string ExcluderegexpLong {
            get {
                return ResourceManager.GetString("ExcluderegexpLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Exclude files regular expression.
        /// </summary>
        internal static string ExcluderegexpShort {
            get {
                return ResourceManager.GetString("ExcluderegexpShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Exclude files.
        /// </summary>
        internal static string ExcludeShort {
            get {
                return ResourceManager.GetString("ExcludeShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to By default, duplicati will restore all files in the backup. Use this option to restore only a subset of the files.
        /// </summary>
        internal static string FiletorestoreLong {
            get {
                return ResourceManager.GetString("FiletorestoreLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A list of files to restore.
        /// </summary>
        internal static string FiletorestoreShort {
            get {
                return ResourceManager.GetString("FiletorestoreShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to When deleting old files, Duplicati will only write out what files are supposed to be deleted. Specify the &quot;force&quot; option to actually remove them..
        /// </summary>
        internal static string ForceLong {
            get {
                return ResourceManager.GetString("ForceLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Force the removal of files.
        /// </summary>
        internal static string ForceShort {
            get {
                return ResourceManager.GetString("ForceShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use this option to limit the length of the backup chain to a certain number. The number supplied here indicates the maximum number of incrementals a chain can contain (not counting the root full backup).
        /// </summary>
        internal static string FullifmorethannincrementalsLong {
            get {
                return ResourceManager.GetString("FullifmorethannincrementalsLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The max number of incrementals in a chain.
        /// </summary>
        internal static string FullifmorethannincrementalsShort {
            get {
                return ResourceManager.GetString("FullifmorethannincrementalsShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to If the last full backup is older than the duration supplied here, Duplicati will make a full backup, otherwise an incremental.
        /// </summary>
        internal static string FullifolderthanLong {
            get {
                return ResourceManager.GetString("FullifolderthanLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The max duration between full backups.
        /// </summary>
        internal static string FullifolderthanShort {
            get {
                return ResourceManager.GetString("FullifolderthanShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to It is not allowed to change the sourcefolder or the number of source folders. If this option is enabled, the backup will become a full backup if the source folders have changed, which will then start a new chain of backups with the new folder set. If --allow-sourcefolder-change is also set, a full backup is only issued if the number of of source folders have changed.
        /// </summary>
        internal static string FullifsourcefolderchangedLong {
            get {
                return ResourceManager.GetString("FullifsourcefolderchangedLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Run a full backup if the sourcefolder has changed.
        /// </summary>
        internal static string FullifsourcefolderchangedShort {
            get {
                return ResourceManager.GetString("FullifsourcefolderchangedShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to When this flag is specified, Duplicati will make a full backup of all files, and ignore any incremental data..
        /// </summary>
        internal static string FullLong {
            get {
                return ResourceManager.GetString("FullLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A flag used to force full backups.
        /// </summary>
        internal static string FullShort {
            get {
                return ResourceManager.GetString("FullShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use --encryption-module=gpg instead.
        /// </summary>
        internal static string GpgencryptionDeprecated {
            get {
                return ResourceManager.GetString("GpgencryptionDeprecated", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to By default, Duplicati will use the AES encryption algorithm to encrypt the backup volumes, setting this flag makes Duplicati use the GNU Privacy Guard instead. GnuPG must be installed on the machine for this to work..
        /// </summary>
        internal static string GpgencryptionLong {
            get {
                return ResourceManager.GetString("GpgencryptionLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use GnuPG for encryption.
        /// </summary>
        internal static string GpgencryptionShort {
            get {
                return ResourceManager.GetString("GpgencryptionShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Include files that match this filter. The filter is a &quot;file-globbing&quot; filter, much like commandline options. You can use &quot;*.txt&quot; to include all text files..
        /// </summary>
        internal static string IncludeLong {
            get {
                return ResourceManager.GetString("IncludeLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Include files that match this filter. The filter is a regular expression filter. You can use &quot;(.*)\.txt&quot; to include all text files..
        /// </summary>
        internal static string IncluderegexpLong {
            get {
                return ResourceManager.GetString("IncluderegexpLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Include files regular expression.
        /// </summary>
        internal static string IncluderegexpShort {
            get {
                return ResourceManager.GetString("IncluderegexpShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Include files.
        /// </summary>
        internal static string IncludeShort {
            get {
                return ResourceManager.GetString("IncludeShort", 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 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 MaxdownloadprsecondLong {
            get {
                return ResourceManager.GetString("MaxdownloadprsecondLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Max number of bytes to download pr. second.
        /// </summary>
        internal static string MaxdownloadprsecondShort {
            get {
                return ResourceManager.GetString("MaxdownloadprsecondShort", 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 MaxuploadprsecondLong {
            get {
                return ResourceManager.GetString("MaxuploadprsecondLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Max number of bytes to upload pr. second.
        /// </summary>
        internal static string MaxuploadprsecondShort {
            get {
                return ResourceManager.GetString("MaxuploadprsecondShort", 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 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 This option will be removed in the future but is included for the odd case where the new format breaks something.
        /// </summary>
        internal static string OldfilenamesDeprecated {
            get {
                return ResourceManager.GetString("OldfilenamesDeprecated", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to By setting this option the filenames generated by Duplicati will contain a time separator as well as a timezone component, which is not cross platform compatible.
        /// </summary>
        internal static string OldfilenamesLong {
            get {
                return ResourceManager.GetString("OldfilenamesLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Uses the old filename format.
        /// </summary>
        internal static string OldfilenamesShort {
            get {
                return ResourceManager.GetString("OldfilenamesShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to If Duplicati encounters a file that is opened by another program, it will attempt to read whatever contents that are in the file. Since the file may be written during the backup, this can cause the backup to contain a partially written file. Use this option to disable this, omitting locked files from the backup. This option has no effect if a snapshot is active..
        /// </summary>
        internal static string OpenfilepolicyLong {
            get {
                return ResourceManager.GetString("OpenfilepolicyLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Determines how to handle open files.
        /// </summary>
        internal static string OpenfilepolicyShort {
            get {
                return ResourceManager.GetString("OpenfilepolicyShort", 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 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, Duplicati will 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 RestoretimeLong {
            get {
                return ResourceManager.GetString("RestoretimeLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The time to restore files.
        /// </summary>
        internal static string RestoretimeShort {
            get {
                return ResourceManager.GetString("RestoretimeShort", 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 Duplicati now uses a filename format that is portable across all operating systems, so this option should not be used and will be removed in the future.
        /// </summary>
        internal static string ShortfilenamesDeprecated {
            get {
                return ResourceManager.GetString("ShortfilenamesDeprecated", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to If the filesystem does not support the long filenames that Duplicati uses, this switch will change the time to be a much more compact, but hard to read format. It will also make the default prefix &quot;dpl&quot;..
        /// </summary>
        internal static string ShortfilenamesLong {
            get {
                return ResourceManager.GetString("ShortfilenamesLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use short filenames.
        /// </summary>
        internal static string ShortfilenamesShort {
            get {
                return ResourceManager.GetString("ShortfilenamesShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to If this path is supplied, Duplicati will store all signature files here, so re-downloads can be avoided..
        /// </summary>
        internal static string SignaturecachepathLong {
            get {
                return ResourceManager.GetString("SignaturecachepathLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A path to temporary storage.
        /// </summary>
        internal static string SignaturecachepathShort {
            get {
                return ResourceManager.GetString("SignaturecachepathShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Supply a list of files separated with semicolons, that will be added to each backup. The Duplicati GUI program uses this to store the setup database with each backup..
        /// </summary>
        internal static string SignaturecontrolfilesLong {
            get {
                return ResourceManager.GetString("SignaturecontrolfilesLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A list of control files to embed in the backups.
        /// </summary>
        internal static string SignaturecontrolfilesShort {
            get {
                return ResourceManager.GetString("SignaturecontrolfilesShort", 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 A size string that limits 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 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  [rest of string was truncated]&quot;;.
        /// </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 The list of files to back up is normally processed in a random fashion to ensure that all files have an equal probability of being processed. Use this setting to process the files in alphabetical order instead.
        /// </summary>
        internal static string SortedfilelistLong {
            get {
                return ResourceManager.GetString("SortedfilelistLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Sort the list of files.
        /// </summary>
        internal static string SortedfilelistShort {
            get {
                return ResourceManager.GetString("SortedfilelistShort", 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 Duplicati no longer uses a time separator for the filenames so this option is useless.
        /// </summary>
        internal static string TimeseparatorDeprecated {
            get {
                return ResourceManager.GetString("TimeseparatorDeprecated", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Per default, Duplicati will use the colon &quot;:&quot; character to separate the time fields in the filename. However, on some filesystem, notably windows, this character is not allowed. Use this option to use another character..
        /// </summary>
        internal static string TimeseparatorLong {
            get {
                return ResourceManager.GetString("TimeseparatorLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Backup volume filename timeseparator.
        /// </summary>
        internal static string TimeseparatorShort {
            get {
                return ResourceManager.GetString("TimeseparatorShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This option can place an upper limit on the total size of each backup. Note that if this flag is specified the backup may not contain all files, even for a full backup..
        /// </summary>
        internal static string TotalsizeLong {
            get {
                return ResourceManager.GetString("TotalsizeLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The number of bytes generated by each backup run.
        /// </summary>
        internal static string TotalsizeShort {
            get {
                return ResourceManager.GetString("TotalsizeShort", 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 fail [rest of string was truncated]&quot;;.
        /// </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 change the level of verifiation done by the verify command. The setting &quot;manifest&quot; will only verify the manifest chain. The settings &quot;signature&quot; will also download and verify all signature files. The setting &quot;full&quot;, will download all files, including content files, and verify that they are unchanged..
        /// </summary>
        internal static string VerificationLevelLong {
            get {
                return ResourceManager.GetString("VerificationLevelLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Level of verification.
        /// </summary>
        internal static string VerificationLevelShort {
            get {
                return ResourceManager.GetString("VerificationLevelShort", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This option can change the default volume size. Changing the size can be usefull if the backend has a limit on the size of each individual file.
        /// </summary>
        internal static string VolsizeLong {
            get {
                return ResourceManager.GetString("VolsizeLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A size string that limits the size of the volumes.
        /// </summary>
        internal static string VolsizeShort {
            get {
                return ResourceManager.GetString("VolsizeShort", 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);
            }
        }
    }
}