FileFlowsPlugins/BasicNodes/i18n/ru.json

{
  "Enums": {
    "LogType": {
      "Debug": "Отладка",
      "Error": "Ошибка",
      "Info": "Информация",
      "Warning": "Предупреждение"
    }
  },
  "Flow": {
    "Parts": {
      "BatchScript": {
        "Description": "Позволяет выполнять пакетный (.bat) скрипт в среде Windows.",
        "Label": "Пакетный скрипт (.bat)",
        "Fields": {
          "Code": "Код"
        },
        "Outputs": {
          "1": "возврат 1",
          "10": "возврат 10",
          "2": "возврат 2",
          "3": "возврат 3",
          "4": "возврат 4",
          "5": "возврат 5",
          "6": "возврат 6",
          "7": "возврат 7",
          "8": "возврат 8",
          "9": "возврат 9"
        }
      },
      "CompleteFlow": {
        "Description": "Завершает/оканчивает поток как успешный",
        "Label": "Завершить поток"
      },
      "CopyFile": {
        "Description": "Копирует файл в папку назначения",
        "Label": "Копировать файл",
        "Fields": {
          "AdditionalFiles": "Дополнительные файлы",
          "AdditionalFiles-Help": "Дополнительные файлы для копирования из директории в новую директорию.\nКаждое значение может содержать комбинацию действительного буквального пути и символов подстановки (* и ?), но не поддерживает регулярные выражения.",
          "AdditionalFilesFromOriginal": "Исходная директория",
          "AdditionalFilesFromOriginal-Help": "Если дополнительные файлы должны быть скопированы из рабочей директории или из исходной директории. Включите для исходной директории.",
          "CopyFolder": "Копировать папку",
          "CopyFolder-Help": "Если также нужно скопировать относительную структуру папок библиотеки",
          "DestinationFile": "Файл назначения",
          "DestinationFile-Help": "Имя файла, в который будет скопирован файл. Если пусто, будет использовано оригинальное имя файла",
          "DestinationPath": "Папка назначения",
          "DestinationPath-Help": "Папка, в которую будет скопирован файл",
          "InputFile": "Файл для копирования",
          "InputFile-Help": "Файл для копирования, если оставлено пустым, будет скопирован рабочий файл",
          "InputFile-Placeholder": "Рабочий файл",
          "PreserverOriginalDates": "Сохранять даты",
          "PreserverOriginalDates-Help": "Если следует сохранить оригинальное время создания и последнее время записи оригинального входного файла."
        },
        "Outputs": {
          "1": "Файл скопирован"
        }
      },
      "CSharpScript": {
        "Description": "Позволяет выполнять код C# внутри потока.",
        "Label": "Функция C#",
        "Fields": {
          "Code": "Код"
        },
        "Outputs": {
          "1": "возвращено 1",
          "10": "возвращено 10",
          "2": "возвращено 2",
          "3": "возвращено 3",
          "4": "возвращено 4",
          "5": "возвращено 5",
          "6": "возвращено 6",
          "7": "возвращено 7",
          "8": "возвращено 8",
          "9": "возвращено 9"
        }
      },
      "Delete": {
        "Description": "Удаляет файл или папку",
        "Label": "Удалить",
        "Fields": {
          "FileName": "Путь",
          "FileName-Help": "Путь к файлу или папке для удаления.\n\nЕсли оставить пустым, будет удален текущий рабочий файл."
        },
        "Outputs": {
          "1": "Файл удален"
        }
      },
      "DeleteSourceDirectory": {
        "Description": "Удаляет исходную папку оригинального файла библиотеки",
        "Label": "Удалить исходную папку",
        "Fields": {
          "IfEmpty": "Если пусто",
          "IfEmpty-Help": "Удалить исходную папку только если она пустая",
          "IncludePatterns": "Включить шаблоны",
          "IncludePatterns-Help": "Необязательно, если установлено, то только файлы, соответствующие этим шаблонам, будут учитываться, чтобы проверить, пуста ли папка. Любой из этих шаблонов может соответствовать.",
          "TopMostOnly": "Только самый верхний",
          "TopMostOnly-Help": "При включении будет удалена только папка, непосредственно содержащая файл, в то время как папки более высокого уровня останутся нетронутыми."
        },
        "Outputs": {
          "1": "Исходная папка удалена",
          "2": "Папка НЕ была удалена"
        }
      },
      "Executor": {
        "Description": "Выполняет следующий процесс над файлом.\nВыход 1: Процесс вернул код успешного завершения\nВыход 2: Процесс вернул код завершения с ошибкой.",
        "Label": "Исполнитель",
        "Fields": {
          "Arguments": "Аргументы",
          "Arguments-Help": "Аргументы, которые будут переданы процессу для выполнения",
          "FileName": "Имя файла",
          "FileName-Help": "Имя файла для выполнения",
          "OutputErrorVariable": "Переменная ошибки вывода",
          "OutputErrorVariable-Help": "Необязательное имя переменной для хранения ошибки вывода процесса",
          "OutputVariable": "Переменная вывода",
          "OutputVariable-Help": "Необязательное имя переменной для хранения вывода процесса",
          "SuccessCode": "Код успеха",
          "SuccessCode-Help": "Код завершения процесса, указывающий на его успешное выполнение. Обычно это должно быть 0.",
          "Timeout": "Тайм-аут",
          "Timeout-Help": "Как долго процесс может выполняться перед завершением. Используйте 0 для отсутствия тайм-аута.",
          "Timeout-Suffix": "секунд",
          "WorkingDirectory": "Рабочая папка",
          "WorkingDirectory-Help": "Папка, из которой будет выполняться процесс"
        },
        "Outputs": {
          "1": "Процесс завершился успешно",
          "2": "Процесс завершился с ошибкой"
        }
      },
      "FailFlow": {
        "Description": "Немедленно завершает поток с ошибкой, полезно, если вы хотите, чтобы определенный путь просто завершился неудачей.",
        "Label": "Завершить поток с ошибкой",
        "Fields": {
          "Reason": "Причина",
          "Reason-Help": "Необязательная причина для записи, почему поток завершился неудачей."
        }
      },
      "FileDateCompare": {
        "Description": "Проверяет, соответствует ли дата создания файла или последнее время записи указанным ограничениям по дате.",
        "Label": "Сравнение даты файла",
        "Fields": {
          "Date": "Дата",
          "DateComparision": "Сравнение",
          "FileName": "Имя файла",
          "FileName-Help": "Файл для проверки. Оставьте пустым, чтобы проверить текущий рабочий файл."
        },
        "Outputs": {
          "1": "Соответствует ограничению по дате.",
          "2": "Не соответствует ограничению по дате."
        }
      },
      "FileExists": {
        "Description": "Проверяет, существует ли файл\n\nВыход 1: Файл существует\nВыход 2: Файл не существует",
        "Label": "Файл существует",
        "Fields": {
          "FileName": "Имя файла",
          "FileName-Help": "Файл, который нужно проверить. Оставьте пустым, чтобы проверить текущий рабочий файл."
        },
        "Outputs": {
          "1": "Файл существует",
          "2": "Файл не существует"
        }
      },
      "FileExtension": {
        "Description": "Проверяет, имеет ли файл одно из заданных расширений.\n\nВыход 1: Совпадает\nВыход 2: Не совпадает",
        "Label": "Расширение файла",
        "Fields": {
          "Extensions": "Расширения",
          "Extensions-Help": "Список нечувствительных к регистру расширений файлов, с которыми будет производиться сравнение.\nВыход 1: Совпадает\nВыход 2: Не совпадает"
        },
        "Outputs": {
          "1": "Совпадение расширения",
          "2": "Расширение не совпадает"
        }
      },
      "FileNameMatches": {
        "Description": "Проверяет, соответствует ли исходное имя файла (включая полный путь) указанному значению с использованием строковых операций.",
        "Label": "Имя файла совпадает",
        "Fields": {
          "Value": "Значение для совпадения",
          "Value-Help": "Укажите значение для сравнения. Поддерживаются переменные, и совпадение происходит с использованием строковых операций."
        },
        "Outputs": {
          "1": "Совпадает",
          "2": "Не совпадает"
        }
      },
      "FileSize": {
        "Description": "Проверяет, соответствует ли размер файла заданным параметрам. Значения указаны в мегабайтах.\n\nВыход 1: Совпадает\nВыход 2: Не совпадает",
        "Label": "Размер файла",
        "Fields": {
          "Comparison": "Сравнение",
          "Lower": "Больше чем",
          "Lower-Help": "Значение должно быть больше этого числа мегабайт",
          "Lower-Suffix": "МБ",
          "Upper": "Меньше чем",
          "Upper-Help": "Значение должно быть меньше этого числа мегабайт. Оставьте 0, чтобы не проверять верхний предел.",
          "Upper-Suffix": "МБ"
        },
        "Outputs": {
          "1": "Размер файла в пределах диапазона",
          "2": "Размер файла вне диапазона"
        }
      },
      "FileSizeCompare": {
        "Description": "Проверяет, изменилась ли размер файла по сравнению с оригинальным файлом.",
        "Label": "Сравнение размера файла",
        "Outputs": {
          "1": "Меньше оригинала",
          "2": "Та же величина, что и оригинал",
          "3": "Больше оригинала"
        }
      },
      "FileSizeWithin": {
        "Description": "Проверяет, находится ли новый размер файла в допустимом диапазоне оригинального размера файла.",
        "Label": "Размер файла в пределах",
        "Fields": {
          "Value": "Значение",
          "Value-Help": "Допустимая разница для размера файла, это значение может быть как плюс, так и минус этой разницы."
        },
        "Outputs": {
          "1": "Размер файла в допустимом диапазоне",
          "2": "Размер файла не в допустимом диапазоне"
        }
      },
      "FolderDateCompare": {
        "Description": "Проверяет, совпадает ли дата создания или последнего изменения папки с указанными ограничениями по дате.",
        "Label": "Сравнение даты папки",
        "Fields": {
          "Date": "Дата",
          "DateComparision": "Сравнение",
          "Path": "Путь",
          "Path-Help": "Путь к папке для проверки. Оставьте пустым, чтобы проверить текущий рабочий файл.\nЕсли указан файл, будет проверена папка, содержащая этот файл."
        },
        "Outputs": {
          "1": "Совпадает с ограничениями по дате.",
          "2": "Не совпадает с ограничениями по дате."
        }
      },
      "FolderIterator": {
        "Description": "Итерирует все файлы в заданной папке и выполняет эти файлы в рамках подфункции.",
        "Label": "Итератор папки",
        "Fields": {
          "Flow": "Поток",
          "Flow-Help": "Подфункция, в рамках которой будут выполнены файлы.",
          "Folder": "Папка",
          "Folder-Help": "Папка, файлы которой будут итерированы.",
          "Pattern": "Шаблон",
          "Pattern-Help": "Любой необязательный шаблон для ограничения файлов для итерации, это может быть шаблон с подстановочным знаком, начинающийся с `*`, или регулярное выражение.",
          "Recursive": "Рекурсивный",
          "Recursive-Help": "Должны ли также итерироваться файлы во всех подпапках или только файлы верхнего уровня."
        },
        "Outputs": {
          "1": "Файлы папки итерированы"
        }
      },
      "Function": {
        "Label": "Функция",
        "Fields": {
          "Code": "Код",
          "Code-Help": "верните -1 для ошибки и остановки потока. верните 0 для завершения потока. верните 1 или более для вызова желаемого вывода.",
          "Outputs": "Выводы",
          "Template": "Шаблон",
          "Template-Help": "ПРЕДУПРЕЖДЕНИЕ: Это заменит все, что находится в блоке кода, на выбранный вами шаблон."
        },
        "Outputs": {
          "1": "возврат 1",
          "10": "возврат 10",
          "2": "возврат 2",
          "3": "возврат 3",
          "4": "возврат 4",
          "5": "возврат 5",
          "6": "возврат 6",
          "7": "возврат 7",
          "8": "возврат 8",
          "9": "возврат 9"
        }
      },
      "GotoFlow": {
        "Description": "Это позволяет вам переключиться на другой поток для обработки. Этот поток завершится, а параметры и рабочий файл будут переданы в новый поток.",
        "Label": "Перейти к потоку",
        "Fields": {
          "Flow": "Поток",
          "UpdateFlowUsed": "Обновить поток",
          "UpdateFlowUsed-Help": "Если файл `Поток` должен быть обновлен для ссылки на этот новый поток или оставить его как исходный поток."
        }
      },
      "HasHardLinks": {
        "Description": "Проверяет, есть ли у файла жесткие ссылки или нет",
        "Label": "Есть жесткие ссылки",
        "Fields": {
          "Count": "Количество",
          "Count-Help": "Количество жестких ссылок, необходимых для вызова вывода 1.",
          "FileName": "Имя файла",
          "FileName-Help": "Файл для проверки. Оставьте пустым, чтобы проверить текущий рабочий файл."
        },
        "Outputs": {
          "1": "Обнаружены жесткие ссылки",
          "2": "Жесткие ссылки не обнаружены"
        }
      },
      "IfBoolean": {
        "Description": "Проверяет, истинна ли переменная или ложна",
        "Label": "Если логическое",
        "Fields": {
          "Variable": "Переменная",
          "Variable-Help": "Имя переменной для проверки"
        },
        "Outputs": {
          "1": "Истина",
          "2": "Ложь"
        }
      },
      "IfString": {
        "Description": "Проверяет, соответствует ли переменная строке",
        "Label": "Если строка",
        "Fields": {
          "Options": "Опции",
          "Options-Help": "Строка для сопоставления.",
          "Outputs": "Выходы",
          "Outputs-Help": "Это должно соответствовать количеству доступных опций",
          "Variable": "Переменная",
          "Variable-Help": "Имя переменной для проверки"
        },
        "Outputs": {
          "1": "Совпадение строки 1",
          "10": "Совпадение строки 10",
          "2": "Совпадение строки 2",
          "3": "Совпадение строки 3",
          "4": "Совпадение строки 4",
          "5": "Совпадение строки 5",
          "6": "Совпадение строки 6",
          "7": "Совпадение строки 7",
          "8": "Совпадение строки 8",
          "9": "Совпадение строки 9"
        }
      },
      "InputFile": {
        "Description": "Элемент входного потока для файла. Это обязательно и является отправной точкой потока. Можно использовать любой элемент входного потока, но требуется хотя бы один.",
        "Label": "Входной файл",
        "Outputs": {
          "1": "Файл библиотеки"
        }
      },
      "InputFolder": {
        "Description": "Элемент входного потока для папки. Это будет работать только в том случае, если библиотека, использующая этот поток, настроена для работы с папками.",
        "Label": "Входная папка",
        "Outputs": {
          "1": "Папка библиотеки"
        }
      },
      "IsDocker": {
        "Description": "Определяет, работает ли этот поток в Docker",
        "Label": "Это Docker",
        "Outputs": {
          "1": "Работает в Docker",
          "2": "Не работает в Docker"
        }
      },
      "IsFromLibrary": {
        "Description": "Проверяет, поступает ли обрабатываемый файл из указанной библиотеки.",
        "Label": "Из библиотеки",
        "Fields": {
          "Library": "Библиотека",
          "Library-Help": "Библиотека для проверки."
        },
        "Outputs": {
          "1": "Файл из указанной библиотеки.",
          "2": "Файл не из указанной библиотеки."
        }
      },
      "IsLinux": {
        "Description": "Определяет, работает ли этот поток в Linux",
        "Label": "Это Linux",
        "Outputs": {
          "1": "Работает в Linux",
          "2": "Не работает в Linux"
        }
      },
      "IsMacOS": {
        "Description": "Определяет, выполняется ли этот поток на MacOS",
        "Label": "Это MacOS",
        "Outputs": {
          "1": "Выполняется на MacOS",
          "2": "Не выполняется на MacOS"
        }
      },
      "IsProcessingOnNode": {
        "Description": "Проверяет, обрабатывает ли поток в данный момент на указанном узле обработки.",
        "Label": "Обрабатывается на узле",
        "Fields": {
          "Node": "Узел",
          "Node-Help": "Узел обработки для проверки."
        },
        "Outputs": {
          "1": "Обрабатывает на узле",
          "2": "Не обрабатывает на узле"
        }
      },
      "IsWindows": {
        "Description": "Определяет, выполняется ли этот поток на Windows",
        "Label": "Это Windows",
        "Outputs": {
          "1": "Выполняется на Windows",
          "2": "Не выполняется на Windows"
        }
      },
      "ListIterator": {
        "Description": "Итерирует все строки в данном списке и выполняет эти строки против подгруппы.",
        "Label": "Итератор списка",
        "Fields": {
          "Flow": "Поток",
          "Flow-Help": "Подгруппа, против которой будут выполнены строки.",
          "List": "Список",
          "List-Help": "Имя переменной, содержащей список для итерации."
        },
        "Outputs": {
          "1": "Список итераций завершен"
        }
      },
      "Log": {
        "Description": "Записывает сообщение в журнал потока",
        "Label": "Журнал",
        "Fields": {
          "LogType": "Тип",
          "Message": "Сообщение"
        },
        "Outputs": {
          "1": "Сообщение записано"
        }
      },
      "LogImage": {
        "Description": "Записывает изображение в журнал",
        "Label": "Журнал изображения",
        "Fields": {
          "ImageFile": "Изображение",
          "ImageFile-Help": "Файл изображения для записи в журнал"
        },
        "Outputs": {
          "1": "Изображение записано в журнал",
          "2": "Не удалось записать изображение в журнал"
        }
      },
      "LogVariables": {
        "Description": "Логирует все переменные в потоке в файл журнала для отладки.",
        "Label": "Логировать Переменные",
        "Fields": {
          "Recursive": "Детализированный Лог",
          "Recursive-Help": "Если включено, сложные переменные будут включать все их вложенные свойства в журнал."
        },
        "Outputs": {
          "1": "Переменные успешно записаны в журнал."
        }
      },
      "Matches": {
        "Description": "Сравнивает набор значений и сопоставляет условия, чтобы увидеть, какой вывод следует вызвать",
        "Label": "Соответствует",
        "Fields": {
          "MatchConditions": "",
          "MatchConditions-Help": "Сопоставления для проверки, какой вывод следует вызвать.",
          "MatchConditionsKey": "Значение",
          "MatchConditionsValue": "Выражение"
        }
      },
      "MatchesAll": {
        "Description": "Сравнивает набор значений и проверяет, соответствуют ли все условия.",
        "Label": "Соответствует всем",
        "Fields": {
          "MatchConditions": "",
          "MatchConditionsHelp": "Условия для проверки, определяющие, какой вывод следует вызвать.",
          "MatchConditionsKey": "Значение",
          "MatchConditionsValue": "Выражение"
        },
        "Outputs": {
          "1": "Все условия совпадают",
          "2": "Не все условия совпадают"
        }
      },
      "MoveFile": {
        "Description": "Перемещает файл в целевую папку",
        "Label": "Переместить файл",
        "Fields": {
          "AdditionalFiles": "Дополнительные Файлы",
          "AdditionalFiles-Help": "Дополнительные файлы, которые нужно переместить из директории в новую директорию.\nКаждое значение может содержать комбинацию допустимого литерального пути и символов подстановки (* и ?), но не поддерживает регулярные выражения.",
          "AdditionalFilesFromOriginal": "Исходная Директория",
          "AdditionalFilesFromOriginal-Help": "Должны ли дополнительные файлы перемещаться из рабочей директории или из исходной директории. Включите для исходной директории.",
          "DeleteOriginal": "Удалить Исходный",
          "DeleteOriginal-Help": "Если исходный файл должен быть удален, это произойдет только в том случае, если рабочий файл отличается от исходного файла.",
          "DestinationFile": "Целевой Файл",
          "DestinationFile-Help": "Имя файла, в который нужно переместить файл. Если пусто, будет использовано исходное имя файла.",
          "DestinationPath": "Целевая Папка",
          "DestinationPath-Help": "Папка, в которую будет перемещен файл.",
          "InputFile": "Файл Для Перемещения",
          "InputFile-Help": "Файл, который нужно переместить; если оставлено пустым, будет перемещен рабочий файл.",
          "InputFile-Placeholder": "Рабочий Файл",
          "MoveFolder": "Копировать Папку",
          "MoveFolder-Help": "Должна ли также быть скопирована относительная структура папки библиотеки.",
          "PreserverOriginalDates": "Сохранить Даты",
          "PreserverOriginalDates-Help": "Должны ли быть сохранены оригинальное время создания и последнее время записи оригинального входного файла."
        },
        "Outputs": {
          "1": "Файл перемещен",
          "2": "Файл перемещен, однако исходный файл не удалось удалить"
        }
      },
      "MoveFolder": {
        "Description": "Перемещает папку",
        "Label": "Переместить папку",
        "Fields": {
          "CreateSubfolder": "Создать Подпапку",
          "CreateSubfolder-Help": "Должна ли быть создана подпапка с именем исходной папки в целевой папке.",
          "DestinationPath": "Назначение",
          "DestinationPath-Help": "Целевая папка, куда нужно переместить исходную папку.",
          "SourcePath": "Исходник",
          "SourcePath-Help": "Папка, которую нужно переместить; если оставить пустой, будет использован рабочий файл. Если это не папка, элемент потока завершится с ошибкой."
        },
        "Outputs": {
          "1": "Папка перемещена"
        }
      },
      "OlderThan": {
        "Description": "Проверяет, старше ли папка заданного диапазона",
        "Label": "Старше чем",
        "Fields": {
          "Date": "Дата",
          "Number": "Число",
          "Unit": "Единица"
        },
        "Outputs": {
          "1": "Файл старше",
          "2": "Файл не старше"
        }
      },
      "OriginalFile": {
        "Description": "Устанавливает текущий рабочий файл в потоке как оригинальный файл, который запустил поток",
        "Label": "Оригинальный файл",
        "Outputs": {
          "1": "Рабочий файл установлен на оригинальный файл"
        }
      },
      "PatternMatch": {
        "Description": "Тестирует рабочий файл и оригинальный файл по регулярному выражению.\n\nВыход 1: Совпадает с выражением\nВыход 2: Не совпадает",
        "Label": "Совпадение шаблона",
        "Fields": {
          "Pattern": "Шаблон",
          "Pattern-Help": "Регулярное выражение, использующее спецификацию C# для регулярных выражений."
        },
        "Outputs": {
          "1": "Совпадает с выражением",
          "2": "НЕ совпадает"
        }
      },
      "PatternReplacer": {
        "Description": "Позволяет делать замены в имени файла. Может использовать регулярные выражения для замен или простые строковые замены.\n\nВыход 1: Замена выполнена\nВыход 2: Замена не выполнена",
        "Label": "Замена шаблона имени файла",
        "Fields": {
          "Replacements": "Замены",
          "ReplacementsKey": "Шаблон",
          "ReplacementsValue": "Значение",
          "UseWorkingFileName": "Использовать рабочее имя файла",
          "UseWorkingFileName-Help": "Если должно быть использовано текущее рабочее имя файла, или если это ложь, будет использовано оригинальное имя входящего файла."
        },
        "Outputs": {
          "1": "Замена выполнена",
          "2": "Замена не выполнена"
        }
      },
      "PowerShellScript": {
        "Description": "Позволяет выполнять скрипт PowerShell (.ps1) в среде Windows.",
        "Label": "Скрипт PowerShell (.ps1)",
        "Fields": {
          "Code": "Код"
        },
        "Outputs": {
          "1": "Вернул 1",
          "10": "Вернул 10",
          "2": "Вернул 2",
          "3": "Вернул 3",
          "4": "Вернул 4",
          "5": "Вернул 5",
          "6": "Вернул 6",
          "7": "Вернул 7",
          "8": "Вернул 8",
          "9": "Вернул 9"
        }
      },
      "Random": {
        "Description": "Выбор случайного вывода",
        "Label": "Случайный",
        "Fields": {
          "Outputs": "Выводы",
          "Outputs-Help": "Количество выводов, которые могут быть вызваны."
        }
      },
      "Renamer": {
        "Description": "Переименовывает рабочий файл.\nПеременные могут использоваться, вводя '{' в поле шаблона.",
        "Label": "Переименовщик",
        "Fields": {
          "CsvFile": "CSV-файл",
          "CsvFile-Help": "Добавляет к этому файлу оригинальное и переименованное имя. Полезно, если вы используете ''Только журнал'', чтобы протестировать переименовщик перед изменением файлов.",
          "DestinationPath": "Папка назначения",
          "DestinationPath-Help": "Должен ли файл быть перемещен в другую папку.",
          "LogOnly": "Только журнал",
          "LogOnly-Help": "Включите, если хотите просто протестировать этот элемент потока без фактического переименования файла.",
          "Pattern": "Новое имя",
          "Pattern-Help": "Новое имя файла. Может использовать переменные. Все пустые () и '{}' будут удалены."
        },
        "Outputs": {
          "1": "Файл переименован"
        }
      },
      "ReplaceOriginal": {
        "Description": "Заменяет оригинальный файл рабочим файлом.\n\nЕсли расширение рабочего файла отличается, оригинальный файл будет удален, а рабочий файл будет перемещен в оригинальный файл с новым расширением.\nНапример, с File.avi на File.mkv",
        "Label": "Заменить оригинал",
        "Fields": {
          "PreserverOriginalDates": "Сохранить Даты",
          "PreserverOriginalDates-Help": "Необходимо ли сохранить оригинальное время создания и время последнего изменения входного файла."
        },
        "Outputs": {
          "1": "Оригинальный файл заменен"
        }
      },
      "Reprocess": {
        "Description": "Этот элемент потока позволяет повторно обработать оригинальный библиотечный файл с помощью другого узла обработки.\n\nЕсли выбран тот же узел обработки, который сейчас обрабатывается, поток завершится неудачей.",
        "Label": "Повторная обработка",
        "Fields": {
          "HoldMinutes": "Время удержания (минуты)",
          "HoldMinutes-Help": "Количество минут для удержания файла перед его повторной обработкой. Используйте 0 для немедленной обработки.",
          "Node": "Узел",
          "Node-Help": "Узел обработки для обработки этого файла."
        }
      },
      "SetVariable": {
        "Description": "Устанавливает переменную в потоке.",
        "Label": "Установить Переменную",
        "Fields": {
          "Value": "Значение",
          "Value-Help": "Значение переменной, которую нужно установить.",
          "Variable": "Переменная",
          "Variable-Help": "Имя переменной для установки"
        },
        "Outputs": {
          "1": "Переменная установлена"
        }
      },
      "SetWorkingFile": {
        "Description": "Обновляет текущий рабочий файл указанным файлом.",
        "Label": "Установить Рабочий Файл",
        "Fields": {
          "DontDeletePrevious": "Не Удалять Предыдущий",
          "DontDeletePrevious-Help": "Если предыдущий *временный* рабочий файл *не* должен быть удален.\nБудут удалены только временные файлы, созданные FileFlows в временной папке исполнителей.",
          "File": "Файл",
          "File-Description": "Путь к новому рабочему файлу или папке."
        },
        "Outputs": {
          "1": "Рабочий файл установлен"
        }
      },
      "SevenZip": {
        "Description": "Позволяет сжимать входные данные в формате 7zip.",
        "Label": "7-Zip",
        "Fields": {
          "CompressionLevel": "Уровень Сжатия",
          "CompressionLevel-Help": "Уровень сжатия, который следует использовать при сжатии.",
          "CompressionMethod": "Метод Сжатия",
          "CompressionMethod-Help": "Используемый метод сжатия, рекомендуется LZMA2.",
          "DestinationFile": "Файл Назначения",
          "DestinationFile-Help": "Имя нового 7zip-файла. Если оставить пустым, будет использовано имя элемента как 7zip-файл.",
          "DestinationPath": "Путь Назначения",
          "DestinationPath-Help": "Папка назначения, в которую поместить 7zip-файл. Если оставить пустым, 7zip будет помещен в корень библиотеки."
        },
        "Outputs": {
          "1": "7zip создан"
        }
      },
      "ShellScript": {
        "Description": "Позволяет вам выполнять скрипт оболочки (.sh) в среде, подобной Unix.",
        "Label": "Скрипт оболочки (.sh)",
        "Fields": {
          "Code": "Код"
        },
        "Outputs": {
          "1": "возвращено 1",
          "10": "возвращено 10",
          "2": "возвращено 2",
          "3": "возвращено 3",
          "4": "возвращено 4",
          "5": "возвращено 5",
          "6": "возвращено 6",
          "7": "возвращено 7",
          "8": "возвращено 8",
          "9": "возвращено 9"
        }
      },
      "Sleep": {
        "Description": "Приостанавливает поток",
        "Label": "Сон",
        "Fields": {
          "Milliseconds": "Миллисекунды",
          "Milliseconds-Help": "На сколько времени приостановить поток. Должно быть от 1 миллисекунды до 1 часа."
        },
        "Outputs": {
          "1": "Поток возобновлен"
        }
      },
      "Tag": {
        "Description": "Присваивает файлу указанные теги",
        "Label": "Тег",
        "Fields": {
          "Replace": "Заменить",
          "Replace-Help": "Следует ли заменить теги или добавить их к существующим тегам.",
          "Tags": "Теги"
        }
      },
      "Touch": {
        "Description": "Обновляет файл или каталог и устанавливает время последней записи на текущее время.",
        "Label": "Трогать",
        "Fields": {
          "FileName": "Имя файла",
          "FileName-Help": "Полное имя файла или папки для обновления.\nЕсли оставить пустым, будет использован рабочий файл."
        },
        "Outputs": {
          "1": "Элемент успешно обновлен"
        }
      },
      "Unpack": {
        "Description": "Позволяет распаковать архив (zip, rar, tar и т. д.)",
        "Label": "Распаковать",
        "Fields": {
          "DestinationPath": "Папка назначения",
          "DestinationPath-Help": "Папка назначения, куда нужно распаковать файл.",
          "File": "Файл",
          "File-Help": "Имя файла для распаковки. Может быть оставлено пустым, и в этом случае будет использован текущий рабочий файл."
        },
        "Outputs": {
          "1": "Файл распакован"
        }
      },
      "VariableMatch": {
        "Description": "Проверяет, соответствует ли входное значение сохраненной переменной.",
        "Label": "Соответствие переменной",
        "Fields": {
          "Input": "Значение",
          "Input-Help": "Значение, с которым необходимо сравнить переменную.",
          "Variable": "Переменная",
          "Variable-Help": "Переменная, с которой нужно сравнить",
          "VariableName": "Переменная",
          "VariableName-Help": "Переменная, с которой нужно сравнить"
        },
        "Outputs": {
          "1": "Входное значение соответствует переменной",
          "2": "Входное значение не соответствует переменной"
        }
      },
      "WebRequest": {
        "Description": "Позволяет отправлять веб-запрос",
        "Label": "Веб-запрос",
        "Fields": {
          "Body": "Тело",
          "Body-Help": "Тело отправляемого запроса. В этом поле можно использовать переменные.",
          "ContentType": "Тип содержимого",
          "ContentType-Help": "Content-Type сообщения для отправки",
          "Headers": "Заголовки",
          "Headers-Help": "Необязательные заголовки для отправки с запросом",
          "HeadersKey": "Ключ",
          "HeadersValue": "Значение",
          "Method": "Метод",
          "Method-Help": "Веб-метод, который следует использовать при отправке этого запроса",
          "Url": "URL",
          "Url-Help": "URL запроса"
        },
        "Outputs": {
          "1": "Успешно отправлено",
          "2": "Запрос вернул неуспешный код состояния"
        }
      },
      "WriteText": {
        "Description": "Записывает текст в файл",
        "Label": "Записать текст",
        "Fields": {
          "File": "Файл",
          "File-Help": "Файл, в который нужно записать текст.",
          "Text": "Текст",
          "Text-Help": "Текст для записи в файл. Если оставить пустым, будет записан полный путь к текущему рабочему файлу."
        },
        "Outputs": {
          "1": "Текст записан в файл"
        }
      },
      "Zip": {
        "Description": "Позволяет заархивировать входные данные",
        "Label": "Zip",
        "Fields": {
          "DestinationFile": "Файл назначения",
          "DestinationFile-Help": "Имя файла вновь созданного zip. Если пусто, будет использовано имя элемента в качестве zip-файла.",
          "DestinationPath": "Папка назначения",
          "DestinationPath-Help": "Папка назначения, в которую нужно поместить zip-файл. Если пусто, zip будет размещен в корне библиотеки.",
          "Path": "Путь",
          "Path-Help": "Путь к файлу или папке, которые нужно заархивировать. Если пусто, будет заархивирован рабочий файл.",
          "SetWorkingFile": "Установить рабочий файл",
          "SetWorkingFile-Help": "Должен ли вновь созданный zip стать новым рабочим файлом."
        },
        "Outputs": {
          "1": "Zip создан"
        }
      }
    }
  },
  "Plugins": {
    "BasicNodes": {
      "Description": "Базовые элементы потока для FileFlows. Этот плагин содержит базовые и общие элементы потока для обработки файлов.\nЭтот плагин необходим для работы FileFlows.",
      "Label": "Базовый"
    }
  }
}